1 /* Handle parameterized types (templates) for GNU -*- C++ -*-.
2 Copyright (C) 1992-2015 Free Software Foundation, Inc.
3 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
4 Rewritten by Jason Merrill (jason@cygnus.com).
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* Known bugs or deficiencies include:
24 all methods must be provided in header files; can't use a source
25 file that contains only the method templates and "just win". */
29 #include "coretypes.h"
34 #include "double-int.h"
41 #include "stringpool.h"
44 #include "stor-layout.h"
48 #include "c-family/c-common.h"
49 #include "c-family/c-objc.h"
50 #include "cp-objcp-common.h"
51 #include "tree-inline.h"
55 #include "tree-iterator.h"
56 #include "type-utils.h"
59 /* The type of functions taking a tree, and some additional data, and
61 typedef int (*tree_fn_t) (tree, void*);
63 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
64 instantiations have been deferred, either because their definitions
65 were not yet available, or because we were putting off doing the work. */
66 struct GTY ((chain_next ("%h.next"))) pending_template {
67 struct pending_template *next;
68 struct tinst_level *tinst;
71 static GTY(()) struct pending_template *pending_templates;
72 static GTY(()) struct pending_template *last_pending_template;
74 int processing_template_parmlist;
75 static int template_header_count;
77 static GTY(()) tree saved_trees;
78 static vec<int> inline_parm_levels;
80 static GTY(()) struct tinst_level *current_tinst_level;
82 static GTY(()) tree saved_access_scope;
84 /* Live only within one (recursive) call to tsubst_expr. We use
85 this to pass the statement expression node from the STMT_EXPR
86 to the EXPR_STMT that is its result. */
87 static tree cur_stmt_expr;
89 /* True if we've recursed into fn_type_unification too many times. */
90 static bool excessive_deduction_depth;
92 struct GTY((for_user)) spec_entry
99 struct spec_hasher : ggc_hasher<spec_entry *>
101 static hashval_t hash (spec_entry *);
102 static bool equal (spec_entry *, spec_entry *);
105 static GTY (()) hash_table<spec_hasher> *decl_specializations;
107 static GTY (()) hash_table<spec_hasher> *type_specializations;
109 /* Contains canonical template parameter types. The vector is indexed by
110 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
111 TREE_LIST, whose TREE_VALUEs contain the canonical template
112 parameters of various types and levels. */
113 static GTY(()) vec<tree, va_gc> *canonical_template_parms;
115 #define UNIFY_ALLOW_NONE 0
116 #define UNIFY_ALLOW_MORE_CV_QUAL 1
117 #define UNIFY_ALLOW_LESS_CV_QUAL 2
118 #define UNIFY_ALLOW_DERIVED 4
119 #define UNIFY_ALLOW_INTEGER 8
120 #define UNIFY_ALLOW_OUTER_LEVEL 16
121 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
122 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
124 enum template_base_result {
126 tbr_ambiguous_baseclass,
130 static void push_access_scope (tree);
131 static void pop_access_scope (tree);
132 static bool resolve_overloaded_unification (tree, tree, tree, tree,
133 unification_kind_t, int,
135 static int try_one_overload (tree, tree, tree, tree, tree,
136 unification_kind_t, int, bool, bool);
137 static int unify (tree, tree, tree, tree, int, bool);
138 static void add_pending_template (tree);
139 static tree reopen_tinst_level (struct tinst_level *);
140 static tree tsubst_initializer_list (tree, tree);
141 static tree get_partial_spec_bindings (tree, tree, tree, tree);
142 static tree coerce_template_parms (tree, tree, tree, tsubst_flags_t,
144 static tree coerce_innermost_template_parms (tree, tree, tree, tsubst_flags_t,
146 static void tsubst_enum (tree, tree, tree);
147 static tree add_to_template_args (tree, tree);
148 static tree add_outermost_template_args (tree, tree);
149 static bool check_instantiated_args (tree, tree, tsubst_flags_t);
150 static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*,
152 static int type_unification_real (tree, tree, tree, const tree *,
153 unsigned int, int, unification_kind_t, int,
154 vec<deferred_access_check, va_gc> **,
156 static void note_template_header (int);
157 static tree convert_nontype_argument_function (tree, tree, tsubst_flags_t);
158 static tree convert_nontype_argument (tree, tree, tsubst_flags_t);
159 static tree convert_template_argument (tree, tree, tree,
160 tsubst_flags_t, int, tree);
161 static int for_each_template_parm (tree, tree_fn_t, void*,
162 hash_set<tree> *, bool);
163 static tree expand_template_argument_pack (tree);
164 static tree build_template_parm_index (int, int, int, tree, tree);
165 static bool inline_needs_template_parms (tree, bool);
166 static void push_inline_template_parms_recursive (tree, int);
167 static tree retrieve_local_specialization (tree);
168 static void register_local_specialization (tree, tree);
169 static tree reduce_template_parm_level (tree, tree, int, tree, tsubst_flags_t);
170 static int mark_template_parm (tree, void *);
171 static int template_parm_this_level_p (tree, void *);
172 static tree tsubst_friend_function (tree, tree);
173 static tree tsubst_friend_class (tree, tree);
174 static int can_complete_type_without_circularity (tree);
175 static tree get_bindings (tree, tree, tree, bool);
176 static int template_decl_level (tree);
177 static int check_cv_quals_for_unify (int, tree, tree);
178 static void template_parm_level_and_index (tree, int*, int*);
179 static int unify_pack_expansion (tree, tree, tree,
180 tree, unification_kind_t, bool, bool);
181 static tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree);
182 static tree tsubst_template_args (tree, tree, tsubst_flags_t, tree);
183 static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
184 static void regenerate_decl_from_template (tree, tree);
185 static tree most_specialized_partial_spec (tree, tsubst_flags_t);
186 static tree tsubst_aggr_type (tree, tree, tsubst_flags_t, tree, int);
187 static tree tsubst_arg_types (tree, tree, tree, tsubst_flags_t, tree);
188 static tree tsubst_function_type (tree, tree, tsubst_flags_t, tree);
189 static bool check_specialization_scope (void);
190 static tree process_partial_specialization (tree);
191 static void set_current_access_from_decl (tree);
192 static enum template_base_result get_template_base (tree, tree, tree, tree,
194 static tree try_class_unification (tree, tree, tree, tree, bool);
195 static int coerce_template_template_parms (tree, tree, tsubst_flags_t,
197 static bool template_template_parm_bindings_ok_p (tree, tree);
198 static int template_args_equal (tree, tree);
199 static void tsubst_default_arguments (tree, tsubst_flags_t);
200 static tree for_each_template_parm_r (tree *, int *, void *);
201 static tree copy_default_args_to_explicit_spec_1 (tree, tree);
202 static void copy_default_args_to_explicit_spec (tree);
203 static int invalid_nontype_parm_type_p (tree, tsubst_flags_t);
204 static bool dependent_template_arg_p (tree);
205 static bool any_template_arguments_need_structural_equality_p (tree);
206 static bool dependent_type_p_r (tree);
207 static tree tsubst_expr (tree, tree, tsubst_flags_t, tree, bool);
208 static tree tsubst_copy (tree, tree, tsubst_flags_t, tree);
209 static tree tsubst_pack_expansion (tree, tree, tsubst_flags_t, tree);
210 static tree tsubst_decl (tree, tree, tsubst_flags_t);
211 static void perform_typedefs_access_check (tree tmpl, tree targs);
212 static void append_type_to_template_for_access_check_1 (tree, tree, tree,
214 static tree listify (tree);
215 static tree listify_autos (tree, tree);
216 static tree template_parm_to_arg (tree t);
217 static tree current_template_args (void);
218 static tree tsubst_template_parm (tree, tree, tsubst_flags_t);
219 static tree instantiate_alias_template (tree, tree, tsubst_flags_t);
221 /* Make the current scope suitable for access checking when we are
222 processing T. T can be FUNCTION_DECL for instantiated function
223 template, VAR_DECL for static member variable, or TYPE_DECL for
224 alias template (needed by instantiate_decl). */
227 push_access_scope (tree t)
229 gcc_assert (VAR_OR_FUNCTION_DECL_P (t)
230 || TREE_CODE (t) == TYPE_DECL);
232 if (DECL_FRIEND_CONTEXT (t))
233 push_nested_class (DECL_FRIEND_CONTEXT (t));
234 else if (DECL_CLASS_SCOPE_P (t))
235 push_nested_class (DECL_CONTEXT (t));
237 push_to_top_level ();
239 if (TREE_CODE (t) == FUNCTION_DECL)
241 saved_access_scope = tree_cons
242 (NULL_TREE, current_function_decl, saved_access_scope);
243 current_function_decl = t;
247 /* Restore the scope set up by push_access_scope. T is the node we
251 pop_access_scope (tree t)
253 if (TREE_CODE (t) == FUNCTION_DECL)
255 current_function_decl = TREE_VALUE (saved_access_scope);
256 saved_access_scope = TREE_CHAIN (saved_access_scope);
259 if (DECL_FRIEND_CONTEXT (t) || DECL_CLASS_SCOPE_P (t))
262 pop_from_top_level ();
265 /* Do any processing required when DECL (a member template
266 declaration) is finished. Returns the TEMPLATE_DECL corresponding
267 to DECL, unless it is a specialization, in which case the DECL
268 itself is returned. */
271 finish_member_template_decl (tree decl)
273 if (decl == error_mark_node)
274 return error_mark_node;
276 gcc_assert (DECL_P (decl));
278 if (TREE_CODE (decl) == TYPE_DECL)
282 type = TREE_TYPE (decl);
283 if (type == error_mark_node)
284 return error_mark_node;
285 if (MAYBE_CLASS_TYPE_P (type)
286 && CLASSTYPE_TEMPLATE_INFO (type)
287 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
289 tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
290 check_member_template (tmpl);
295 else if (TREE_CODE (decl) == FIELD_DECL)
296 error ("data member %qD cannot be a member template", decl);
297 else if (DECL_TEMPLATE_INFO (decl))
299 if (!DECL_TEMPLATE_SPECIALIZATION (decl))
301 check_member_template (DECL_TI_TEMPLATE (decl));
302 return DECL_TI_TEMPLATE (decl);
308 error ("invalid member template declaration %qD", decl);
310 return error_mark_node;
313 /* Create a template info node. */
316 build_template_info (tree template_decl, tree template_args)
318 tree result = make_node (TEMPLATE_INFO);
319 TI_TEMPLATE (result) = template_decl;
320 TI_ARGS (result) = template_args;
324 /* Return the template info node corresponding to T, whatever T is. */
327 get_template_info (const_tree t)
329 tree tinfo = NULL_TREE;
331 if (!t || t == error_mark_node)
334 if (TREE_CODE (t) == NAMESPACE_DECL)
337 if (DECL_P (t) && DECL_LANG_SPECIFIC (t))
338 tinfo = DECL_TEMPLATE_INFO (t);
340 if (!tinfo && DECL_IMPLICIT_TYPEDEF_P (t))
343 if (OVERLOAD_TYPE_P (t))
344 tinfo = TYPE_TEMPLATE_INFO (t);
345 else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
346 tinfo = TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t);
351 /* Returns the template nesting level of the indicated class TYPE.
361 A<T>::B<U> has depth two, while A<T> has depth one.
362 Both A<T>::B<int> and A<int>::B<U> have depth one, if
363 they are instantiations, not specializations.
365 This function is guaranteed to return 0 if passed NULL_TREE so
366 that, for example, `template_class_depth (current_class_type)' is
370 template_class_depth (tree type)
375 type && TREE_CODE (type) != NAMESPACE_DECL;
376 type = (TREE_CODE (type) == FUNCTION_DECL)
377 ? CP_DECL_CONTEXT (type) : CP_TYPE_CONTEXT (type))
379 tree tinfo = get_template_info (type);
381 if (tinfo && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo))
382 && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo))))
389 /* Subroutine of maybe_begin_member_template_processing.
390 Returns true if processing DECL needs us to push template parms. */
393 inline_needs_template_parms (tree decl, bool nsdmi)
395 if (!decl || (!nsdmi && ! DECL_TEMPLATE_INFO (decl)))
398 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl)))
399 > (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl)));
402 /* Subroutine of maybe_begin_member_template_processing.
403 Push the template parms in PARMS, starting from LEVELS steps into the
404 chain, and ending at the beginning, since template parms are listed
408 push_inline_template_parms_recursive (tree parmlist, int levels)
410 tree parms = TREE_VALUE (parmlist);
414 push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1);
416 ++processing_template_decl;
417 current_template_parms
418 = tree_cons (size_int (processing_template_decl),
419 parms, current_template_parms);
420 TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1;
422 begin_scope (TREE_VEC_LENGTH (parms) ? sk_template_parms : sk_template_spec,
424 for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
426 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
428 if (error_operand_p (parm))
431 gcc_assert (DECL_P (parm));
433 switch (TREE_CODE (parm))
442 /* Make a CONST_DECL as is done in process_template_parm.
443 It is ugly that we recreate this here; the original
444 version built in process_template_parm is no longer
446 tree decl = build_decl (DECL_SOURCE_LOCATION (parm),
447 CONST_DECL, DECL_NAME (parm),
449 DECL_ARTIFICIAL (decl) = 1;
450 TREE_CONSTANT (decl) = 1;
451 TREE_READONLY (decl) = 1;
452 DECL_INITIAL (decl) = DECL_INITIAL (parm);
453 SET_DECL_TEMPLATE_PARM_P (decl);
464 /* Restore the template parameter context for a member template, a
465 friend template defined in a class definition, or a non-template
466 member of template class. */
469 maybe_begin_member_template_processing (tree decl)
473 bool nsdmi = TREE_CODE (decl) == FIELD_DECL;
477 tree ctx = DECL_CONTEXT (decl);
478 decl = (CLASSTYPE_TEMPLATE_INFO (ctx)
479 /* Disregard full specializations (c++/60999). */
480 && uses_template_parms (ctx)
481 ? CLASSTYPE_TI_TEMPLATE (ctx) : NULL_TREE);
484 if (inline_needs_template_parms (decl, nsdmi))
486 parms = DECL_TEMPLATE_PARMS (most_general_template (decl));
487 levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl;
489 if (DECL_TEMPLATE_SPECIALIZATION (decl))
492 parms = TREE_CHAIN (parms);
495 push_inline_template_parms_recursive (parms, levels);
498 /* Remember how many levels of template parameters we pushed so that
499 we can pop them later. */
500 inline_parm_levels.safe_push (levels);
503 /* Undo the effects of maybe_begin_member_template_processing. */
506 maybe_end_member_template_processing (void)
511 if (inline_parm_levels.length () == 0)
514 last = inline_parm_levels.pop ();
515 for (i = 0; i < last; ++i)
517 --processing_template_decl;
518 current_template_parms = TREE_CHAIN (current_template_parms);
523 /* Return a new template argument vector which contains all of ARGS,
524 but has as its innermost set of arguments the EXTRA_ARGS. */
527 add_to_template_args (tree args, tree extra_args)
534 if (args == NULL_TREE || extra_args == error_mark_node)
537 extra_depth = TMPL_ARGS_DEPTH (extra_args);
538 new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth);
540 for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i)
541 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));
543 for (j = 1; j <= extra_depth; ++j, ++i)
544 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));
549 /* Like add_to_template_args, but only the outermost ARGS are added to
550 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
551 (EXTRA_ARGS) levels are added. This function is used to combine
552 the template arguments from a partial instantiation with the
553 template arguments used to attain the full instantiation from the
554 partial instantiation. */
557 add_outermost_template_args (tree args, tree extra_args)
561 /* If there are more levels of EXTRA_ARGS than there are ARGS,
562 something very fishy is going on. */
563 gcc_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args));
565 /* If *all* the new arguments will be the EXTRA_ARGS, just return
567 if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
570 /* For the moment, we make ARGS look like it contains fewer levels. */
571 TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);
573 new_args = add_to_template_args (args, extra_args);
575 /* Now, we restore ARGS to its full dimensions. */
576 TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);
581 /* Return the N levels of innermost template arguments from the ARGS. */
584 get_innermost_template_args (tree args, int n)
592 /* If N is 1, just return the innermost set of template arguments. */
594 return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args));
596 /* If we're not removing anything, just return the arguments we were
598 extra_levels = TMPL_ARGS_DEPTH (args) - n;
599 gcc_assert (extra_levels >= 0);
600 if (extra_levels == 0)
603 /* Make a new set of arguments, not containing the outer arguments. */
604 new_args = make_tree_vec (n);
605 for (i = 1; i <= n; ++i)
606 SET_TMPL_ARGS_LEVEL (new_args, i,
607 TMPL_ARGS_LEVEL (args, i + extra_levels));
612 /* The inverse of get_innermost_template_args: Return all but the innermost
613 EXTRA_LEVELS levels of template arguments from the ARGS. */
616 strip_innermost_template_args (tree args, int extra_levels)
619 int n = TMPL_ARGS_DEPTH (args) - extra_levels;
624 /* If N is 1, just return the outermost set of template arguments. */
626 return TMPL_ARGS_LEVEL (args, 1);
628 /* If we're not removing anything, just return the arguments we were
630 gcc_assert (extra_levels >= 0);
631 if (extra_levels == 0)
634 /* Make a new set of arguments, not containing the inner arguments. */
635 new_args = make_tree_vec (n);
636 for (i = 1; i <= n; ++i)
637 SET_TMPL_ARGS_LEVEL (new_args, i,
638 TMPL_ARGS_LEVEL (args, i));
643 /* We've got a template header coming up; push to a new level for storing
647 begin_template_parm_list (void)
649 /* We use a non-tag-transparent scope here, which causes pushtag to
650 put tags in this scope, rather than in the enclosing class or
651 namespace scope. This is the right thing, since we want
652 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
653 global template class, push_template_decl handles putting the
654 TEMPLATE_DECL into top-level scope. For a nested template class,
657 template <class T> struct S1 {
658 template <class T> struct S2 {};
661 pushtag contains special code to call pushdecl_with_scope on the
662 TEMPLATE_DECL for S2. */
663 begin_scope (sk_template_parms, NULL);
664 ++processing_template_decl;
665 ++processing_template_parmlist;
666 note_template_header (0);
669 /* This routine is called when a specialization is declared. If it is
670 invalid to declare a specialization here, an error is reported and
671 false is returned, otherwise this routine will return true. */
674 check_specialization_scope (void)
676 tree scope = current_scope ();
680 An explicit specialization shall be declared in the namespace of
681 which the template is a member, or, for member templates, in the
682 namespace of which the enclosing class or enclosing class
683 template is a member. An explicit specialization of a member
684 function, member class or static data member of a class template
685 shall be declared in the namespace of which the class template
687 if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
689 error ("explicit specialization in non-namespace scope %qD", scope);
695 In an explicit specialization declaration for a member of a class
696 template or a member template that appears in namespace scope,
697 the member template and some of its enclosing class templates may
698 remain unspecialized, except that the declaration shall not
699 explicitly specialize a class member template if its enclosing
700 class templates are not explicitly specialized as well. */
701 if (current_template_parms)
703 error ("enclosing class templates are not explicitly specialized");
710 /* We've just seen template <>. */
713 begin_specialization (void)
715 begin_scope (sk_template_spec, NULL);
716 note_template_header (1);
717 return check_specialization_scope ();
720 /* Called at then end of processing a declaration preceded by
724 end_specialization (void)
727 reset_specialization ();
730 /* Any template <>'s that we have seen thus far are not referring to a
731 function specialization. */
734 reset_specialization (void)
736 processing_specialization = 0;
737 template_header_count = 0;
740 /* We've just seen a template header. If SPECIALIZATION is nonzero,
741 it was of the form template <>. */
744 note_template_header (int specialization)
746 processing_specialization = specialization;
747 template_header_count++;
750 /* We're beginning an explicit instantiation. */
753 begin_explicit_instantiation (void)
755 gcc_assert (!processing_explicit_instantiation);
756 processing_explicit_instantiation = true;
761 end_explicit_instantiation (void)
763 gcc_assert (processing_explicit_instantiation);
764 processing_explicit_instantiation = false;
767 /* An explicit specialization or partial specialization of TMPL is being
768 declared. Check that the namespace in which the specialization is
769 occurring is permissible. Returns false iff it is invalid to
770 specialize TMPL in the current namespace. */
773 check_specialization_namespace (tree tmpl)
775 tree tpl_ns = decl_namespace_context (tmpl);
779 An explicit specialization shall be declared in the namespace of
780 which the template is a member, or, for member templates, in the
781 namespace of which the enclosing class or enclosing class
782 template is a member. An explicit specialization of a member
783 function, member class or static data member of a class template
784 shall be declared in the namespace of which the class template is
786 if (current_scope() != DECL_CONTEXT (tmpl)
787 && !at_namespace_scope_p ())
789 error ("specialization of %qD must appear at namespace scope", tmpl);
792 if (is_associated_namespace (current_namespace, tpl_ns))
793 /* Same or super-using namespace. */
797 permerror (input_location, "specialization of %qD in different namespace", tmpl);
798 permerror (input_location, " from definition of %q+#D", tmpl);
803 /* SPEC is an explicit instantiation. Check that it is valid to
804 perform this explicit instantiation in the current namespace. */
807 check_explicit_instantiation_namespace (tree spec)
811 /* DR 275: An explicit instantiation shall appear in an enclosing
812 namespace of its template. */
813 ns = decl_namespace_context (spec);
814 if (!is_ancestor (current_namespace, ns))
815 permerror (input_location, "explicit instantiation of %qD in namespace %qD "
816 "(which does not enclose namespace %qD)",
817 spec, current_namespace, ns);
820 /* The TYPE is being declared. If it is a template type, that means it
821 is a partial specialization. Do appropriate error-checking. */
824 maybe_process_partial_specialization (tree type)
828 if (type == error_mark_node)
829 return error_mark_node;
831 /* A lambda that appears in specialization context is not itself a
833 if (CLASS_TYPE_P (type) && CLASSTYPE_LAMBDA_EXPR (type))
836 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
838 error ("name of class shadows template template parameter %qD",
840 return error_mark_node;
843 context = TYPE_CONTEXT (type);
845 if (TYPE_ALIAS_P (type))
847 if (TYPE_TEMPLATE_INFO (type)
848 && DECL_ALIAS_TEMPLATE_P (TYPE_TI_TEMPLATE (type)))
849 error ("specialization of alias template %qD",
850 TYPE_TI_TEMPLATE (type));
852 error ("explicit specialization of non-template %qT", type);
853 return error_mark_node;
855 else if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type))
857 /* This is for ordinary explicit specialization and partial
858 specialization of a template class such as:
860 template <> class C<int>;
864 template <class T> class C<T*>;
866 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
868 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
869 && !COMPLETE_TYPE_P (type))
871 if (!check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type))
872 && !at_namespace_scope_p ())
873 return error_mark_node;
874 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
875 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)) = input_location;
876 if (processing_template_decl)
878 if (push_template_decl (TYPE_MAIN_DECL (type))
880 return error_mark_node;
883 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
884 error ("specialization of %qT after instantiation", type);
885 else if (errorcount && !processing_specialization
886 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type)
887 && !uses_template_parms (CLASSTYPE_TI_ARGS (type)))
888 /* Trying to define a specialization either without a template<> header
889 or in an inappropriate place. We've already given an error, so just
890 bail now so we don't actually define the specialization. */
891 return error_mark_node;
893 else if (CLASS_TYPE_P (type)
894 && !CLASSTYPE_USE_TEMPLATE (type)
895 && CLASSTYPE_TEMPLATE_INFO (type)
896 && context && CLASS_TYPE_P (context)
897 && CLASSTYPE_TEMPLATE_INFO (context))
899 /* This is for an explicit specialization of member class
900 template according to [temp.expl.spec/18]:
902 template <> template <class U> class C<int>::D;
904 The context `C<int>' must be an implicit instantiation.
905 Otherwise this is just a member class template declared
908 template <> class C<int> { template <class U> class D; };
909 template <> template <class U> class C<int>::D;
911 In the first case, `C<int>::D' is a specialization of `C<T>::D'
912 while in the second case, `C<int>::D' is a primary template
913 and `C<T>::D' may not exist. */
915 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context)
916 && !COMPLETE_TYPE_P (type))
919 tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
921 if (current_namespace
922 != decl_namespace_context (tmpl))
924 permerror (input_location, "specializing %q#T in different namespace", type);
925 permerror (input_location, " from definition of %q+#D", tmpl);
928 /* Check for invalid specialization after instantiation:
930 template <> template <> class C<int>::D<int>;
931 template <> template <class U> class C<int>::D; */
933 for (t = DECL_TEMPLATE_INSTANTIATIONS (tmpl);
934 t; t = TREE_CHAIN (t))
936 tree inst = TREE_VALUE (t);
937 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst)
938 || !COMPLETE_OR_OPEN_TYPE_P (inst))
940 /* We already have a full specialization of this partial
941 instantiation, or a full specialization has been
942 looked up but not instantiated. Reassign it to the
943 new member specialization template. */
947 elt.tmpl = most_general_template (tmpl);
948 elt.args = CLASSTYPE_TI_ARGS (inst);
951 type_specializations->remove_elt (&elt);
954 elt.args = INNERMOST_TEMPLATE_ARGS (elt.args);
957 = type_specializations->find_slot (&elt, INSERT);
958 entry = ggc_alloc<spec_entry> ();
963 /* But if we've had an implicit instantiation, that's a
964 problem ([temp.expl.spec]/6). */
965 error ("specialization %qT after instantiation %qT",
969 /* Mark TYPE as a specialization. And as a result, we only
970 have one level of template argument for the innermost
972 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
973 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)) = input_location;
974 CLASSTYPE_TI_ARGS (type)
975 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
978 else if (processing_specialization)
980 /* Someday C++0x may allow for enum template specialization. */
981 if (cxx_dialect > cxx98 && TREE_CODE (type) == ENUMERAL_TYPE
982 && CLASS_TYPE_P (context) && CLASSTYPE_USE_TEMPLATE (context))
983 pedwarn (input_location, OPT_Wpedantic, "template specialization "
984 "of %qD not allowed by ISO C++", type);
987 error ("explicit specialization of non-template %qT", type);
988 return error_mark_node;
995 /* Returns nonzero if we can optimize the retrieval of specializations
996 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
997 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
1000 optimize_specialization_lookup_p (tree tmpl)
1002 return (DECL_FUNCTION_TEMPLATE_P (tmpl)
1003 && DECL_CLASS_SCOPE_P (tmpl)
1004 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
1006 && CLASS_TYPE_P (DECL_CONTEXT (tmpl))
1007 /* The optimized lookup depends on the fact that the
1008 template arguments for the member function template apply
1009 purely to the containing class, which is not true if the
1010 containing class is an explicit or partial
1012 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl))
1013 && !DECL_MEMBER_TEMPLATE_P (tmpl)
1014 && !DECL_CONV_FN_P (tmpl)
1015 /* It is possible to have a template that is not a member
1016 template and is not a member of a template class:
1018 template <typename T>
1019 struct S { friend A::f(); };
1021 Here, the friend function is a template, but the context does
1022 not have template information. The optimized lookup relies
1023 on having ARGS be the template arguments for both the class
1024 and the function template. */
1025 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl)));
1028 /* Retrieve the specialization (in the sense of [temp.spec] - a
1029 specialization is either an instantiation or an explicit
1030 specialization) of TMPL for the given template ARGS. If there is
1031 no such specialization, return NULL_TREE. The ARGS are a vector of
1032 arguments, or a vector of vectors of arguments, in the case of
1033 templates with more than one level of parameters.
1035 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1036 then we search for a partial specialization matching ARGS. This
1037 parameter is ignored if TMPL is not a class template.
1039 We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1040 result is a NONTYPE_ARGUMENT_PACK. */
1043 retrieve_specialization (tree tmpl, tree args, hashval_t hash)
1045 if (tmpl == NULL_TREE)
1048 if (args == error_mark_node)
1051 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL
1052 || TREE_CODE (tmpl) == FIELD_DECL);
1054 /* There should be as many levels of arguments as there are
1055 levels of parameters. */
1056 gcc_assert (TMPL_ARGS_DEPTH (args)
1057 == (TREE_CODE (tmpl) == TEMPLATE_DECL
1058 ? TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl))
1059 : template_class_depth (DECL_CONTEXT (tmpl))));
1061 if (optimize_specialization_lookup_p (tmpl))
1063 tree class_template;
1064 tree class_specialization;
1065 vec<tree, va_gc> *methods;
1069 /* The template arguments actually apply to the containing
1070 class. Find the class specialization with those
1072 class_template = CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl));
1073 class_specialization
1074 = retrieve_specialization (class_template, args, 0);
1075 if (!class_specialization)
1077 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
1078 for the specialization. */
1079 idx = class_method_index_for_fn (class_specialization, tmpl);
1082 /* Iterate through the methods with the indicated name, looking
1083 for the one that has an instance of TMPL. */
1084 methods = CLASSTYPE_METHOD_VEC (class_specialization);
1085 for (fns = (*methods)[idx]; fns; fns = OVL_NEXT (fns))
1087 tree fn = OVL_CURRENT (fns);
1088 if (DECL_TEMPLATE_INFO (fn) && DECL_TI_TEMPLATE (fn) == tmpl
1089 /* using-declarations can add base methods to the method vec,
1090 and we don't want those here. */
1091 && DECL_CONTEXT (fn) == class_specialization)
1100 hash_table<spec_hasher> *specializations;
1104 elt.spec = NULL_TREE;
1106 if (DECL_CLASS_TEMPLATE_P (tmpl))
1107 specializations = type_specializations;
1109 specializations = decl_specializations;
1112 hash = spec_hasher::hash (&elt);
1113 found = specializations->find_with_hash (&elt, hash);
1121 /* Like retrieve_specialization, but for local declarations. */
1124 retrieve_local_specialization (tree tmpl)
1126 if (local_specializations == NULL)
1129 tree *slot = local_specializations->get (tmpl);
1130 return slot ? *slot : NULL_TREE;
1133 /* Returns nonzero iff DECL is a specialization of TMPL. */
1136 is_specialization_of (tree decl, tree tmpl)
1140 if (TREE_CODE (decl) == FUNCTION_DECL)
1144 t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
1150 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
1152 for (t = TREE_TYPE (decl);
1154 t = CLASSTYPE_USE_TEMPLATE (t)
1155 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
1156 if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl)))
1163 /* Returns nonzero iff DECL is a specialization of friend declaration
1164 FRIEND_DECL according to [temp.friend]. */
1167 is_specialization_of_friend (tree decl, tree friend_decl)
1169 bool need_template = true;
1172 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
1173 || TREE_CODE (decl) == TYPE_DECL);
1175 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1176 of a template class, we want to check if DECL is a specialization
1178 if (TREE_CODE (friend_decl) == FUNCTION_DECL
1179 && DECL_TEMPLATE_INFO (friend_decl)
1180 && !DECL_USE_TEMPLATE (friend_decl))
1182 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1183 friend_decl = DECL_TI_TEMPLATE (friend_decl);
1184 need_template = false;
1186 else if (TREE_CODE (friend_decl) == TEMPLATE_DECL
1187 && !PRIMARY_TEMPLATE_P (friend_decl))
1188 need_template = false;
1190 /* There is nothing to do if this is not a template friend. */
1191 if (TREE_CODE (friend_decl) != TEMPLATE_DECL)
1194 if (is_specialization_of (decl, friend_decl))
1198 A member of a class template may be declared to be a friend of a
1199 non-template class. In this case, the corresponding member of
1200 every specialization of the class template is a friend of the
1201 class granting friendship.
1203 For example, given a template friend declaration
1205 template <class T> friend void A<T>::f();
1207 the member function below is considered a friend
1209 template <> struct A<int> {
1213 For this type of template friend, TEMPLATE_DEPTH below will be
1214 nonzero. To determine if DECL is a friend of FRIEND, we first
1215 check if the enclosing class is a specialization of another. */
1217 template_depth = template_class_depth (CP_DECL_CONTEXT (friend_decl));
1219 && DECL_CLASS_SCOPE_P (decl)
1220 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)),
1221 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl))))
1223 /* Next, we check the members themselves. In order to handle
1224 a few tricky cases, such as when FRIEND_DECL's are
1226 template <class T> friend void A<T>::g(T t);
1227 template <class T> template <T t> friend void A<T>::h();
1231 void A<int>::g(int);
1232 template <int> void A<int>::h();
1234 we need to figure out ARGS, the template arguments from
1235 the context of DECL. This is required for template substitution
1236 of `T' in the function parameter of `g' and template parameter
1237 of `h' in the above examples. Here ARGS corresponds to `int'. */
1239 tree context = DECL_CONTEXT (decl);
1240 tree args = NULL_TREE;
1241 int current_depth = 0;
1243 while (current_depth < template_depth)
1245 if (CLASSTYPE_TEMPLATE_INFO (context))
1247 if (current_depth == 0)
1248 args = TYPE_TI_ARGS (context);
1250 args = add_to_template_args (TYPE_TI_ARGS (context), args);
1253 context = TYPE_CONTEXT (context);
1256 if (TREE_CODE (decl) == FUNCTION_DECL)
1261 tree friend_args_type;
1262 tree decl_args_type;
1264 /* Make sure that both DECL and FRIEND_DECL are templates or
1266 is_template = DECL_TEMPLATE_INFO (decl)
1267 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl));
1268 if (need_template ^ is_template)
1270 else if (is_template)
1272 /* If both are templates, check template parameter list. */
1274 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl),
1276 if (!comp_template_parms
1277 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)),
1281 decl_type = TREE_TYPE (DECL_TI_TEMPLATE (decl));
1284 decl_type = TREE_TYPE (decl);
1286 friend_type = tsubst_function_type (TREE_TYPE (friend_decl), args,
1287 tf_none, NULL_TREE);
1288 if (friend_type == error_mark_node)
1291 /* Check if return types match. */
1292 if (!same_type_p (TREE_TYPE (decl_type), TREE_TYPE (friend_type)))
1295 /* Check if function parameter types match, ignoring the
1296 `this' parameter. */
1297 friend_args_type = TYPE_ARG_TYPES (friend_type);
1298 decl_args_type = TYPE_ARG_TYPES (decl_type);
1299 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl))
1300 friend_args_type = TREE_CHAIN (friend_args_type);
1301 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1302 decl_args_type = TREE_CHAIN (decl_args_type);
1304 return compparms (decl_args_type, friend_args_type);
1308 /* DECL is a TYPE_DECL */
1310 tree decl_type = TREE_TYPE (decl);
1312 /* Make sure that both DECL and FRIEND_DECL are templates or
1315 = CLASSTYPE_TEMPLATE_INFO (decl_type)
1316 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type));
1318 if (need_template ^ is_template)
1320 else if (is_template)
1323 /* If both are templates, check the name of the two
1324 TEMPLATE_DECL's first because is_friend didn't. */
1325 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type))
1326 != DECL_NAME (friend_decl))
1329 /* Now check template parameter list. */
1331 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl),
1333 return comp_template_parms
1334 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type)),
1338 return (DECL_NAME (decl)
1339 == DECL_NAME (friend_decl));
1345 /* Register the specialization SPEC as a specialization of TMPL with
1346 the indicated ARGS. IS_FRIEND indicates whether the specialization
1347 is actually just a friend declaration. Returns SPEC, or an
1348 equivalent prior declaration, if available.
1350 We also store instantiations of field packs in the hash table, even
1351 though they are not themselves templates, to make lookup easier. */
1354 register_specialization (tree spec, tree tmpl, tree args, bool is_friend,
1358 spec_entry **slot = NULL;
1361 gcc_assert ((TREE_CODE (tmpl) == TEMPLATE_DECL && DECL_P (spec))
1362 || (TREE_CODE (tmpl) == FIELD_DECL
1363 && TREE_CODE (spec) == NONTYPE_ARGUMENT_PACK));
1365 if (TREE_CODE (spec) == FUNCTION_DECL
1366 && uses_template_parms (DECL_TI_ARGS (spec)))
1367 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1368 register it; we want the corresponding TEMPLATE_DECL instead.
1369 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1370 the more obvious `uses_template_parms (spec)' to avoid problems
1371 with default function arguments. In particular, given
1372 something like this:
1374 template <class T> void f(T t1, T t = T())
1376 the default argument expression is not substituted for in an
1377 instantiation unless and until it is actually needed. */
1380 if (optimize_specialization_lookup_p (tmpl))
1381 /* We don't put these specializations in the hash table, but we might
1382 want to give an error about a mismatch. */
1383 fn = retrieve_specialization (tmpl, args, 0);
1391 hash = spec_hasher::hash (&elt);
1394 decl_specializations->find_slot_with_hash (&elt, hash, INSERT);
1396 fn = ((spec_entry *) *slot)->spec;
1401 /* We can sometimes try to re-register a specialization that we've
1402 already got. In particular, regenerate_decl_from_template calls
1403 duplicate_decls which will update the specialization list. But,
1404 we'll still get called again here anyhow. It's more convenient
1405 to simply allow this than to try to prevent it. */
1408 else if (fn && DECL_TEMPLATE_SPECIALIZATION (spec))
1410 if (DECL_TEMPLATE_INSTANTIATION (fn))
1412 if (DECL_ODR_USED (fn)
1413 || DECL_EXPLICIT_INSTANTIATION (fn))
1415 error ("specialization of %qD after instantiation",
1417 return error_mark_node;
1422 /* This situation should occur only if the first
1423 specialization is an implicit instantiation, the
1424 second is an explicit specialization, and the
1425 implicit instantiation has not yet been used. That
1426 situation can occur if we have implicitly
1427 instantiated a member function and then specialized
1430 We can also wind up here if a friend declaration that
1431 looked like an instantiation turns out to be a
1434 template <class T> void foo(T);
1435 class S { friend void foo<>(int) };
1436 template <> void foo(int);
1438 We transform the existing DECL in place so that any
1439 pointers to it become pointers to the updated
1442 If there was a definition for the template, but not
1443 for the specialization, we want this to look as if
1444 there were no definition, and vice versa. */
1445 DECL_INITIAL (fn) = NULL_TREE;
1446 duplicate_decls (spec, fn, is_friend);
1447 /* The call to duplicate_decls will have applied
1450 An explicit specialization of a function template
1451 is inline only if it is explicitly declared to be,
1452 and independently of whether its function template
1455 to the primary function; now copy the inline bits to
1456 the various clones. */
1457 FOR_EACH_CLONE (clone, fn)
1459 DECL_DECLARED_INLINE_P (clone)
1460 = DECL_DECLARED_INLINE_P (fn);
1461 DECL_SOURCE_LOCATION (clone)
1462 = DECL_SOURCE_LOCATION (fn);
1463 DECL_DELETED_FN (clone)
1464 = DECL_DELETED_FN (fn);
1466 check_specialization_namespace (tmpl);
1471 else if (DECL_TEMPLATE_SPECIALIZATION (fn))
1473 if (!duplicate_decls (spec, fn, is_friend) && DECL_INITIAL (spec))
1474 /* Dup decl failed, but this is a new definition. Set the
1475 line number so any errors match this new
1477 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec);
1483 return duplicate_decls (spec, fn, is_friend);
1485 /* A specialization must be declared in the same namespace as the
1486 template it is specializing. */
1487 if (DECL_P (spec) && DECL_TEMPLATE_SPECIALIZATION (spec)
1488 && !check_specialization_namespace (tmpl))
1489 DECL_CONTEXT (spec) = DECL_CONTEXT (tmpl);
1491 if (slot != NULL /* !optimize_specialization_lookup_p (tmpl) */)
1493 spec_entry *entry = ggc_alloc<spec_entry> ();
1494 gcc_assert (tmpl && args && spec);
1497 if ((TREE_CODE (spec) == FUNCTION_DECL && DECL_NAMESPACE_SCOPE_P (spec)
1498 && PRIMARY_TEMPLATE_P (tmpl)
1499 && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl)) == NULL_TREE)
1500 || variable_template_p (tmpl))
1501 /* If TMPL is a forward declaration of a template function, keep a list
1502 of all specializations in case we need to reassign them to a friend
1503 template later in tsubst_friend_function.
1505 Also keep a list of all variable template instantiations so that
1506 process_partial_specialization can check whether a later partial
1507 specialization would have used it. */
1508 DECL_TEMPLATE_INSTANTIATIONS (tmpl)
1509 = tree_cons (args, spec, DECL_TEMPLATE_INSTANTIATIONS (tmpl));
1515 /* Returns true iff two spec_entry nodes are equivalent. Only compares the
1516 TMPL and ARGS members, ignores SPEC. */
1518 int comparing_specializations;
1521 spec_hasher::equal (spec_entry *e1, spec_entry *e2)
1525 ++comparing_specializations;
1526 equal = (e1->tmpl == e2->tmpl
1527 && comp_template_args (e1->args, e2->args));
1528 --comparing_specializations;
1533 /* Returns a hash for a template TMPL and template arguments ARGS. */
1536 hash_tmpl_and_args (tree tmpl, tree args)
1538 hashval_t val = DECL_UID (tmpl);
1539 return iterative_hash_template_arg (args, val);
1542 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1546 spec_hasher::hash (spec_entry *e)
1548 return hash_tmpl_and_args (e->tmpl, e->args);
1551 /* Recursively calculate a hash value for a template argument ARG, for use
1552 in the hash tables of template specializations. */
1555 iterative_hash_template_arg (tree arg, hashval_t val)
1557 unsigned HOST_WIDE_INT i;
1558 enum tree_code code;
1561 if (arg == NULL_TREE)
1562 return iterative_hash_object (arg, val);
1567 if (TREE_CODE (arg) == ARGUMENT_PACK_SELECT)
1568 /* We can get one of these when re-hashing a previous entry in the middle
1569 of substituting into a pack expansion. Just look through it. */
1570 arg = ARGUMENT_PACK_SELECT_FROM_PACK (arg);
1572 code = TREE_CODE (arg);
1573 tclass = TREE_CODE_CLASS (code);
1575 val = iterative_hash_object (code, val);
1582 case IDENTIFIER_NODE:
1583 return iterative_hash_object (IDENTIFIER_HASH_VALUE (arg), val);
1587 int i, len = TREE_VEC_LENGTH (arg);
1588 for (i = 0; i < len; ++i)
1589 val = iterative_hash_template_arg (TREE_VEC_ELT (arg, i), val);
1593 case TYPE_PACK_EXPANSION:
1594 case EXPR_PACK_EXPANSION:
1595 val = iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg), val);
1596 return iterative_hash_template_arg (PACK_EXPANSION_EXTRA_ARGS (arg), val);
1598 case TYPE_ARGUMENT_PACK:
1599 case NONTYPE_ARGUMENT_PACK:
1600 return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg), val);
1603 for (; arg; arg = TREE_CHAIN (arg))
1604 val = iterative_hash_template_arg (TREE_VALUE (arg), val);
1608 for (; arg; arg = OVL_NEXT (arg))
1609 val = iterative_hash_template_arg (OVL_CURRENT (arg), val);
1615 iterative_hash_template_arg (TREE_TYPE (arg), val);
1616 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg), i, field, value)
1618 val = iterative_hash_template_arg (field, val);
1619 val = iterative_hash_template_arg (value, val);
1625 if (!DECL_ARTIFICIAL (arg))
1627 val = iterative_hash_object (DECL_PARM_INDEX (arg), val);
1628 val = iterative_hash_object (DECL_PARM_LEVEL (arg), val);
1630 return iterative_hash_template_arg (TREE_TYPE (arg), val);
1633 return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg), val);
1636 val = iterative_hash_template_arg (PTRMEM_CST_CLASS (arg), val);
1637 return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg), val);
1639 case TEMPLATE_PARM_INDEX:
1640 val = iterative_hash_template_arg
1641 (TREE_TYPE (TEMPLATE_PARM_DECL (arg)), val);
1642 val = iterative_hash_object (TEMPLATE_PARM_LEVEL (arg), val);
1643 return iterative_hash_object (TEMPLATE_PARM_IDX (arg), val);
1646 val = iterative_hash_object (TRAIT_EXPR_KIND (arg), val);
1647 val = iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg), val);
1648 return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg), val);
1651 val = iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg)),
1653 return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg)),
1657 val = iterative_hash_template_arg (TREE_OPERAND (arg, 0), val);
1658 code = TREE_CODE (TREE_OPERAND (arg, 1));
1659 val = iterative_hash_object (code, val);
1660 return iterative_hash_template_arg (TREE_OPERAND (arg, 2), val);
1663 /* A lambda can't appear in a template arg, but don't crash on
1665 gcc_assert (seen_error ());
1669 case IMPLICIT_CONV_EXPR:
1670 case STATIC_CAST_EXPR:
1671 case REINTERPRET_CAST_EXPR:
1672 case CONST_CAST_EXPR:
1673 case DYNAMIC_CAST_EXPR:
1675 val = iterative_hash_template_arg (TREE_TYPE (arg), val);
1676 /* Now hash operands as usual. */
1686 if (alias_template_specialization_p (arg))
1688 // We want an alias specialization that survived strip_typedefs
1689 // to hash differently from its TYPE_CANONICAL, to avoid hash
1690 // collisions that compare as different in template_args_equal.
1691 // These could be dependent specializations that strip_typedefs
1692 // left alone, or untouched specializations because
1693 // coerce_template_parms returns the unconverted template
1694 // arguments if it sees incomplete argument packs.
1695 tree ti = TYPE_TEMPLATE_INFO (arg);
1696 return hash_tmpl_and_args (TI_TEMPLATE (ti), TI_ARGS (ti));
1698 if (TYPE_CANONICAL (arg))
1699 return iterative_hash_object (TYPE_HASH (TYPE_CANONICAL (arg)),
1701 else if (TREE_CODE (arg) == DECLTYPE_TYPE)
1702 return iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg), val);
1703 /* Otherwise just compare the types during lookup. */
1706 case tcc_declaration:
1708 return iterative_hash_expr (arg, val);
1711 gcc_assert (IS_EXPR_CODE_CLASS (tclass));
1713 unsigned n = cp_tree_operand_length (arg);
1714 for (i = 0; i < n; ++i)
1715 val = iterative_hash_template_arg (TREE_OPERAND (arg, i), val);
1723 /* Unregister the specialization SPEC as a specialization of TMPL.
1724 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1725 if the SPEC was listed as a specialization of TMPL.
1727 Note that SPEC has been ggc_freed, so we can't look inside it. */
1730 reregister_specialization (tree spec, tree tinfo, tree new_spec)
1735 elt.tmpl = most_general_template (TI_TEMPLATE (tinfo));
1736 elt.args = TI_ARGS (tinfo);
1737 elt.spec = NULL_TREE;
1739 entry = decl_specializations->find (&elt);
1742 gcc_assert (entry->spec == spec || entry->spec == new_spec);
1743 gcc_assert (new_spec != NULL_TREE);
1744 entry->spec = new_spec;
1751 /* Like register_specialization, but for local declarations. We are
1752 registering SPEC, an instantiation of TMPL. */
1755 register_local_specialization (tree spec, tree tmpl)
1757 local_specializations->put (tmpl, spec);
1760 /* TYPE is a class type. Returns true if TYPE is an explicitly
1761 specialized class. */
1764 explicit_class_specialization_p (tree type)
1766 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
1768 return !uses_template_parms (CLASSTYPE_TI_ARGS (type));
1771 /* Print the list of functions at FNS, going through all the overloads
1772 for each element of the list. Alternatively, FNS can not be a
1773 TREE_LIST, in which case it will be printed together with all the
1776 MORE and *STR should respectively be FALSE and NULL when the function
1777 is called from the outside. They are used internally on recursive
1778 calls. print_candidates manages the two parameters and leaves NULL
1779 in *STR when it ends. */
1782 print_candidates_1 (tree fns, bool more, const char **str)
1785 char *spaces = NULL;
1787 for (fn = fns; fn; fn = OVL_NEXT (fn))
1788 if (TREE_CODE (fn) == TREE_LIST)
1790 for (fn2 = fn; fn2 != NULL_TREE; fn2 = TREE_CHAIN (fn2))
1791 print_candidates_1 (TREE_VALUE (fn2),
1792 TREE_CHAIN (fn2) || more, str);
1796 tree cand = OVL_CURRENT (fn);
1799 /* Pick the prefix string. */
1800 if (!more && !OVL_NEXT (fns))
1802 inform (DECL_SOURCE_LOCATION (cand),
1803 "candidate is: %#D", cand);
1807 *str = _("candidates are:");
1808 spaces = get_spaces (*str);
1810 inform (DECL_SOURCE_LOCATION (cand), "%s %#D", *str, cand);
1811 *str = spaces ? spaces : *str;
1821 /* Print the list of candidate FNS in an error message. FNS can also
1822 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
1825 print_candidates (tree fns)
1827 const char *str = NULL;
1828 print_candidates_1 (fns, false, &str);
1829 gcc_assert (str == NULL);
1832 /* Returns the template (one of the functions given by TEMPLATE_ID)
1833 which can be specialized to match the indicated DECL with the
1834 explicit template args given in TEMPLATE_ID. The DECL may be
1835 NULL_TREE if none is available. In that case, the functions in
1836 TEMPLATE_ID are non-members.
1838 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1839 specialization of a member template.
1841 The TEMPLATE_COUNT is the number of references to qualifying
1842 template classes that appeared in the name of the function. See
1843 check_explicit_specialization for a more accurate description.
1845 TSK indicates what kind of template declaration (if any) is being
1846 declared. TSK_TEMPLATE indicates that the declaration given by
1847 DECL, though a FUNCTION_DECL, has template parameters, and is
1848 therefore a template function.
1850 The template args (those explicitly specified and those deduced)
1851 are output in a newly created vector *TARGS_OUT.
1853 If it is impossible to determine the result, an error message is
1854 issued. The error_mark_node is returned to indicate failure. */
1857 determine_specialization (tree template_id,
1860 int need_member_template,
1866 tree explicit_targs;
1867 tree candidates = NULL_TREE;
1868 /* A TREE_LIST of templates of which DECL may be a specialization.
1869 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1870 corresponding TREE_PURPOSE is the set of template arguments that,
1871 when used to instantiate the template, would produce a function
1872 with the signature of DECL. */
1873 tree templates = NULL_TREE;
1875 cp_binding_level *b;
1877 *targs_out = NULL_TREE;
1879 if (template_id == error_mark_node || decl == error_mark_node)
1880 return error_mark_node;
1882 /* We shouldn't be specializing a member template of an
1883 unspecialized class template; we already gave an error in
1884 check_specialization_scope, now avoid crashing. */
1885 if (template_count && DECL_CLASS_SCOPE_P (decl)
1886 && template_class_depth (DECL_CONTEXT (decl)) > 0)
1888 gcc_assert (errorcount);
1889 return error_mark_node;
1892 fns = TREE_OPERAND (template_id, 0);
1893 explicit_targs = TREE_OPERAND (template_id, 1);
1895 if (fns == error_mark_node)
1896 return error_mark_node;
1898 /* Check for baselinks. */
1899 if (BASELINK_P (fns))
1900 fns = BASELINK_FUNCTIONS (fns);
1902 if (TREE_CODE (decl) == FUNCTION_DECL && !is_overloaded_fn (fns))
1904 error ("%qD is not a function template", fns);
1905 return error_mark_node;
1907 else if (VAR_P (decl) && !variable_template_p (fns))
1909 error ("%qD is not a variable template", fns);
1910 return error_mark_node;
1913 /* Count the number of template headers specified for this
1916 for (b = current_binding_level;
1917 b->kind == sk_template_parms;
1921 if (variable_template_p (fns))
1922 templates = tree_cons (explicit_targs, fns, templates);
1923 else for (; fns; fns = OVL_NEXT (fns))
1925 tree fn = OVL_CURRENT (fns);
1927 if (TREE_CODE (fn) == TEMPLATE_DECL)
1929 tree decl_arg_types;
1933 /* In case of explicit specialization, we need to check if
1934 the number of template headers appearing in the specialization
1935 is correct. This is usually done in check_explicit_specialization,
1936 but the check done there cannot be exhaustive when specializing
1937 member functions. Consider the following code:
1939 template <> void A<int>::f(int);
1940 template <> template <> void A<int>::f(int);
1942 Assuming that A<int> is not itself an explicit specialization
1943 already, the first line specializes "f" which is a non-template
1944 member function, whilst the second line specializes "f" which
1945 is a template member function. So both lines are syntactically
1946 correct, and check_explicit_specialization does not reject
1949 Here, we can do better, as we are matching the specialization
1950 against the declarations. We count the number of template
1951 headers, and we check if they match TEMPLATE_COUNT + 1
1952 (TEMPLATE_COUNT is the number of qualifying template classes,
1953 plus there must be another header for the member template
1956 Notice that if header_count is zero, this is not a
1957 specialization but rather a template instantiation, so there
1958 is no check we can perform here. */
1959 if (header_count && header_count != template_count + 1)
1962 /* Check that the number of template arguments at the
1963 innermost level for DECL is the same as for FN. */
1964 if (current_binding_level->kind == sk_template_parms
1965 && !current_binding_level->explicit_spec_p
1966 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn))
1967 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
1968 (current_template_parms))))
1971 /* DECL might be a specialization of FN. */
1972 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1973 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
1975 /* For a non-static member function, we need to make sure
1976 that the const qualification is the same. Since
1977 get_bindings does not try to merge the "this" parameter,
1978 we must do the comparison explicitly. */
1979 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1980 && !same_type_p (TREE_VALUE (fn_arg_types),
1981 TREE_VALUE (decl_arg_types)))
1984 /* Skip the "this" parameter and, for constructors of
1985 classes with virtual bases, the VTT parameter. A
1986 full specialization of a constructor will have a VTT
1987 parameter, but a template never will. */
1989 = skip_artificial_parms_for (decl, decl_arg_types);
1991 = skip_artificial_parms_for (fn, fn_arg_types);
1993 /* Function templates cannot be specializations; there are
1994 no partial specializations of functions. Therefore, if
1995 the type of DECL does not match FN, there is no
1997 if (tsk == tsk_template)
1999 if (compparms (fn_arg_types, decl_arg_types))
2000 candidates = tree_cons (NULL_TREE, fn, candidates);
2004 /* See whether this function might be a specialization of this
2005 template. Suppress access control because we might be trying
2006 to make this specialization a friend, and we have already done
2007 access control for the declaration of the specialization. */
2008 push_deferring_access_checks (dk_no_check);
2009 targs = get_bindings (fn, decl, explicit_targs, /*check_ret=*/true);
2010 pop_deferring_access_checks ();
2013 /* We cannot deduce template arguments that when used to
2014 specialize TMPL will produce DECL. */
2017 /* Make sure that the deduced arguments actually work. */
2018 insttype = tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE);
2019 if (insttype == error_mark_node)
2022 = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (insttype));
2023 if (!compparms (fn_arg_types, decl_arg_types))
2026 /* Save this template, and the arguments deduced. */
2027 templates = tree_cons (targs, fn, templates);
2029 else if (need_member_template)
2030 /* FN is an ordinary member function, and we need a
2031 specialization of a member template. */
2033 else if (TREE_CODE (fn) != FUNCTION_DECL)
2034 /* We can get IDENTIFIER_NODEs here in certain erroneous
2037 else if (!DECL_FUNCTION_MEMBER_P (fn))
2038 /* This is just an ordinary non-member function. Nothing can
2039 be a specialization of that. */
2041 else if (DECL_ARTIFICIAL (fn))
2042 /* Cannot specialize functions that are created implicitly. */
2046 tree decl_arg_types;
2048 /* This is an ordinary member function. However, since
2049 we're here, we can assume its enclosing class is a
2050 template class. For example,
2052 template <typename T> struct S { void f(); };
2053 template <> void S<int>::f() {}
2055 Here, S<int>::f is a non-template, but S<int> is a
2056 template class. If FN has the same type as DECL, we
2057 might be in business. */
2059 if (!DECL_TEMPLATE_INFO (fn))
2060 /* Its enclosing class is an explicit specialization
2061 of a template class. This is not a candidate. */
2064 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
2065 TREE_TYPE (TREE_TYPE (fn))))
2066 /* The return types differ. */
2069 /* Adjust the type of DECL in case FN is a static member. */
2070 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
2071 if (DECL_STATIC_FUNCTION_P (fn)
2072 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2073 decl_arg_types = TREE_CHAIN (decl_arg_types);
2075 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
2078 candidates = tree_cons (NULL_TREE, fn, candidates);
2082 if (templates && TREE_CHAIN (templates))
2088 It is possible for a specialization with a given function
2089 signature to be instantiated from more than one function
2090 template. In such cases, explicit specification of the
2091 template arguments must be used to uniquely identify the
2092 function template specialization being specialized.
2094 Note that here, there's no suggestion that we're supposed to
2095 determine which of the candidate templates is most
2096 specialized. However, we, also have:
2100 Partial ordering of overloaded function template
2101 declarations is used in the following contexts to select
2102 the function template to which a function template
2103 specialization refers:
2105 -- when an explicit specialization refers to a function
2108 So, we do use the partial ordering rules, at least for now.
2109 This extension can only serve to make invalid programs valid,
2110 so it's safe. And, there is strong anecdotal evidence that
2111 the committee intended the partial ordering rules to apply;
2112 the EDG front end has that behavior, and John Spicer claims
2113 that the committee simply forgot to delete the wording in
2114 [temp.expl.spec]. */
2115 tree tmpl = most_specialized_instantiation (templates);
2116 if (tmpl != error_mark_node)
2119 TREE_CHAIN (templates) = NULL_TREE;
2123 if (templates == NULL_TREE && candidates == NULL_TREE)
2125 error ("template-id %qD for %q+D does not match any template "
2126 "declaration", template_id, decl);
2127 if (header_count && header_count != template_count + 1)
2128 inform (input_location, "saw %d %<template<>%>, need %d for "
2129 "specializing a member function template",
2130 header_count, template_count + 1);
2131 return error_mark_node;
2133 else if ((templates && TREE_CHAIN (templates))
2134 || (candidates && TREE_CHAIN (candidates))
2135 || (templates && candidates))
2137 error ("ambiguous template specialization %qD for %q+D",
2139 candidates = chainon (candidates, templates);
2140 print_candidates (candidates);
2141 return error_mark_node;
2144 /* We have one, and exactly one, match. */
2147 tree fn = TREE_VALUE (candidates);
2148 *targs_out = copy_node (DECL_TI_ARGS (fn));
2149 /* DECL is a re-declaration or partial instantiation of a template
2151 if (TREE_CODE (fn) == TEMPLATE_DECL)
2153 /* It was a specialization of an ordinary member function in a
2155 return DECL_TI_TEMPLATE (fn);
2158 /* It was a specialization of a template. */
2159 targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates)));
2160 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs))
2162 *targs_out = copy_node (targs);
2163 SET_TMPL_ARGS_LEVEL (*targs_out,
2164 TMPL_ARGS_DEPTH (*targs_out),
2165 TREE_PURPOSE (templates));
2168 *targs_out = TREE_PURPOSE (templates);
2169 return TREE_VALUE (templates);
2172 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2173 but with the default argument values filled in from those in the
2177 copy_default_args_to_explicit_spec_1 (tree spec_types,
2180 tree new_spec_types;
2185 if (spec_types == void_list_node)
2186 return void_list_node;
2188 /* Substitute into the rest of the list. */
2190 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
2191 TREE_CHAIN (tmpl_types));
2193 /* Add the default argument for this parameter. */
2194 return hash_tree_cons (TREE_PURPOSE (tmpl_types),
2195 TREE_VALUE (spec_types),
2199 /* DECL is an explicit specialization. Replicate default arguments
2200 from the template it specializes. (That way, code like:
2202 template <class T> void f(T = 3);
2203 template <> void f(double);
2206 works, as required.) An alternative approach would be to look up
2207 the correct default arguments at the call-site, but this approach
2208 is consistent with how implicit instantiations are handled. */
2211 copy_default_args_to_explicit_spec (tree decl)
2216 tree new_spec_types;
2220 tree object_type = NULL_TREE;
2221 tree in_charge = NULL_TREE;
2222 tree vtt = NULL_TREE;
2224 /* See if there's anything we need to do. */
2225 tmpl = DECL_TI_TEMPLATE (decl);
2226 tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
2227 for (t = tmpl_types; t; t = TREE_CHAIN (t))
2228 if (TREE_PURPOSE (t))
2233 old_type = TREE_TYPE (decl);
2234 spec_types = TYPE_ARG_TYPES (old_type);
2236 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2238 /* Remove the this pointer, but remember the object's type for
2240 object_type = TREE_TYPE (TREE_VALUE (spec_types));
2241 spec_types = TREE_CHAIN (spec_types);
2242 tmpl_types = TREE_CHAIN (tmpl_types);
2244 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
2246 /* DECL may contain more parameters than TMPL due to the extra
2247 in-charge parameter in constructors and destructors. */
2248 in_charge = spec_types;
2249 spec_types = TREE_CHAIN (spec_types);
2251 if (DECL_HAS_VTT_PARM_P (decl))
2254 spec_types = TREE_CHAIN (spec_types);
2258 /* Compute the merged default arguments. */
2260 copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);
2262 /* Compute the new FUNCTION_TYPE. */
2266 new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt),
2271 /* Put the in-charge parameter back. */
2272 new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
2273 TREE_VALUE (in_charge),
2276 new_type = build_method_type_directly (object_type,
2277 TREE_TYPE (old_type),
2281 new_type = build_function_type (TREE_TYPE (old_type),
2283 new_type = cp_build_type_attribute_variant (new_type,
2284 TYPE_ATTRIBUTES (old_type));
2285 new_type = build_exception_variant (new_type,
2286 TYPE_RAISES_EXCEPTIONS (old_type));
2288 if (TYPE_HAS_LATE_RETURN_TYPE (old_type))
2289 TYPE_HAS_LATE_RETURN_TYPE (new_type) = 1;
2291 TREE_TYPE (decl) = new_type;
2294 /* Return the number of template headers we expect to see for a definition
2295 or specialization of CTYPE or one of its non-template members. */
2298 num_template_headers_for_class (tree ctype)
2300 int num_templates = 0;
2302 while (ctype && CLASS_TYPE_P (ctype))
2304 /* You're supposed to have one `template <...>' for every
2305 template class, but you don't need one for a full
2306 specialization. For example:
2308 template <class T> struct S{};
2309 template <> struct S<int> { void f(); };
2310 void S<int>::f () {}
2312 is correct; there shouldn't be a `template <>' for the
2313 definition of `S<int>::f'. */
2314 if (!CLASSTYPE_TEMPLATE_INFO (ctype))
2315 /* If CTYPE does not have template information of any
2316 kind, then it is not a template, nor is it nested
2317 within a template. */
2319 if (explicit_class_specialization_p (ctype))
2321 if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (ctype)))
2324 ctype = TYPE_CONTEXT (ctype);
2327 return num_templates;
2330 /* Do a simple sanity check on the template headers that precede the
2331 variable declaration DECL. */
2334 check_template_variable (tree decl)
2336 tree ctx = CP_DECL_CONTEXT (decl);
2337 int wanted = num_template_headers_for_class (ctx);
2338 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
2339 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl)))
2341 if (cxx_dialect < cxx14)
2342 pedwarn (DECL_SOURCE_LOCATION (decl), 0,
2343 "variable templates only available with "
2344 "-std=c++14 or -std=gnu++14");
2346 // Namespace-scope variable templates should have a template header.
2349 if (template_header_count > wanted)
2351 bool warned = pedwarn (DECL_SOURCE_LOCATION (decl), 0,
2352 "too many template headers for %D (should be %d)",
2354 if (warned && CLASS_TYPE_P (ctx)
2355 && CLASSTYPE_TEMPLATE_SPECIALIZATION (ctx))
2356 inform (DECL_SOURCE_LOCATION (decl),
2357 "members of an explicitly specialized class are defined "
2358 "without a template header");
2362 /* Check to see if the function just declared, as indicated in
2363 DECLARATOR, and in DECL, is a specialization of a function
2364 template. We may also discover that the declaration is an explicit
2365 instantiation at this point.
2367 Returns DECL, or an equivalent declaration that should be used
2368 instead if all goes well. Issues an error message if something is
2369 amiss. Returns error_mark_node if the error is not easily
2372 FLAGS is a bitmask consisting of the following flags:
2374 2: The function has a definition.
2375 4: The function is a friend.
2377 The TEMPLATE_COUNT is the number of references to qualifying
2378 template classes that appeared in the name of the function. For
2381 template <class T> struct S { void f(); };
2384 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2385 classes are not counted in the TEMPLATE_COUNT, so that in
2387 template <class T> struct S {};
2388 template <> struct S<int> { void f(); }
2389 template <> void S<int>::f();
2391 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2392 invalid; there should be no template <>.)
2394 If the function is a specialization, it is marked as such via
2395 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2396 is set up correctly, and it is added to the list of specializations
2397 for that template. */
2400 check_explicit_specialization (tree declarator,
2405 int have_def = flags & 2;
2406 int is_friend = flags & 4;
2407 int specialization = 0;
2408 int explicit_instantiation = 0;
2409 int member_specialization = 0;
2410 tree ctype = DECL_CLASS_CONTEXT (decl);
2411 tree dname = DECL_NAME (decl);
2416 if (!processing_specialization)
2419 tsk = tsk_excessive_parms;
2422 tsk = current_tmpl_spec_kind (template_count);
2427 if (processing_specialization)
2430 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
2432 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
2435 /* This could be something like:
2437 template <class T> void f(T);
2438 class S { friend void f<>(int); } */
2442 /* This case handles bogus declarations like template <>
2443 template <class T> void f<int>(); */
2445 error ("template-id %qD in declaration of primary template",
2452 case tsk_invalid_member_spec:
2453 /* The error has already been reported in
2454 check_specialization_scope. */
2455 return error_mark_node;
2457 case tsk_invalid_expl_inst:
2458 error ("template parameter list used in explicit instantiation");
2464 error ("definition provided for explicit instantiation");
2466 explicit_instantiation = 1;
2469 case tsk_excessive_parms:
2470 case tsk_insufficient_parms:
2471 if (tsk == tsk_excessive_parms)
2472 error ("too many template parameter lists in declaration of %qD",
2474 else if (template_header_count)
2475 error("too few template parameter lists in declaration of %qD", decl);
2477 error("explicit specialization of %qD must be introduced by "
2478 "%<template <>%>", decl);
2482 if (VAR_P (decl) && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
2483 /* In cases like template<> constexpr bool v = true;
2484 We'll give an error in check_template_variable. */
2487 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
2489 member_specialization = 1;
2495 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
2497 /* This case handles bogus declarations like template <>
2498 template <class T> void f<int>(); */
2500 if (!uses_template_parms (declarator))
2501 error ("template-id %qD in declaration of primary template",
2503 else if (variable_template_p (TREE_OPERAND (declarator, 0)))
2505 /* Partial specialization of variable template. */
2506 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
2510 else if (cxx_dialect < cxx14)
2511 error ("non-type partial specialization %qD "
2512 "is not allowed", declarator);
2514 error ("non-class, non-variable partial specialization %qD "
2515 "is not allowed", declarator);
2520 if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
2521 /* This is a specialization of a member template, without
2522 specialization the containing class. Something like:
2524 template <class T> struct S {
2525 template <class U> void f (U);
2527 template <> template <class U> void S<int>::f(U) {}
2529 That's a specialization -- but of the entire template. */
2537 if ((specialization || member_specialization)
2538 /* This doesn't apply to variable templates. */
2539 && (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE
2540 || TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE))
2542 tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
2543 for (; t; t = TREE_CHAIN (t))
2544 if (TREE_PURPOSE (t))
2546 permerror (input_location,
2547 "default argument specified in explicit specialization");
2552 if (specialization || member_specialization || explicit_instantiation)
2554 tree tmpl = NULL_TREE;
2555 tree targs = NULL_TREE;
2556 bool was_template_id = (TREE_CODE (declarator) == TEMPLATE_ID_EXPR);
2558 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2559 if (!was_template_id)
2563 gcc_assert (identifier_p (declarator));
2568 /* If there is no class context, the explicit instantiation
2569 must be at namespace scope. */
2570 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl));
2572 /* Find the namespace binding, using the declaration
2574 fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
2576 if (fns == error_mark_node || !is_overloaded_fn (fns))
2578 error ("%qD is not a template function", dname);
2579 fns = error_mark_node;
2583 tree fn = OVL_CURRENT (fns);
2584 if (!is_associated_namespace (CP_DECL_CONTEXT (decl),
2585 CP_DECL_CONTEXT (fn)))
2586 error ("%qD is not declared in %qD",
2587 decl, current_namespace);
2591 declarator = lookup_template_function (fns, NULL_TREE);
2594 if (declarator == error_mark_node)
2595 return error_mark_node;
2597 if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
2599 if (!explicit_instantiation)
2600 /* A specialization in class scope. This is invalid,
2601 but the error will already have been flagged by
2602 check_specialization_scope. */
2603 return error_mark_node;
2606 /* It's not valid to write an explicit instantiation in
2609 class C { template void f(); }
2611 This case is caught by the parser. However, on
2614 template class C { void f(); };
2616 (which is invalid) we can get here. The error will be
2623 else if (ctype != NULL_TREE
2624 && (identifier_p (TREE_OPERAND (declarator, 0))))
2626 // We'll match variable templates in start_decl.
2630 /* Find the list of functions in ctype that have the same
2631 name as the declared function. */
2632 tree name = TREE_OPERAND (declarator, 0);
2633 tree fns = NULL_TREE;
2636 if (constructor_name_p (name, ctype))
2638 int is_constructor = DECL_CONSTRUCTOR_P (decl);
2640 if (is_constructor ? !TYPE_HAS_USER_CONSTRUCTOR (ctype)
2641 : !CLASSTYPE_DESTRUCTORS (ctype))
2643 /* From [temp.expl.spec]:
2645 If such an explicit specialization for the member
2646 of a class template names an implicitly-declared
2647 special member function (clause _special_), the
2648 program is ill-formed.
2650 Similar language is found in [temp.explicit]. */
2651 error ("specialization of implicitly-declared special member function");
2652 return error_mark_node;
2655 name = is_constructor ? ctor_identifier : dtor_identifier;
2658 if (!DECL_CONV_FN_P (decl))
2660 idx = lookup_fnfields_1 (ctype, name);
2662 fns = (*CLASSTYPE_METHOD_VEC (ctype))[idx];
2666 vec<tree, va_gc> *methods;
2669 /* For a type-conversion operator, we cannot do a
2670 name-based lookup. We might be looking for `operator
2671 int' which will be a specialization of `operator T'.
2672 So, we find *all* the conversion operators, and then
2673 select from them. */
2676 methods = CLASSTYPE_METHOD_VEC (ctype);
2678 for (idx = CLASSTYPE_FIRST_CONVERSION_SLOT;
2679 methods->iterate (idx, &ovl);
2682 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl)))
2683 /* There are no more conversion functions. */
2686 /* Glue all these conversion functions together
2687 with those we already have. */
2688 for (; ovl; ovl = OVL_NEXT (ovl))
2689 fns = ovl_cons (OVL_CURRENT (ovl), fns);
2693 if (fns == NULL_TREE)
2695 error ("no member function %qD declared in %qT", name, ctype);
2696 return error_mark_node;
2699 TREE_OPERAND (declarator, 0) = fns;
2702 /* Figure out what exactly is being specialized at this point.
2703 Note that for an explicit instantiation, even one for a
2704 member function, we cannot tell apriori whether the
2705 instantiation is for a member template, or just a member
2706 function of a template class. Even if a member template is
2707 being instantiated, the member template arguments may be
2708 elided if they can be deduced from the rest of the
2710 tmpl = determine_specialization (declarator, decl,
2712 member_specialization,
2716 if (!tmpl || tmpl == error_mark_node)
2717 /* We couldn't figure out what this declaration was
2719 return error_mark_node;
2722 tree gen_tmpl = most_general_template (tmpl);
2724 if (explicit_instantiation)
2726 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2727 is done by do_decl_instantiation later. */
2729 int arg_depth = TMPL_ARGS_DEPTH (targs);
2730 int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
2732 if (arg_depth > parm_depth)
2734 /* If TMPL is not the most general template (for
2735 example, if TMPL is a friend template that is
2736 injected into namespace scope), then there will
2737 be too many levels of TARGS. Remove some of them
2742 new_targs = make_tree_vec (parm_depth);
2743 for (i = arg_depth - parm_depth; i < arg_depth; ++i)
2744 TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
2745 = TREE_VEC_ELT (targs, i);
2749 return instantiate_template (tmpl, targs, tf_error);
2752 /* If we thought that the DECL was a member function, but it
2753 turns out to be specializing a static member function,
2754 make DECL a static member function as well. */
2755 if (DECL_FUNCTION_TEMPLATE_P (tmpl)
2756 && DECL_STATIC_FUNCTION_P (tmpl)
2757 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2758 revert_static_member_fn (decl);
2760 /* If this is a specialization of a member template of a
2761 template class, we want to return the TEMPLATE_DECL, not
2762 the specialization of it. */
2763 if (tsk == tsk_template && !was_template_id)
2765 tree result = DECL_TEMPLATE_RESULT (tmpl);
2766 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
2767 DECL_INITIAL (result) = NULL_TREE;
2771 DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
2772 DECL_SOURCE_LOCATION (result)
2773 = DECL_SOURCE_LOCATION (decl);
2774 /* We want to use the argument list specified in the
2775 definition, not in the original declaration. */
2776 DECL_ARGUMENTS (result) = DECL_ARGUMENTS (decl);
2777 for (parm = DECL_ARGUMENTS (result); parm;
2778 parm = DECL_CHAIN (parm))
2779 DECL_CONTEXT (parm) = result;
2781 return register_specialization (tmpl, gen_tmpl, targs,
2785 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2786 DECL_TEMPLATE_INFO (decl) = build_template_info (tmpl, targs);
2788 if (was_template_id)
2789 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl)) = true;
2791 /* Inherit default function arguments from the template
2792 DECL is specializing. */
2793 if (DECL_FUNCTION_TEMPLATE_P (tmpl))
2794 copy_default_args_to_explicit_spec (decl);
2796 /* This specialization has the same protection as the
2797 template it specializes. */
2798 TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
2799 TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
2801 /* 7.1.1-1 [dcl.stc]
2803 A storage-class-specifier shall not be specified in an
2804 explicit specialization...
2806 The parser rejects these, so unless action is taken here,
2807 explicit function specializations will always appear with
2810 The action recommended by the C++ CWG in response to C++
2811 defect report 605 is to make the storage class and linkage
2812 of the explicit specialization match the templated function:
2814 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2816 if (tsk == tsk_expl_spec && DECL_FUNCTION_TEMPLATE_P (gen_tmpl))
2818 tree tmpl_func = DECL_TEMPLATE_RESULT (gen_tmpl);
2819 gcc_assert (TREE_CODE (tmpl_func) == FUNCTION_DECL);
2821 /* This specialization has the same linkage and visibility as
2822 the function template it specializes. */
2823 TREE_PUBLIC (decl) = TREE_PUBLIC (tmpl_func);
2824 if (! TREE_PUBLIC (decl))
2826 DECL_INTERFACE_KNOWN (decl) = 1;
2827 DECL_NOT_REALLY_EXTERN (decl) = 1;
2829 DECL_THIS_STATIC (decl) = DECL_THIS_STATIC (tmpl_func);
2830 if (DECL_VISIBILITY_SPECIFIED (tmpl_func))
2832 DECL_VISIBILITY_SPECIFIED (decl) = 1;
2833 DECL_VISIBILITY (decl) = DECL_VISIBILITY (tmpl_func);
2837 /* If DECL is a friend declaration, declared using an
2838 unqualified name, the namespace associated with DECL may
2839 have been set incorrectly. For example, in:
2841 template <typename T> void f(T);
2843 struct S { friend void f<int>(int); }
2846 we will have set the DECL_CONTEXT for the friend
2847 declaration to N, rather than to the global namespace. */
2848 if (DECL_NAMESPACE_SCOPE_P (decl))
2849 DECL_CONTEXT (decl) = DECL_CONTEXT (tmpl);
2851 if (is_friend && !have_def)
2852 /* This is not really a declaration of a specialization.
2853 It's just the name of an instantiation. But, it's not
2854 a request for an instantiation, either. */
2855 SET_DECL_IMPLICIT_INSTANTIATION (decl);
2856 else if (TREE_CODE (decl) == FUNCTION_DECL)
2857 /* A specialization is not necessarily COMDAT. */
2858 DECL_COMDAT (decl) = (TREE_PUBLIC (decl)
2859 && DECL_DECLARED_INLINE_P (decl));
2860 else if (TREE_CODE (decl) == VAR_DECL)
2861 DECL_COMDAT (decl) = false;
2863 /* Register this specialization so that we can find it
2865 decl = register_specialization (decl, gen_tmpl, targs, is_friend, 0);
2867 /* A 'structor should already have clones. */
2868 gcc_assert (decl == error_mark_node
2869 || variable_template_p (tmpl)
2870 || !(DECL_CONSTRUCTOR_P (decl)
2871 || DECL_DESTRUCTOR_P (decl))
2872 || DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl)));
2879 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2880 parameters. These are represented in the same format used for
2881 DECL_TEMPLATE_PARMS. */
2884 comp_template_parms (const_tree parms1, const_tree parms2)
2889 if (parms1 == parms2)
2892 for (p1 = parms1, p2 = parms2;
2893 p1 != NULL_TREE && p2 != NULL_TREE;
2894 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2))
2896 tree t1 = TREE_VALUE (p1);
2897 tree t2 = TREE_VALUE (p2);
2900 gcc_assert (TREE_CODE (t1) == TREE_VEC);
2901 gcc_assert (TREE_CODE (t2) == TREE_VEC);
2903 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
2906 for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
2908 tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
2909 tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
2911 /* If either of the template parameters are invalid, assume
2912 they match for the sake of error recovery. */
2913 if (error_operand_p (parm1) || error_operand_p (parm2))
2916 if (TREE_CODE (parm1) != TREE_CODE (parm2))
2919 if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM
2920 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1)
2921 == TEMPLATE_TYPE_PARAMETER_PACK (parm2)))
2923 else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
2928 if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
2929 /* One set of parameters has more parameters lists than the
2936 /* Determine whether PARM is a parameter pack. */
2939 template_parameter_pack_p (const_tree parm)
2941 /* Determine if we have a non-type template parameter pack. */
2942 if (TREE_CODE (parm) == PARM_DECL)
2943 return (DECL_TEMPLATE_PARM_P (parm)
2944 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)));
2945 if (TREE_CODE (parm) == TEMPLATE_PARM_INDEX)
2946 return TEMPLATE_PARM_PARAMETER_PACK (parm);
2948 /* If this is a list of template parameters, we could get a
2949 TYPE_DECL or a TEMPLATE_DECL. */
2950 if (TREE_CODE (parm) == TYPE_DECL || TREE_CODE (parm) == TEMPLATE_DECL)
2951 parm = TREE_TYPE (parm);
2953 /* Otherwise it must be a type template parameter. */
2954 return ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
2955 || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM)
2956 && TEMPLATE_TYPE_PARAMETER_PACK (parm));
2959 /* Determine if T is a function parameter pack. */
2962 function_parameter_pack_p (const_tree t)
2964 if (t && TREE_CODE (t) == PARM_DECL)
2965 return DECL_PACK_P (t);
2969 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
2970 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
2973 get_function_template_decl (const_tree primary_func_tmpl_inst)
2975 if (! primary_func_tmpl_inst
2976 || TREE_CODE (primary_func_tmpl_inst) != FUNCTION_DECL
2977 || ! primary_template_instantiation_p (primary_func_tmpl_inst))
2980 return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst));
2983 /* Return true iff the function parameter PARAM_DECL was expanded
2984 from the function parameter pack PACK. */
2987 function_parameter_expanded_from_pack_p (tree param_decl, tree pack)
2989 if (DECL_ARTIFICIAL (param_decl)
2990 || !function_parameter_pack_p (pack))
2993 /* The parameter pack and its pack arguments have the same
2995 return DECL_PARM_INDEX (pack) == DECL_PARM_INDEX (param_decl);
2998 /* Determine whether ARGS describes a variadic template args list,
2999 i.e., one that is terminated by a template argument pack. */
3002 template_args_variadic_p (tree args)
3007 if (args == NULL_TREE)
3010 args = INNERMOST_TEMPLATE_ARGS (args);
3011 nargs = TREE_VEC_LENGTH (args);
3016 last_parm = TREE_VEC_ELT (args, nargs - 1);
3018 return ARGUMENT_PACK_P (last_parm);
3021 /* Generate a new name for the parameter pack name NAME (an
3022 IDENTIFIER_NODE) that incorporates its */
3025 make_ith_pack_parameter_name (tree name, int i)
3027 /* Munge the name to include the parameter index. */
3028 #define NUMBUF_LEN 128
3029 char numbuf[NUMBUF_LEN];
3033 if (name == NULL_TREE)
3035 snprintf (numbuf, NUMBUF_LEN, "%i", i);
3036 newname_len = IDENTIFIER_LENGTH (name)
3037 + strlen (numbuf) + 2;
3038 newname = (char*)alloca (newname_len);
3039 snprintf (newname, newname_len,
3040 "%s#%i", IDENTIFIER_POINTER (name), i);
3041 return get_identifier (newname);
3044 /* Return true if T is a primary function, class or alias template
3048 primary_template_instantiation_p (const_tree t)
3053 if (TREE_CODE (t) == FUNCTION_DECL)
3054 return DECL_LANG_SPECIFIC (t)
3055 && DECL_TEMPLATE_INSTANTIATION (t)
3056 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t));
3057 else if (CLASS_TYPE_P (t) && !TYPE_DECL_ALIAS_P (TYPE_NAME (t)))
3058 return CLASSTYPE_TEMPLATE_INSTANTIATION (t)
3059 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t));
3060 else if (alias_template_specialization_p (t))
3065 /* Return true if PARM is a template template parameter. */
3068 template_template_parameter_p (const_tree parm)
3070 return DECL_TEMPLATE_TEMPLATE_PARM_P (parm);
3073 /* Return true iff PARM is a DECL representing a type template
3077 template_type_parameter_p (const_tree parm)
3080 && (TREE_CODE (parm) == TYPE_DECL
3081 || TREE_CODE (parm) == TEMPLATE_DECL)
3082 && DECL_TEMPLATE_PARM_P (parm));
3085 /* Return the template parameters of T if T is a
3086 primary template instantiation, NULL otherwise. */
3089 get_primary_template_innermost_parameters (const_tree t)
3091 tree parms = NULL, template_info = NULL;
3093 if ((template_info = get_template_info (t))
3094 && primary_template_instantiation_p (t))
3095 parms = INNERMOST_TEMPLATE_PARMS
3096 (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info)));
3101 /* Return the template parameters of the LEVELth level from the full list
3102 of template parameters PARMS. */
3105 get_template_parms_at_level (tree parms, int level)
3109 || TREE_CODE (parms) != TREE_LIST
3110 || level > TMPL_PARMS_DEPTH (parms))
3113 for (p = parms; p; p = TREE_CHAIN (p))
3114 if (TMPL_PARMS_DEPTH (p) == level)
3120 /* Returns the template arguments of T if T is a template instantiation,
3124 get_template_innermost_arguments (const_tree t)
3126 tree args = NULL, template_info = NULL;
3128 if ((template_info = get_template_info (t))
3129 && TI_ARGS (template_info))
3130 args = INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info));
3135 /* Return the argument pack elements of T if T is a template argument pack,
3139 get_template_argument_pack_elems (const_tree t)
3141 if (TREE_CODE (t) != TYPE_ARGUMENT_PACK
3142 && TREE_CODE (t) != NONTYPE_ARGUMENT_PACK)
3145 return ARGUMENT_PACK_ARGS (t);
3148 /* Structure used to track the progress of find_parameter_packs_r. */
3149 struct find_parameter_pack_data
3151 /* TREE_LIST that will contain all of the parameter packs found by
3153 tree* parameter_packs;
3155 /* Set of AST nodes that have been visited by the traversal. */
3156 hash_set<tree> *visited;
3159 /* Identifies all of the argument packs that occur in a template
3160 argument and appends them to the TREE_LIST inside DATA, which is a
3161 find_parameter_pack_data structure. This is a subroutine of
3162 make_pack_expansion and uses_parameter_packs. */
3164 find_parameter_packs_r (tree *tp, int *walk_subtrees, void* data)
3167 struct find_parameter_pack_data* ppd =
3168 (struct find_parameter_pack_data*)data;
3169 bool parameter_pack_p = false;
3171 /* Handle type aliases/typedefs. */
3172 if (TYPE_ALIAS_P (t))
3174 if (TYPE_TEMPLATE_INFO (t))
3175 cp_walk_tree (&TYPE_TI_ARGS (t),
3176 &find_parameter_packs_r,
3182 /* Identify whether this is a parameter pack or not. */
3183 switch (TREE_CODE (t))
3185 case TEMPLATE_PARM_INDEX:
3186 if (TEMPLATE_PARM_PARAMETER_PACK (t))
3187 parameter_pack_p = true;
3190 case TEMPLATE_TYPE_PARM:
3191 t = TYPE_MAIN_VARIANT (t);
3192 case TEMPLATE_TEMPLATE_PARM:
3193 if (TEMPLATE_TYPE_PARAMETER_PACK (t))
3194 parameter_pack_p = true;
3199 if (DECL_PACK_P (t))
3201 /* We don't want to walk into the type of a PARM_DECL,
3202 because we don't want to see the type parameter pack. */
3204 parameter_pack_p = true;
3208 /* Look through a lambda capture proxy to the field pack. */
3210 if (DECL_HAS_VALUE_EXPR_P (t))
3212 tree v = DECL_VALUE_EXPR (t);
3214 &find_parameter_packs_r,
3221 parameter_pack_p = true;
3224 /* Not a parameter pack. */
3228 if (parameter_pack_p)
3230 /* Add this parameter pack to the list. */
3231 *ppd->parameter_packs = tree_cons (NULL_TREE, t, *ppd->parameter_packs);
3235 cp_walk_tree (&TYPE_CONTEXT (t),
3236 &find_parameter_packs_r, ppd, ppd->visited);
3238 /* This switch statement will return immediately if we don't find a
3240 switch (TREE_CODE (t))
3242 case TEMPLATE_PARM_INDEX:
3245 case BOUND_TEMPLATE_TEMPLATE_PARM:
3246 /* Check the template itself. */
3247 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t)),
3248 &find_parameter_packs_r, ppd, ppd->visited);
3249 /* Check the template arguments. */
3250 cp_walk_tree (&TYPE_TI_ARGS (t), &find_parameter_packs_r, ppd,
3255 case TEMPLATE_TYPE_PARM:
3256 case TEMPLATE_TEMPLATE_PARM:
3263 if (TYPE_PTRMEMFUNC_P (t))
3269 if (TYPE_TEMPLATE_INFO (t))
3270 cp_walk_tree (&TYPE_TI_ARGS (t),
3271 &find_parameter_packs_r, ppd, ppd->visited);
3278 cp_walk_tree (&TREE_TYPE (t),
3279 &find_parameter_packs_r, ppd, ppd->visited);
3283 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t), &find_parameter_packs_r,
3288 case TYPE_PACK_EXPANSION:
3289 case EXPR_PACK_EXPANSION:
3294 cp_walk_tree (&TYPE_MAX_VALUE (t), &find_parameter_packs_r,
3299 case IDENTIFIER_NODE:
3300 cp_walk_tree (&TREE_TYPE (t), &find_parameter_packs_r, ppd,
3312 /* Determines if the expression or type T uses any parameter packs. */
3314 uses_parameter_packs (tree t)
3316 tree parameter_packs = NULL_TREE;
3317 struct find_parameter_pack_data ppd;
3318 ppd.parameter_packs = ¶meter_packs;
3319 ppd.visited = new hash_set<tree>;
3320 cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
3322 return parameter_packs != NULL_TREE;
3325 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3326 representation a base-class initializer into a parameter pack
3327 expansion. If all goes well, the resulting node will be an
3328 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3331 make_pack_expansion (tree arg)
3334 tree parameter_packs = NULL_TREE;
3335 bool for_types = false;
3336 struct find_parameter_pack_data ppd;
3338 if (!arg || arg == error_mark_node)
3341 if (TREE_CODE (arg) == TREE_LIST)
3343 /* The only time we will see a TREE_LIST here is for a base
3344 class initializer. In this case, the TREE_PURPOSE will be a
3345 _TYPE node (representing the base class expansion we're
3346 initializing) and the TREE_VALUE will be a TREE_LIST
3347 containing the initialization arguments.
3349 The resulting expansion looks somewhat different from most
3350 expansions. Rather than returning just one _EXPANSION, we
3351 return a TREE_LIST whose TREE_PURPOSE is a
3352 TYPE_PACK_EXPANSION containing the bases that will be
3353 initialized. The TREE_VALUE will be identical to the
3354 original TREE_VALUE, which is a list of arguments that will
3355 be passed to each base. We do not introduce any new pack
3356 expansion nodes into the TREE_VALUE (although it is possible
3357 that some already exist), because the TREE_PURPOSE and
3358 TREE_VALUE all need to be expanded together with the same
3359 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3360 resulting TREE_PURPOSE will mention the parameter packs in
3361 both the bases and the arguments to the bases. */
3364 tree parameter_packs = NULL_TREE;
3366 /* Determine which parameter packs will be used by the base
3368 ppd.visited = new hash_set<tree>;
3369 ppd.parameter_packs = ¶meter_packs;
3370 cp_walk_tree (&TREE_PURPOSE (arg), &find_parameter_packs_r,
3373 if (parameter_packs == NULL_TREE)
3375 error ("base initializer expansion %<%T%> contains no parameter packs", arg);
3377 return error_mark_node;
3380 if (TREE_VALUE (arg) != void_type_node)
3382 /* Collect the sets of parameter packs used in each of the
3383 initialization arguments. */
3384 for (value = TREE_VALUE (arg); value; value = TREE_CHAIN (value))
3386 /* Determine which parameter packs will be expanded in this
3388 cp_walk_tree (&TREE_VALUE (value), &find_parameter_packs_r,
3395 /* Create the pack expansion type for the base type. */
3396 purpose = cxx_make_type (TYPE_PACK_EXPANSION);
3397 SET_PACK_EXPANSION_PATTERN (purpose, TREE_PURPOSE (arg));
3398 PACK_EXPANSION_PARAMETER_PACKS (purpose) = parameter_packs;
3400 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3401 they will rarely be compared to anything. */
3402 SET_TYPE_STRUCTURAL_EQUALITY (purpose);
3404 return tree_cons (purpose, TREE_VALUE (arg), NULL_TREE);
3407 if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
3410 /* Build the PACK_EXPANSION_* node. */
3412 ? cxx_make_type (TYPE_PACK_EXPANSION)
3413 : make_node (EXPR_PACK_EXPANSION);
3414 SET_PACK_EXPANSION_PATTERN (result, arg);
3415 if (TREE_CODE (result) == EXPR_PACK_EXPANSION)
3417 /* Propagate type and const-expression information. */
3418 TREE_TYPE (result) = TREE_TYPE (arg);
3419 TREE_CONSTANT (result) = TREE_CONSTANT (arg);
3422 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3423 they will rarely be compared to anything. */
3424 SET_TYPE_STRUCTURAL_EQUALITY (result);
3426 /* Determine which parameter packs will be expanded. */
3427 ppd.parameter_packs = ¶meter_packs;
3428 ppd.visited = new hash_set<tree>;
3429 cp_walk_tree (&arg, &find_parameter_packs_r, &ppd, ppd.visited);
3432 /* Make sure we found some parameter packs. */
3433 if (parameter_packs == NULL_TREE)
3436 error ("expansion pattern %<%T%> contains no argument packs", arg);
3438 error ("expansion pattern %<%E%> contains no argument packs", arg);
3439 return error_mark_node;
3441 PACK_EXPANSION_PARAMETER_PACKS (result) = parameter_packs;
3443 PACK_EXPANSION_LOCAL_P (result) = at_function_scope_p ();
3448 /* Checks T for any "bare" parameter packs, which have not yet been
3449 expanded, and issues an error if any are found. This operation can
3450 only be done on full expressions or types (e.g., an expression
3451 statement, "if" condition, etc.), because we could have expressions like:
3453 foo(f(g(h(args)))...)
3455 where "args" is a parameter pack. check_for_bare_parameter_packs
3456 should not be called for the subexpressions args, h(args),
3457 g(h(args)), or f(g(h(args))), because we would produce erroneous
3460 Returns TRUE and emits an error if there were bare parameter packs,
3461 returns FALSE otherwise. */
3463 check_for_bare_parameter_packs (tree t)
3465 tree parameter_packs = NULL_TREE;
3466 struct find_parameter_pack_data ppd;
3468 if (!processing_template_decl || !t || t == error_mark_node)
3471 if (TREE_CODE (t) == TYPE_DECL)
3474 ppd.parameter_packs = ¶meter_packs;
3475 ppd.visited = new hash_set<tree>;
3476 cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
3479 if (parameter_packs)
3481 error ("parameter packs not expanded with %<...%>:");
3482 while (parameter_packs)
3484 tree pack = TREE_VALUE (parameter_packs);
3485 tree name = NULL_TREE;
3487 if (TREE_CODE (pack) == TEMPLATE_TYPE_PARM
3488 || TREE_CODE (pack) == TEMPLATE_TEMPLATE_PARM)
3489 name = TYPE_NAME (pack);
3490 else if (TREE_CODE (pack) == TEMPLATE_PARM_INDEX)
3491 name = DECL_NAME (TEMPLATE_PARM_DECL (pack));
3493 name = DECL_NAME (pack);
3496 inform (input_location, " %qD", name);
3498 inform (input_location, " <anonymous>");
3500 parameter_packs = TREE_CHAIN (parameter_packs);
3509 /* Expand any parameter packs that occur in the template arguments in
3512 expand_template_argument_pack (tree args)
3514 tree result_args = NULL_TREE;
3515 int in_arg, out_arg = 0, nargs = args ? TREE_VEC_LENGTH (args) : 0;
3516 int num_result_args = -1;
3517 int non_default_args_count = -1;
3519 /* First, determine if we need to expand anything, and the number of
3520 slots we'll need. */
3521 for (in_arg = 0; in_arg < nargs; ++in_arg)
3523 tree arg = TREE_VEC_ELT (args, in_arg);
3524 if (arg == NULL_TREE)
3526 if (ARGUMENT_PACK_P (arg))
3528 int num_packed = TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg));
3529 if (num_result_args < 0)
3530 num_result_args = in_arg + num_packed;
3532 num_result_args += num_packed;
3536 if (num_result_args >= 0)
3541 /* If no expansion is necessary, we're done. */
3542 if (num_result_args < 0)
3545 /* Expand arguments. */
3546 result_args = make_tree_vec (num_result_args);
3547 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args))
3548 non_default_args_count =
3549 GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args);
3550 for (in_arg = 0; in_arg < nargs; ++in_arg)
3552 tree arg = TREE_VEC_ELT (args, in_arg);
3553 if (ARGUMENT_PACK_P (arg))
3555 tree packed = ARGUMENT_PACK_ARGS (arg);
3556 int i, num_packed = TREE_VEC_LENGTH (packed);
3557 for (i = 0; i < num_packed; ++i, ++out_arg)
3558 TREE_VEC_ELT (result_args, out_arg) = TREE_VEC_ELT(packed, i);
3559 if (non_default_args_count > 0)
3560 non_default_args_count += num_packed - 1;
3564 TREE_VEC_ELT (result_args, out_arg) = arg;
3568 if (non_default_args_count >= 0)
3569 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args, non_default_args_count);
3573 /* Checks if DECL shadows a template parameter.
3575 [temp.local]: A template-parameter shall not be redeclared within its
3576 scope (including nested scopes).
3578 Emits an error and returns TRUE if the DECL shadows a parameter,
3579 returns FALSE otherwise. */
3582 check_template_shadow (tree decl)
3586 /* If we're not in a template, we can't possibly shadow a template
3588 if (!current_template_parms)
3591 /* Figure out what we're shadowing. */
3592 if (TREE_CODE (decl) == OVERLOAD)
3593 decl = OVL_CURRENT (decl);
3594 olddecl = innermost_non_namespace_value (DECL_NAME (decl));
3596 /* If there's no previous binding for this name, we're not shadowing
3597 anything, let alone a template parameter. */
3601 /* If we're not shadowing a template parameter, we're done. Note
3602 that OLDDECL might be an OVERLOAD (or perhaps even an
3603 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3605 if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
3608 /* We check for decl != olddecl to avoid bogus errors for using a
3609 name inside a class. We check TPFI to avoid duplicate errors for
3610 inline member templates. */
3612 || (DECL_TEMPLATE_PARM_P (decl)
3613 && TEMPLATE_PARMS_FOR_INLINE (current_template_parms)))
3616 /* Don't complain about the injected class name, as we've already
3617 complained about the class itself. */
3618 if (DECL_SELF_REFERENCE_P (decl))
3621 error ("declaration of %q+#D", decl);
3622 error (" shadows template parm %q+#D", olddecl);
3626 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3627 ORIG_LEVEL, DECL, and TYPE. */
3630 build_template_parm_index (int index,
3636 tree t = make_node (TEMPLATE_PARM_INDEX);
3637 TEMPLATE_PARM_IDX (t) = index;
3638 TEMPLATE_PARM_LEVEL (t) = level;
3639 TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
3640 TEMPLATE_PARM_DECL (t) = decl;
3641 TREE_TYPE (t) = type;
3642 TREE_CONSTANT (t) = TREE_CONSTANT (decl);
3643 TREE_READONLY (t) = TREE_READONLY (decl);
3648 /* Find the canonical type parameter for the given template type
3649 parameter. Returns the canonical type parameter, which may be TYPE
3650 if no such parameter existed. */
3653 canonical_type_parameter (tree type)
3656 int idx = TEMPLATE_TYPE_IDX (type);
3657 if (!canonical_template_parms)
3658 vec_alloc (canonical_template_parms, idx+1);
3660 while (canonical_template_parms->length () <= (unsigned)idx)
3661 vec_safe_push (canonical_template_parms, NULL_TREE);
3663 list = (*canonical_template_parms)[idx];
3664 while (list && !comptypes (type, TREE_VALUE (list), COMPARE_STRUCTURAL))
3665 list = TREE_CHAIN (list);
3668 return TREE_VALUE (list);
3671 (*canonical_template_parms)[idx]
3672 = tree_cons (NULL_TREE, type,
3673 (*canonical_template_parms)[idx]);
3678 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3679 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3680 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3681 new one is created. */
3684 reduce_template_parm_level (tree index, tree type, int levels, tree args,
3685 tsubst_flags_t complain)
3687 if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
3688 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
3689 != TEMPLATE_PARM_LEVEL (index) - levels)
3690 || !same_type_p (type, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index))))
3692 tree orig_decl = TEMPLATE_PARM_DECL (index);
3695 decl = build_decl (DECL_SOURCE_LOCATION (orig_decl),
3696 TREE_CODE (orig_decl), DECL_NAME (orig_decl), type);
3697 TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl);
3698 TREE_READONLY (decl) = TREE_READONLY (orig_decl);
3699 DECL_ARTIFICIAL (decl) = 1;
3700 SET_DECL_TEMPLATE_PARM_P (decl);
3702 t = build_template_parm_index (TEMPLATE_PARM_IDX (index),
3703 TEMPLATE_PARM_LEVEL (index) - levels,
3704 TEMPLATE_PARM_ORIG_LEVEL (index),
3706 TEMPLATE_PARM_DESCENDANTS (index) = t;
3707 TEMPLATE_PARM_PARAMETER_PACK (t)
3708 = TEMPLATE_PARM_PARAMETER_PACK (index);
3710 /* Template template parameters need this. */
3711 if (TREE_CODE (decl) == TEMPLATE_DECL)
3712 DECL_TEMPLATE_PARMS (decl) = tsubst_template_parms
3713 (DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index)),
3717 return TEMPLATE_PARM_DESCENDANTS (index);
3720 /* Process information from new template parameter PARM and append it
3721 to the LIST being built. This new parameter is a non-type
3722 parameter iff IS_NON_TYPE is true. This new parameter is a
3723 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
3727 process_template_parm (tree list, location_t parm_loc, tree parm,
3728 bool is_non_type, bool is_parameter_pack)
3734 gcc_assert (TREE_CODE (parm) == TREE_LIST);
3735 defval = TREE_PURPOSE (parm);
3739 tree p = tree_last (list);
3741 if (p && TREE_VALUE (p) != error_mark_node)
3744 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
3745 idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
3747 idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
3755 parm = TREE_VALUE (parm);
3757 SET_DECL_TEMPLATE_PARM_P (parm);
3759 if (TREE_TYPE (parm) != error_mark_node)
3763 The top-level cv-qualifiers on the template-parameter are
3764 ignored when determining its type. */
3765 TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
3766 if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
3767 TREE_TYPE (parm) = error_mark_node;
3768 else if (uses_parameter_packs (TREE_TYPE (parm))
3769 && !is_parameter_pack
3770 /* If we're in a nested template parameter list, the template
3771 template parameter could be a parameter pack. */
3772 && processing_template_parmlist == 1)
3774 /* This template parameter is not a parameter pack, but it
3775 should be. Complain about "bare" parameter packs. */
3776 check_for_bare_parameter_packs (TREE_TYPE (parm));
3778 /* Recover by calling this a parameter pack. */
3779 is_parameter_pack = true;
3783 /* A template parameter is not modifiable. */
3784 TREE_CONSTANT (parm) = 1;
3785 TREE_READONLY (parm) = 1;
3786 decl = build_decl (parm_loc,
3787 CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
3788 TREE_CONSTANT (decl) = 1;
3789 TREE_READONLY (decl) = 1;
3790 DECL_INITIAL (parm) = DECL_INITIAL (decl)
3791 = build_template_parm_index (idx, processing_template_decl,
3792 processing_template_decl,
3793 decl, TREE_TYPE (parm));
3795 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm))
3796 = is_parameter_pack;
3801 parm = TREE_VALUE (TREE_VALUE (parm));
3803 if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
3805 t = cxx_make_type (TEMPLATE_TEMPLATE_PARM);
3806 /* This is for distinguishing between real templates and template
3807 template parameters */
3808 TREE_TYPE (parm) = t;
3809 TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t;
3814 t = cxx_make_type (TEMPLATE_TYPE_PARM);
3815 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3816 decl = build_decl (parm_loc,
3817 TYPE_DECL, parm, t);
3820 TYPE_NAME (t) = decl;
3821 TYPE_STUB_DECL (t) = decl;
3823 TEMPLATE_TYPE_PARM_INDEX (t)
3824 = build_template_parm_index (idx, processing_template_decl,
3825 processing_template_decl,
3826 decl, TREE_TYPE (parm));
3827 TEMPLATE_TYPE_PARAMETER_PACK (t) = is_parameter_pack;
3828 TYPE_CANONICAL (t) = canonical_type_parameter (t);
3830 DECL_ARTIFICIAL (decl) = 1;
3831 SET_DECL_TEMPLATE_PARM_P (decl);
3833 parm = build_tree_list (defval, parm);
3834 return chainon (list, parm);
3837 /* The end of a template parameter list has been reached. Process the
3838 tree list into a parameter vector, converting each parameter into a more
3839 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3843 end_template_parm_list (tree parms)
3847 tree saved_parmlist = make_tree_vec (list_length (parms));
3849 current_template_parms
3850 = tree_cons (size_int (processing_template_decl),
3851 saved_parmlist, current_template_parms);
3853 for (parm = parms, nparms = 0; parm; parm = next, nparms++)
3855 next = TREE_CHAIN (parm);
3856 TREE_VEC_ELT (saved_parmlist, nparms) = parm;
3857 TREE_CHAIN (parm) = NULL_TREE;
3860 --processing_template_parmlist;
3862 return saved_parmlist;
3865 /* end_template_decl is called after a template declaration is seen. */
3868 end_template_decl (void)
3870 reset_specialization ();
3872 if (! processing_template_decl)
3875 /* This matches the pushlevel in begin_template_parm_list. */
3878 --processing_template_decl;
3879 current_template_parms = TREE_CHAIN (current_template_parms);
3882 /* Takes a TREE_LIST representing a template parameter and convert it
3883 into an argument suitable to be passed to the type substitution
3884 functions. Note that If the TREE_LIST contains an error_mark
3885 node, the returned argument is error_mark_node. */
3888 template_parm_to_arg (tree t)
3892 || TREE_CODE (t) != TREE_LIST)
3895 if (error_operand_p (TREE_VALUE (t)))
3896 return error_mark_node;
3900 if (TREE_CODE (t) == TYPE_DECL
3901 || TREE_CODE (t) == TEMPLATE_DECL)
3905 if (TEMPLATE_TYPE_PARAMETER_PACK (t))
3907 /* Turn this argument into a TYPE_ARGUMENT_PACK
3908 with a single element, which expands T. */
3909 tree vec = make_tree_vec (1);
3910 #ifdef ENABLE_CHECKING
3911 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3912 (vec, TREE_VEC_LENGTH (vec));
3914 TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
3916 t = cxx_make_type (TYPE_ARGUMENT_PACK);
3917 SET_ARGUMENT_PACK_ARGS (t, vec);
3922 t = DECL_INITIAL (t);
3924 if (TEMPLATE_PARM_PARAMETER_PACK (t))
3926 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3927 with a single element, which expands T. */
3928 tree vec = make_tree_vec (1);
3929 tree type = TREE_TYPE (TEMPLATE_PARM_DECL (t));
3930 #ifdef ENABLE_CHECKING
3931 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3932 (vec, TREE_VEC_LENGTH (vec));
3934 t = convert_from_reference (t);
3935 TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
3937 t = make_node (NONTYPE_ARGUMENT_PACK);
3938 SET_ARGUMENT_PACK_ARGS (t, vec);
3939 TREE_TYPE (t) = type;
3942 t = convert_from_reference (t);
3947 /* Given a set of template parameters, return them as a set of template
3948 arguments. The template parameters are represented as a TREE_VEC, in
3949 the form documented in cp-tree.h for template arguments. */
3952 template_parms_to_args (tree parms)
3955 tree args = NULL_TREE;
3956 int length = TMPL_PARMS_DEPTH (parms);
3959 /* If there is only one level of template parameters, we do not
3960 create a TREE_VEC of TREE_VECs. Instead, we return a single
3961 TREE_VEC containing the arguments. */
3963 args = make_tree_vec (length);
3965 for (header = parms; header; header = TREE_CHAIN (header))
3967 tree a = copy_node (TREE_VALUE (header));
3970 TREE_TYPE (a) = NULL_TREE;
3971 for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
3972 TREE_VEC_ELT (a, i) = template_parm_to_arg (TREE_VEC_ELT (a, i));
3974 #ifdef ENABLE_CHECKING
3975 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a, TREE_VEC_LENGTH (a));
3979 TREE_VEC_ELT (args, --l) = a;
3984 if (length > 1 && TREE_VEC_ELT (args, 0) == NULL_TREE)
3985 /* This can happen for template parms of a template template
3988 template<template<class T, class U> class TT> struct S;
3990 Consider the level of the parms of TT; T and U both have
3991 level 2; TT has no template parm of level 1. So in this case
3992 the first element of full_template_args is NULL_TREE. If we
3993 leave it like this TMPL_ARGS_DEPTH on args returns 1 instead
3994 of 2. This will make tsubst wrongly consider that T and U
3995 have level 1. Instead, let's create a dummy vector as the
3996 first element of full_template_args so that TMPL_ARGS_DEPTH
3997 returns the correct depth for args. */
3998 TREE_VEC_ELT (args, 0) = make_tree_vec (1);
4002 /* Within the declaration of a template, return the currently active
4003 template parameters as an argument TREE_VEC. */
4006 current_template_args (void)
4008 return template_parms_to_args (current_template_parms);
4011 /* Update the declared TYPE by doing any lookups which were thought to be
4012 dependent, but are not now that we know the SCOPE of the declarator. */
4015 maybe_update_decl_type (tree orig_type, tree scope)
4017 tree type = orig_type;
4019 if (type == NULL_TREE)
4022 if (TREE_CODE (orig_type) == TYPE_DECL)
4023 type = TREE_TYPE (type);
4025 if (scope && TYPE_P (scope) && dependent_type_p (scope)
4026 && dependent_type_p (type)
4027 /* Don't bother building up the args in this case. */
4028 && TREE_CODE (type) != TEMPLATE_TYPE_PARM)
4030 /* tsubst in the args corresponding to the template parameters,
4031 including auto if present. Most things will be unchanged, but
4032 make_typename_type and tsubst_qualified_id will resolve
4033 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
4034 tree args = current_template_args ();
4035 tree auto_node = type_uses_auto (type);
4039 tree auto_vec = make_tree_vec (1);
4040 TREE_VEC_ELT (auto_vec, 0) = auto_node;
4041 args = add_to_template_args (args, auto_vec);
4043 pushed = push_scope (scope);
4044 type = tsubst (type, args, tf_warning_or_error, NULL_TREE);
4049 if (type == error_mark_node)
4052 if (TREE_CODE (orig_type) == TYPE_DECL)
4054 if (same_type_p (type, TREE_TYPE (orig_type)))
4057 type = TYPE_NAME (type);
4062 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
4063 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
4064 a member template. Used by push_template_decl below. */
4067 build_template_decl (tree decl, tree parms, bool member_template_p)
4069 tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
4070 DECL_TEMPLATE_PARMS (tmpl) = parms;
4071 DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
4072 DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
4073 DECL_MEMBER_TEMPLATE_P (tmpl) = member_template_p;
4078 struct template_parm_data
4080 /* The level of the template parameters we are currently
4084 /* The index of the specialization argument we are currently
4088 /* An array whose size is the number of template parameters. The
4089 elements are nonzero if the parameter has been used in any one
4090 of the arguments processed so far. */
4093 /* An array whose size is the number of template arguments. The
4094 elements are nonzero if the argument makes use of template
4095 parameters of this level. */
4096 int* arg_uses_template_parms;
4099 /* Subroutine of push_template_decl used to see if each template
4100 parameter in a partial specialization is used in the explicit
4101 argument list. If T is of the LEVEL given in DATA (which is
4102 treated as a template_parm_data*), then DATA->PARMS is marked
4106 mark_template_parm (tree t, void* data)
4110 struct template_parm_data* tpd = (struct template_parm_data*) data;
4112 template_parm_level_and_index (t, &level, &idx);
4114 if (level == tpd->level)
4116 tpd->parms[idx] = 1;
4117 tpd->arg_uses_template_parms[tpd->current_arg] = 1;
4120 /* Return zero so that for_each_template_parm will continue the
4121 traversal of the tree; we want to mark *every* template parm. */
4125 /* Process the partial specialization DECL. */
4128 process_partial_specialization (tree decl)
4130 tree type = TREE_TYPE (decl);
4131 tree tinfo = get_template_info (decl);
4132 tree maintmpl = TI_TEMPLATE (tinfo);
4133 tree specargs = TI_ARGS (tinfo);
4134 tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
4135 tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
4138 int nargs = TREE_VEC_LENGTH (inner_args);
4141 bool did_error_intro = false;
4142 struct template_parm_data tpd;
4143 struct template_parm_data tpd2;
4145 gcc_assert (current_template_parms);
4147 inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
4148 ntparms = TREE_VEC_LENGTH (inner_parms);
4150 /* We check that each of the template parameters given in the
4151 partial specialization is used in the argument list to the
4152 specialization. For example:
4154 template <class T> struct S;
4155 template <class T> struct S<T*>;
4157 The second declaration is OK because `T*' uses the template
4158 parameter T, whereas
4160 template <class T> struct S<int>;
4162 is no good. Even trickier is:
4173 The S2<T> declaration is actually invalid; it is a
4174 full-specialization. Of course,
4177 struct S2<T (*)(U)>;
4179 or some such would have been OK. */
4180 tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
4181 tpd.parms = XALLOCAVEC (int, ntparms);
4182 memset (tpd.parms, 0, sizeof (int) * ntparms);
4184 tpd.arg_uses_template_parms = XALLOCAVEC (int, nargs);
4185 memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
4186 for (i = 0; i < nargs; ++i)
4188 tpd.current_arg = i;
4189 for_each_template_parm (TREE_VEC_ELT (inner_args, i),
4190 &mark_template_parm,
4193 /*include_nondeduced_p=*/false);
4195 for (i = 0; i < ntparms; ++i)
4196 if (tpd.parms[i] == 0)
4198 /* One of the template parms was not used in a deduced context in the
4200 if (!did_error_intro)
4202 error ("template parameters not deducible in "
4203 "partial specialization:");
4204 did_error_intro = true;
4207 inform (input_location, " %qD",
4208 TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
4211 if (did_error_intro)
4212 return error_mark_node;
4214 /* [temp.class.spec]
4216 The argument list of the specialization shall not be identical to
4217 the implicit argument list of the primary template. */
4219 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (maintmpl)));
4220 if (comp_template_args (inner_args, INNERMOST_TEMPLATE_ARGS (main_args)))
4221 error ("partial specialization %qD does not specialize "
4222 "any template arguments", decl);
4224 /* A partial specialization that replaces multiple parameters of the
4225 primary template with a pack expansion is less specialized for those
4227 if (nargs < DECL_NTPARMS (maintmpl))
4229 error ("partial specialization is not more specialized than the "
4230 "primary template because it replaces multiple parameters "
4231 "with a pack expansion");
4232 inform (DECL_SOURCE_LOCATION (maintmpl), "primary template here");
4236 /* [temp.class.spec]
4238 A partially specialized non-type argument expression shall not
4239 involve template parameters of the partial specialization except
4240 when the argument expression is a simple identifier.
4242 The type of a template parameter corresponding to a specialized
4243 non-type argument shall not be dependent on a parameter of the
4246 Also, we verify that pack expansions only occur at the
4247 end of the argument list. */
4248 gcc_assert (nargs == DECL_NTPARMS (maintmpl));
4250 for (i = 0; i < nargs; ++i)
4252 tree parm = TREE_VALUE (TREE_VEC_ELT (main_inner_parms, i));
4253 tree arg = TREE_VEC_ELT (inner_args, i);
4254 tree packed_args = NULL_TREE;
4257 if (ARGUMENT_PACK_P (arg))
4259 /* Extract the arguments from the argument pack. We'll be
4260 iterating over these in the following loop. */
4261 packed_args = ARGUMENT_PACK_ARGS (arg);
4262 len = TREE_VEC_LENGTH (packed_args);
4265 for (j = 0; j < len; j++)
4268 /* Get the Jth argument in the parameter pack. */
4269 arg = TREE_VEC_ELT (packed_args, j);
4271 if (PACK_EXPANSION_P (arg))
4273 /* Pack expansions must come at the end of the
4275 if ((packed_args && j < len - 1)
4276 || (!packed_args && i < nargs - 1))
4278 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
4279 error ("parameter pack argument %qE must be at the "
4280 "end of the template argument list", arg);
4282 error ("parameter pack argument %qT must be at the "
4283 "end of the template argument list", arg);
4287 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
4288 /* We only care about the pattern. */
4289 arg = PACK_EXPANSION_PATTERN (arg);
4291 if (/* These first two lines are the `non-type' bit. */
4293 && TREE_CODE (arg) != TEMPLATE_DECL
4294 /* This next two lines are the `argument expression is not just a
4295 simple identifier' condition and also the `specialized
4296 non-type argument' bit. */
4297 && TREE_CODE (arg) != TEMPLATE_PARM_INDEX
4298 && !(REFERENCE_REF_P (arg)
4299 && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_PARM_INDEX))
4301 if ((!packed_args && tpd.arg_uses_template_parms[i])
4302 || (packed_args && uses_template_parms (arg)))
4303 error ("template argument %qE involves template parameter(s)",
4307 /* Look at the corresponding template parameter,
4308 marking which template parameters its type depends
4310 tree type = TREE_TYPE (parm);
4314 /* We haven't yet initialized TPD2. Do so now. */
4315 tpd2.arg_uses_template_parms = XALLOCAVEC (int, nargs);
4316 /* The number of parameters here is the number in the
4317 main template, which, as checked in the assertion
4319 tpd2.parms = XALLOCAVEC (int, nargs);
4321 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
4324 /* Mark the template parameters. But this time, we're
4325 looking for the template parameters of the main
4326 template, not in the specialization. */
4327 tpd2.current_arg = i;
4328 tpd2.arg_uses_template_parms[i] = 0;
4329 memset (tpd2.parms, 0, sizeof (int) * nargs);
4330 for_each_template_parm (type,
4331 &mark_template_parm,
4334 /*include_nondeduced_p=*/false);
4336 if (tpd2.arg_uses_template_parms [i])
4338 /* The type depended on some template parameters.
4339 If they are fully specialized in the
4340 specialization, that's OK. */
4343 for (j = 0; j < nargs; ++j)
4344 if (tpd2.parms[j] != 0
4345 && tpd.arg_uses_template_parms [j])
4348 error_n (input_location, count,
4349 "type %qT of template argument %qE depends "
4350 "on a template parameter",
4351 "type %qT of template argument %qE depends "
4352 "on template parameters",
4361 /* We should only get here once. */
4362 if (TREE_CODE (decl) == TYPE_DECL)
4363 gcc_assert (!COMPLETE_TYPE_P (type));
4365 tree tmpl = build_template_decl (decl, current_template_parms,
4366 DECL_MEMBER_TEMPLATE_P (maintmpl));
4367 TREE_TYPE (tmpl) = type;
4368 DECL_TEMPLATE_RESULT (tmpl) = decl;
4369 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
4370 DECL_TEMPLATE_INFO (tmpl) = build_template_info (maintmpl, specargs);
4371 DECL_PRIMARY_TEMPLATE (tmpl) = maintmpl;
4373 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
4374 = tree_cons (specargs, tmpl,
4375 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
4376 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
4378 for (inst = DECL_TEMPLATE_INSTANTIATIONS (maintmpl); inst;
4379 inst = TREE_CHAIN (inst))
4381 tree instance = TREE_VALUE (inst);
4382 if (TYPE_P (instance)
4383 ? (COMPLETE_TYPE_P (instance)
4384 && CLASSTYPE_IMPLICIT_INSTANTIATION (instance))
4385 : DECL_TEMPLATE_INSTANTIATION (instance))
4387 tree spec = most_specialized_partial_spec (instance, tf_none);
4388 if (spec && TREE_VALUE (spec) == tmpl)
4390 tree inst_decl = (DECL_P (instance)
4391 ? instance : TYPE_NAME (instance));
4392 permerror (input_location,
4393 "partial specialization of %qD after instantiation "
4394 "of %qD", decl, inst_decl);
4402 /* PARM is a template parameter of some form; return the corresponding
4403 TEMPLATE_PARM_INDEX. */
4406 get_template_parm_index (tree parm)
4408 if (TREE_CODE (parm) == PARM_DECL
4409 || TREE_CODE (parm) == CONST_DECL)
4410 parm = DECL_INITIAL (parm);
4411 else if (TREE_CODE (parm) == TYPE_DECL
4412 || TREE_CODE (parm) == TEMPLATE_DECL)
4413 parm = TREE_TYPE (parm);
4414 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
4415 || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM)
4416 parm = TEMPLATE_TYPE_PARM_INDEX (parm);
4417 gcc_assert (TREE_CODE (parm) == TEMPLATE_PARM_INDEX);
4421 /* Subroutine of fixed_parameter_pack_p below. Look for any template
4422 parameter packs used by the template parameter PARM. */
4425 fixed_parameter_pack_p_1 (tree parm, struct find_parameter_pack_data *ppd)
4427 /* A type parm can't refer to another parm. */
4428 if (TREE_CODE (parm) == TYPE_DECL)
4430 else if (TREE_CODE (parm) == PARM_DECL)
4432 cp_walk_tree (&TREE_TYPE (parm), &find_parameter_packs_r,
4437 gcc_assert (TREE_CODE (parm) == TEMPLATE_DECL);
4439 tree vec = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (parm));
4440 for (int i = 0; i < TREE_VEC_LENGTH (vec); ++i)
4441 fixed_parameter_pack_p_1 (TREE_VALUE (TREE_VEC_ELT (vec, i)), ppd);
4444 /* PARM is a template parameter pack. Return any parameter packs used in
4445 its type or the type of any of its template parameters. If there are
4446 any such packs, it will be instantiated into a fixed template parameter
4447 list by partial instantiation rather than be fully deduced. */
4450 fixed_parameter_pack_p (tree parm)
4452 /* This can only be true in a member template. */
4453 if (TEMPLATE_PARM_ORIG_LEVEL (get_template_parm_index (parm)) < 2)
4455 /* This can only be true for a parameter pack. */
4456 if (!template_parameter_pack_p (parm))
4458 /* A type parm can't refer to another parm. */
4459 if (TREE_CODE (parm) == TYPE_DECL)
4462 tree parameter_packs = NULL_TREE;
4463 struct find_parameter_pack_data ppd;
4464 ppd.parameter_packs = ¶meter_packs;
4465 ppd.visited = new hash_set<tree>;
4467 fixed_parameter_pack_p_1 (parm, &ppd);
4470 return parameter_packs;
4473 /* Check that a template declaration's use of default arguments and
4474 parameter packs is not invalid. Here, PARMS are the template
4475 parameters. IS_PRIMARY is true if DECL is the thing declared by
4476 a primary template. IS_PARTIAL is true if DECL is a partial
4479 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4480 declaration (but not a definition); 1 indicates a declaration, 2
4481 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4482 emitted for extraneous default arguments.
4484 Returns TRUE if there were no errors found, FALSE otherwise. */
4487 check_default_tmpl_args (tree decl, tree parms, bool is_primary,
4488 bool is_partial, int is_friend_decl)
4491 int last_level_to_check;
4493 bool no_errors = true;
4497 A default template-argument shall not be specified in a
4498 function template declaration or a function template definition, nor
4499 in the template-parameter-list of the definition of a member of a
4502 if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL
4503 || (TREE_CODE (decl) == FUNCTION_DECL && DECL_LOCAL_FUNCTION_P (decl)))
4504 /* You can't have a function template declaration in a local
4505 scope, nor you can you define a member of a class template in a
4509 if ((TREE_CODE (decl) == TYPE_DECL
4511 && LAMBDA_TYPE_P (TREE_TYPE (decl)))
4512 || (TREE_CODE (decl) == FUNCTION_DECL
4513 && LAMBDA_FUNCTION_P (decl)))
4514 /* A lambda doesn't have an explicit declaration; don't complain
4515 about the parms of the enclosing class. */
4518 if (current_class_type
4519 && !TYPE_BEING_DEFINED (current_class_type)
4520 && DECL_LANG_SPECIFIC (decl)
4521 && DECL_DECLARES_FUNCTION_P (decl)
4522 /* If this is either a friend defined in the scope of the class
4523 or a member function. */
4524 && (DECL_FUNCTION_MEMBER_P (decl)
4525 ? same_type_p (DECL_CONTEXT (decl), current_class_type)
4526 : DECL_FRIEND_CONTEXT (decl)
4527 ? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type)
4529 /* And, if it was a member function, it really was defined in
4530 the scope of the class. */
4531 && (!DECL_FUNCTION_MEMBER_P (decl)
4532 || DECL_INITIALIZED_IN_CLASS_P (decl)))
4533 /* We already checked these parameters when the template was
4534 declared, so there's no need to do it again now. This function
4535 was defined in class scope, but we're processing its body now
4536 that the class is complete. */
4539 /* Core issue 226 (C++0x only): the following only applies to class
4542 && ((cxx_dialect == cxx98) || TREE_CODE (decl) != FUNCTION_DECL))
4546 If a template-parameter has a default template-argument, all
4547 subsequent template-parameters shall have a default
4548 template-argument supplied. */
4549 for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
4551 tree inner_parms = TREE_VALUE (parm_level);
4552 int ntparms = TREE_VEC_LENGTH (inner_parms);
4553 int seen_def_arg_p = 0;
4556 for (i = 0; i < ntparms; ++i)
4558 tree parm = TREE_VEC_ELT (inner_parms, i);
4560 if (parm == error_mark_node)
4563 if (TREE_PURPOSE (parm))
4565 else if (seen_def_arg_p
4566 && !template_parameter_pack_p (TREE_VALUE (parm)))
4568 error ("no default argument for %qD", TREE_VALUE (parm));
4569 /* For better subsequent error-recovery, we indicate that
4570 there should have been a default argument. */
4571 TREE_PURPOSE (parm) = error_mark_node;
4574 else if (!is_partial
4576 /* Don't complain about an enclosing partial
4578 && parm_level == parms
4579 && TREE_CODE (decl) == TYPE_DECL
4581 && template_parameter_pack_p (TREE_VALUE (parm))
4582 /* A fixed parameter pack will be partially
4583 instantiated into a fixed length list. */
4584 && !fixed_parameter_pack_p (TREE_VALUE (parm)))
4586 /* A primary class template can only have one
4587 parameter pack, at the end of the template
4590 error ("parameter pack %q+D must be at the end of the"
4591 " template parameter list", TREE_VALUE (parm));
4593 TREE_VALUE (TREE_VEC_ELT (inner_parms, i))
4601 if (((cxx_dialect == cxx98) && TREE_CODE (decl) != TYPE_DECL)
4605 /* For an ordinary class template, default template arguments are
4606 allowed at the innermost level, e.g.:
4607 template <class T = int>
4609 but, in a partial specialization, they're not allowed even
4610 there, as we have in [temp.class.spec]:
4612 The template parameter list of a specialization shall not
4613 contain default template argument values.
4615 So, for a partial specialization, or for a function template
4616 (in C++98/C++03), we look at all of them. */
4619 /* But, for a primary class template that is not a partial
4620 specialization we look at all template parameters except the
4622 parms = TREE_CHAIN (parms);
4624 /* Figure out what error message to issue. */
4625 if (is_friend_decl == 2)
4626 msg = G_("default template arguments may not be used in function template "
4627 "friend re-declaration");
4628 else if (is_friend_decl)
4629 msg = G_("default template arguments may not be used in function template "
4630 "friend declarations");
4631 else if (TREE_CODE (decl) == FUNCTION_DECL && (cxx_dialect == cxx98))
4632 msg = G_("default template arguments may not be used in function templates "
4633 "without -std=c++11 or -std=gnu++11");
4634 else if (is_partial)
4635 msg = G_("default template arguments may not be used in "
4636 "partial specializations");
4638 msg = G_("default argument for template parameter for class enclosing %qD");
4640 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
4641 /* If we're inside a class definition, there's no need to
4642 examine the parameters to the class itself. On the one
4643 hand, they will be checked when the class is defined, and,
4644 on the other, default arguments are valid in things like:
4645 template <class T = double>
4646 struct S { template <class U> void f(U); };
4647 Here the default argument for `S' has no bearing on the
4648 declaration of `f'. */
4649 last_level_to_check = template_class_depth (current_class_type) + 1;
4651 /* Check everything. */
4652 last_level_to_check = 0;
4654 for (parm_level = parms;
4655 parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
4656 parm_level = TREE_CHAIN (parm_level))
4658 tree inner_parms = TREE_VALUE (parm_level);
4662 ntparms = TREE_VEC_LENGTH (inner_parms);
4663 for (i = 0; i < ntparms; ++i)
4665 if (TREE_VEC_ELT (inner_parms, i) == error_mark_node)
4668 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
4673 if (is_friend_decl == 2)
4680 /* Clear out the default argument so that we are not
4682 TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
4686 /* At this point, if we're still interested in issuing messages,
4687 they must apply to classes surrounding the object declared. */
4689 msg = G_("default argument for template parameter for class "
4696 /* Worker for push_template_decl_real, called via
4697 for_each_template_parm. DATA is really an int, indicating the
4698 level of the parameters we are interested in. If T is a template
4699 parameter of that level, return nonzero. */
4702 template_parm_this_level_p (tree t, void* data)
4704 int this_level = *(int *)data;
4707 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
4708 level = TEMPLATE_PARM_LEVEL (t);
4710 level = TEMPLATE_TYPE_LEVEL (t);
4711 return level == this_level;
4714 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
4715 parameters given by current_template_args, or reuses a
4716 previously existing one, if appropriate. Returns the DECL, or an
4717 equivalent one, if it is replaced via a call to duplicate_decls.
4719 If IS_FRIEND is true, DECL is a friend declaration. */
4722 push_template_decl_real (tree decl, bool is_friend)
4730 int new_template_p = 0;
4731 /* True if the template is a member template, in the sense of
4733 bool member_template_p = false;
4735 if (decl == error_mark_node || !current_template_parms)
4736 return error_mark_node;
4738 /* See if this is a partial specialization. */
4739 is_partial = ((DECL_IMPLICIT_TYPEDEF_P (decl)
4740 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
4741 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
4742 || (TREE_CODE (decl) == VAR_DECL
4743 && DECL_LANG_SPECIFIC (decl)
4744 && DECL_TEMPLATE_SPECIALIZATION (decl)
4745 && TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl))));
4747 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl))
4751 /* For a friend, we want the context of the friend function, not
4752 the type of which it is a friend. */
4753 ctx = CP_DECL_CONTEXT (decl);
4754 else if (CP_DECL_CONTEXT (decl)
4755 && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4756 /* In the case of a virtual function, we want the class in which
4758 ctx = CP_DECL_CONTEXT (decl);
4760 /* Otherwise, if we're currently defining some class, the DECL
4761 is assumed to be a member of the class. */
4762 ctx = current_scope ();
4764 if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
4767 if (!DECL_CONTEXT (decl))
4768 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
4770 /* See if this is a primary template. */
4771 if (is_friend && ctx
4772 && uses_template_parms_level (ctx, processing_template_decl))
4773 /* A friend template that specifies a class context, i.e.
4774 template <typename T> friend void A<T>::f();
4777 else if (TREE_CODE (decl) == TYPE_DECL
4778 && LAMBDA_TYPE_P (TREE_TYPE (decl)))
4781 is_primary = template_parm_scope_p ();
4785 if (DECL_CLASS_SCOPE_P (decl))
4786 member_template_p = true;
4787 if (TREE_CODE (decl) == TYPE_DECL
4788 && ANON_AGGRNAME_P (DECL_NAME (decl)))
4790 error ("template class without a name");
4791 return error_mark_node;
4793 else if (TREE_CODE (decl) == FUNCTION_DECL)
4795 if (member_template_p)
4797 if (DECL_OVERRIDE_P (decl) || DECL_FINAL_P (decl))
4798 error ("member template %qD may not have virt-specifiers", decl);
4800 if (DECL_DESTRUCTOR_P (decl))
4804 A destructor shall not be a member template. */
4805 error ("destructor %qD declared as member template", decl);
4806 return error_mark_node;
4808 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl))
4809 && (!prototype_p (TREE_TYPE (decl))
4810 || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
4811 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
4812 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl))))
4813 == void_list_node)))
4815 /* [basic.stc.dynamic.allocation]
4817 An allocation function can be a function
4818 template. ... Template allocation functions shall
4819 have two or more parameters. */
4820 error ("invalid template declaration of %qD", decl);
4821 return error_mark_node;
4824 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
4825 && CLASS_TYPE_P (TREE_TYPE (decl)))
4827 else if (TREE_CODE (decl) == TYPE_DECL
4828 && TYPE_DECL_ALIAS_P (decl))
4829 /* alias-declaration */
4830 gcc_assert (!DECL_ARTIFICIAL (decl));
4831 else if (VAR_P (decl))
4832 /* C++14 variable template. */;
4835 error ("template declaration of %q#D", decl);
4836 return error_mark_node;
4840 /* Check to see that the rules regarding the use of default
4841 arguments are not being violated. */
4842 check_default_tmpl_args (decl, current_template_parms,
4843 is_primary, is_partial, /*is_friend_decl=*/0);
4845 /* Ensure that there are no parameter packs in the type of this
4846 declaration that have not been expanded. */
4847 if (TREE_CODE (decl) == FUNCTION_DECL)
4849 /* Check each of the arguments individually to see if there are
4850 any bare parameter packs. */
4851 tree type = TREE_TYPE (decl);
4852 tree arg = DECL_ARGUMENTS (decl);
4853 tree argtype = TYPE_ARG_TYPES (type);
4855 while (arg && argtype)
4857 if (!DECL_PACK_P (arg)
4858 && check_for_bare_parameter_packs (TREE_TYPE (arg)))
4860 /* This is a PARM_DECL that contains unexpanded parameter
4861 packs. We have already complained about this in the
4862 check_for_bare_parameter_packs call, so just replace
4863 these types with ERROR_MARK_NODE. */
4864 TREE_TYPE (arg) = error_mark_node;
4865 TREE_VALUE (argtype) = error_mark_node;
4868 arg = DECL_CHAIN (arg);
4869 argtype = TREE_CHAIN (argtype);
4872 /* Check for bare parameter packs in the return type and the
4873 exception specifiers. */
4874 if (check_for_bare_parameter_packs (TREE_TYPE (type)))
4875 /* Errors were already issued, set return type to int
4876 as the frontend doesn't expect error_mark_node as
4878 TREE_TYPE (type) = integer_type_node;
4879 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type)))
4880 TYPE_RAISES_EXCEPTIONS (type) = NULL_TREE;
4882 else if (check_for_bare_parameter_packs ((TREE_CODE (decl) == TYPE_DECL
4883 && TYPE_DECL_ALIAS_P (decl))
4884 ? DECL_ORIGINAL_TYPE (decl)
4885 : TREE_TYPE (decl)))
4887 TREE_TYPE (decl) = error_mark_node;
4888 return error_mark_node;
4892 return process_partial_specialization (decl);
4894 args = current_template_args ();
4897 || TREE_CODE (ctx) == FUNCTION_DECL
4898 || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
4899 || (TREE_CODE (decl) == TYPE_DECL
4900 && LAMBDA_TYPE_P (TREE_TYPE (decl)))
4901 || (is_friend && !DECL_TEMPLATE_INFO (decl)))
4903 if (DECL_LANG_SPECIFIC (decl)
4904 && DECL_TEMPLATE_INFO (decl)
4905 && DECL_TI_TEMPLATE (decl))
4906 tmpl = DECL_TI_TEMPLATE (decl);
4907 /* If DECL is a TYPE_DECL for a class-template, then there won't
4908 be DECL_LANG_SPECIFIC. The information equivalent to
4909 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
4910 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
4911 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
4912 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
4914 /* Since a template declaration already existed for this
4915 class-type, we must be redeclaring it here. Make sure
4916 that the redeclaration is valid. */
4917 redeclare_class_template (TREE_TYPE (decl),
4918 current_template_parms);
4919 /* We don't need to create a new TEMPLATE_DECL; just use the
4920 one we already had. */
4921 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
4925 tmpl = build_template_decl (decl, current_template_parms,
4929 if (DECL_LANG_SPECIFIC (decl)
4930 && DECL_TEMPLATE_SPECIALIZATION (decl))
4932 /* A specialization of a member template of a template
4934 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
4935 DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
4936 DECL_TEMPLATE_INFO (decl) = NULL_TREE;
4942 tree a, t, current, parms;
4944 tree tinfo = get_template_info (decl);
4948 error ("template definition of non-template %q#D", decl);
4949 return error_mark_node;
4952 tmpl = TI_TEMPLATE (tinfo);
4954 if (DECL_FUNCTION_TEMPLATE_P (tmpl)
4955 && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
4956 && DECL_TEMPLATE_SPECIALIZATION (decl)
4957 && DECL_MEMBER_TEMPLATE_P (tmpl))
4961 /* The declaration is a specialization of a member
4962 template, declared outside the class. Therefore, the
4963 innermost template arguments will be NULL, so we
4964 replace them with the arguments determined by the
4965 earlier call to check_explicit_specialization. */
4966 args = DECL_TI_ARGS (decl);
4969 = build_template_decl (decl, current_template_parms,
4971 DECL_TEMPLATE_RESULT (new_tmpl) = decl;
4972 TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
4973 DECL_TI_TEMPLATE (decl) = new_tmpl;
4974 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
4975 DECL_TEMPLATE_INFO (new_tmpl)
4976 = build_template_info (tmpl, args);
4978 register_specialization (new_tmpl,
4979 most_general_template (tmpl),
4985 /* Make sure the template headers we got make sense. */
4987 parms = DECL_TEMPLATE_PARMS (tmpl);
4988 i = TMPL_PARMS_DEPTH (parms);
4989 if (TMPL_ARGS_DEPTH (args) != i)
4991 error ("expected %d levels of template parms for %q#D, got %d",
4992 i, decl, TMPL_ARGS_DEPTH (args));
4993 DECL_INTERFACE_KNOWN (decl) = 1;
4994 return error_mark_node;
4997 for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
4999 a = TMPL_ARGS_LEVEL (args, i);
5000 t = INNERMOST_TEMPLATE_PARMS (parms);
5002 if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
5004 if (current == decl)
5005 error ("got %d template parameters for %q#D",
5006 TREE_VEC_LENGTH (a), decl);
5008 error ("got %d template parameters for %q#T",
5009 TREE_VEC_LENGTH (a), current);
5010 error (" but %d required", TREE_VEC_LENGTH (t));
5011 /* Avoid crash in import_export_decl. */
5012 DECL_INTERFACE_KNOWN (decl) = 1;
5013 return error_mark_node;
5016 if (current == decl)
5018 else if (current == NULL_TREE)
5019 /* Can happen in erroneous input. */
5022 current = get_containing_scope (current);
5025 /* Check that the parms are used in the appropriate qualifying scopes
5026 in the declarator. */
5027 if (!comp_template_args
5029 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl)))))
5032 template arguments to %qD do not match original template %qD",
5033 decl, DECL_TEMPLATE_RESULT (tmpl));
5034 if (!uses_template_parms (TI_ARGS (tinfo)))
5035 inform (input_location, "use template<> for an explicit specialization");
5036 /* Avoid crash in import_export_decl. */
5037 DECL_INTERFACE_KNOWN (decl) = 1;
5038 return error_mark_node;
5042 DECL_TEMPLATE_RESULT (tmpl) = decl;
5043 TREE_TYPE (tmpl) = TREE_TYPE (decl);
5045 /* Push template declarations for global functions and types. Note
5046 that we do not try to push a global template friend declared in a
5047 template class; such a thing may well depend on the template
5048 parameters of the class. */
5049 if (new_template_p && !ctx
5050 && !(is_friend && template_class_depth (current_class_type) > 0))
5052 tmpl = pushdecl_namespace_level (tmpl, is_friend);
5053 if (tmpl == error_mark_node)
5054 return error_mark_node;
5056 /* Hide template friend classes that haven't been declared yet. */
5057 if (is_friend && TREE_CODE (decl) == TYPE_DECL)
5059 DECL_ANTICIPATED (tmpl) = 1;
5060 DECL_FRIEND_P (tmpl) = 1;
5066 tree parms = DECL_TEMPLATE_PARMS (tmpl);
5069 DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
5070 if (DECL_CONV_FN_P (tmpl))
5072 int depth = TMPL_PARMS_DEPTH (parms);
5074 /* It is a conversion operator. See if the type converted to
5075 depends on innermost template operands. */
5077 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl)),
5079 DECL_TEMPLATE_CONV_FN_P (tmpl) = 1;
5082 /* Give template template parms a DECL_CONTEXT of the template
5083 for which they are a parameter. */
5084 parms = INNERMOST_TEMPLATE_PARMS (parms);
5085 for (i = TREE_VEC_LENGTH (parms) - 1; i >= 0; --i)
5087 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
5088 if (TREE_CODE (parm) == TEMPLATE_DECL)
5089 DECL_CONTEXT (parm) = tmpl;
5093 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5094 back to its most general template. If TMPL is a specialization,
5095 ARGS may only have the innermost set of arguments. Add the missing
5096 argument levels if necessary. */
5097 if (DECL_TEMPLATE_INFO (tmpl))
5098 args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);
5100 info = build_template_info (tmpl, args);
5102 if (DECL_IMPLICIT_TYPEDEF_P (decl))
5103 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
5106 if (is_primary && !DECL_LANG_SPECIFIC (decl))
5107 retrofit_lang_decl (decl);
5108 if (DECL_LANG_SPECIFIC (decl))
5109 DECL_TEMPLATE_INFO (decl) = info;
5112 if (flag_implicit_templates
5114 && TREE_PUBLIC (decl)
5115 && VAR_OR_FUNCTION_DECL_P (decl))
5116 /* Set DECL_COMDAT on template instantiations; if we force
5117 them to be emitted by explicit instantiation or -frepo,
5118 mark_needed will tell cgraph to do the right thing. */
5119 DECL_COMDAT (decl) = true;
5121 return DECL_TEMPLATE_RESULT (tmpl);
5125 push_template_decl (tree decl)
5127 return push_template_decl_real (decl, false);
5130 /* FN is an inheriting constructor that inherits from the constructor
5131 template INHERITED; turn FN into a constructor template with a matching
5135 add_inherited_template_parms (tree fn, tree inherited)
5138 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited));
5139 inner_parms = copy_node (inner_parms);
5141 = tree_cons (size_int (processing_template_decl + 1),
5142 inner_parms, current_template_parms);
5143 tree tmpl = build_template_decl (fn, parms, /*member*/true);
5144 tree args = template_parms_to_args (parms);
5145 DECL_TEMPLATE_INFO (fn) = build_template_info (tmpl, args);
5146 TREE_TYPE (tmpl) = TREE_TYPE (fn);
5147 DECL_TEMPLATE_RESULT (tmpl) = fn;
5148 DECL_ARTIFICIAL (tmpl) = true;
5149 DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
5153 /* Called when a class template TYPE is redeclared with the indicated
5154 template PARMS, e.g.:
5156 template <class T> struct S;
5157 template <class T> struct S {}; */
5160 redeclare_class_template (tree type, tree parms)
5166 if (!TYPE_TEMPLATE_INFO (type))
5168 error ("%qT is not a template type", type);
5172 tmpl = TYPE_TI_TEMPLATE (type);
5173 if (!PRIMARY_TEMPLATE_P (tmpl))
5174 /* The type is nested in some template class. Nothing to worry
5175 about here; there are no new template parameters for the nested
5181 error ("template specifiers not specified in declaration of %qD",
5186 parms = INNERMOST_TEMPLATE_PARMS (parms);
5187 tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
5189 if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
5191 error_n (input_location, TREE_VEC_LENGTH (parms),
5192 "redeclared with %d template parameter",
5193 "redeclared with %d template parameters",
5194 TREE_VEC_LENGTH (parms));
5195 inform_n (input_location, TREE_VEC_LENGTH (tmpl_parms),
5196 "previous declaration %q+D used %d template parameter",
5197 "previous declaration %q+D used %d template parameters",
5198 tmpl, TREE_VEC_LENGTH (tmpl_parms));
5202 for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
5209 if (TREE_VEC_ELT (tmpl_parms, i) == error_mark_node
5210 || TREE_VEC_ELT (parms, i) == error_mark_node)
5213 tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
5214 if (error_operand_p (tmpl_parm))
5217 parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
5218 tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i));
5219 parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
5221 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5223 if (TREE_CODE (tmpl_parm) != TREE_CODE (parm)
5224 || (TREE_CODE (tmpl_parm) != TYPE_DECL
5225 && !same_type_p (TREE_TYPE (tmpl_parm), TREE_TYPE (parm)))
5226 || (TREE_CODE (tmpl_parm) != PARM_DECL
5227 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm))
5228 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm))))
5229 || (TREE_CODE (tmpl_parm) == PARM_DECL
5230 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm))
5231 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))))
5233 error ("template parameter %q+#D", tmpl_parm);
5234 error ("redeclared here as %q#D", parm);
5238 if (tmpl_default != NULL_TREE && parm_default != NULL_TREE)
5240 /* We have in [temp.param]:
5242 A template-parameter may not be given default arguments
5243 by two different declarations in the same scope. */
5244 error_at (input_location, "redefinition of default argument for %q#D", parm);
5245 inform (DECL_SOURCE_LOCATION (tmpl_parm),
5246 "original definition appeared here");
5250 if (parm_default != NULL_TREE)
5251 /* Update the previous template parameters (which are the ones
5252 that will really count) with the new default value. */
5253 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default;
5254 else if (tmpl_default != NULL_TREE)
5255 /* Update the new parameters, too; they'll be used as the
5256 parameters for any members. */
5257 TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default;
5263 /* The actual substitution part of instantiate_non_dependent_expr_sfinae,
5264 to be used when the caller has already checked
5265 (processing_template_decl
5266 && !instantiation_dependent_expression_p (expr)
5267 && potential_constant_expression (expr))
5268 and cleared processing_template_decl. */
5271 instantiate_non_dependent_expr_internal (tree expr, tsubst_flags_t complain)
5273 return tsubst_copy_and_build (expr,
5276 /*in_decl=*/NULL_TREE,
5277 /*function_p=*/false,
5278 /*integral_constant_expression_p=*/true);
5281 /* Simplify EXPR if it is a non-dependent expression. Returns the
5282 (possibly simplified) expression. */
5285 instantiate_non_dependent_expr_sfinae (tree expr, tsubst_flags_t complain)
5287 if (expr == NULL_TREE)
5290 /* If we're in a template, but EXPR isn't value dependent, simplify
5291 it. We're supposed to treat:
5293 template <typename T> void f(T[1 + 1]);
5294 template <typename T> void f(T[2]);
5296 as two declarations of the same function, for example. */
5297 if (processing_template_decl
5298 && !instantiation_dependent_expression_p (expr)
5299 && potential_constant_expression (expr))
5301 processing_template_decl_sentinel s;
5302 expr = instantiate_non_dependent_expr_internal (expr, complain);
5308 instantiate_non_dependent_expr (tree expr)
5310 return instantiate_non_dependent_expr_sfinae (expr, tf_error);
5313 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
5314 template declaration, or a TYPE_DECL for an alias declaration. */
5317 alias_type_or_template_p (tree t)
5321 return ((TREE_CODE (t) == TYPE_DECL && TYPE_DECL_ALIAS_P (t))
5324 && TYPE_DECL_ALIAS_P (TYPE_NAME (t)))
5325 || DECL_ALIAS_TEMPLATE_P (t));
5328 /* Return TRUE iff T is a specialization of an alias template. */
5331 alias_template_specialization_p (const_tree t)
5333 /* It's an alias template specialization if it's an alias and its
5334 TYPE_NAME is a specialization of a primary template. */
5335 if (TYPE_ALIAS_P (t))
5337 tree name = TYPE_NAME (t);
5338 if (DECL_LANG_SPECIFIC (name))
5339 if (tree ti = DECL_TEMPLATE_INFO (name))
5341 tree tmpl = TI_TEMPLATE (ti);
5342 return PRIMARY_TEMPLATE_P (tmpl);
5348 /* Return TRUE iff T is a specialization of an alias template with
5349 dependent template-arguments. */
5352 dependent_alias_template_spec_p (const_tree t)
5354 return (alias_template_specialization_p (t)
5355 && (any_dependent_template_arguments_p
5356 (INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (t)))));
5359 /* Return the number of innermost template parameters in TMPL. */
5362 num_innermost_template_parms (tree tmpl)
5364 tree parms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl));
5365 return TREE_VEC_LENGTH (parms);
5368 /* Return either TMPL or another template that it is equivalent to under DR
5369 1286: An alias that just changes the name of a template is equivalent to
5370 the other template. */
5373 get_underlying_template (tree tmpl)
5375 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
5376 while (DECL_ALIAS_TEMPLATE_P (tmpl))
5378 tree result = DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl));
5379 if (TYPE_TEMPLATE_INFO (result))
5381 tree sub = TYPE_TI_TEMPLATE (result);
5382 if (PRIMARY_TEMPLATE_P (sub)
5383 && (num_innermost_template_parms (tmpl)
5384 == num_innermost_template_parms (sub)))
5386 tree alias_args = INNERMOST_TEMPLATE_ARGS
5387 (template_parms_to_args (DECL_TEMPLATE_PARMS (tmpl)));
5388 if (!comp_template_args (TYPE_TI_ARGS (result), alias_args))
5390 /* The alias type is equivalent to the pattern of the
5391 underlying template, so strip the alias. */
5401 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
5402 must be a function or a pointer-to-function type, as specified
5403 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
5404 and check that the resulting function has external linkage. */
5407 convert_nontype_argument_function (tree type, tree expr,
5408 tsubst_flags_t complain)
5412 linkage_kind linkage;
5414 fn = instantiate_type (type, fns, tf_none);
5415 if (fn == error_mark_node)
5416 return error_mark_node;
5419 if (TREE_CODE (fn_no_ptr) == ADDR_EXPR)
5420 fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0);
5421 if (BASELINK_P (fn_no_ptr))
5422 fn_no_ptr = BASELINK_FUNCTIONS (fn_no_ptr);
5424 /* [temp.arg.nontype]/1
5426 A template-argument for a non-type, non-template template-parameter
5429 -- the address of an object or function with external [C++11: or
5430 internal] linkage. */
5432 if (TREE_CODE (fn_no_ptr) != FUNCTION_DECL)
5434 if (complain & tf_error)
5436 error ("%qE is not a valid template argument for type %qT",
5438 if (TYPE_PTR_P (type))
5439 error ("it must be the address of a function with "
5440 "external linkage");
5442 error ("it must be the name of a function with "
5443 "external linkage");
5448 linkage = decl_linkage (fn_no_ptr);
5449 if (cxx_dialect >= cxx11 ? linkage == lk_none : linkage != lk_external)
5451 if (complain & tf_error)
5453 if (cxx_dialect >= cxx11)
5454 error ("%qE is not a valid template argument for type %qT "
5455 "because %qD has no linkage",
5456 expr, type, fn_no_ptr);
5458 error ("%qE is not a valid template argument for type %qT "
5459 "because %qD does not have external linkage",
5460 expr, type, fn_no_ptr);
5468 /* Subroutine of convert_nontype_argument.
5469 Check if EXPR of type TYPE is a valid pointer-to-member constant.
5470 Emit an error otherwise. */
5473 check_valid_ptrmem_cst_expr (tree type, tree expr,
5474 tsubst_flags_t complain)
5477 if (expr && (null_ptr_cst_p (expr) || TREE_CODE (expr) == PTRMEM_CST))
5479 if (cxx_dialect >= cxx11 && null_member_pointer_value_p (expr))
5481 if (processing_template_decl
5482 && TREE_CODE (expr) == ADDR_EXPR
5483 && TREE_CODE (TREE_OPERAND (expr, 0)) == OFFSET_REF)
5485 if (complain & tf_error)
5487 error ("%qE is not a valid template argument for type %qT",
5489 error ("it must be a pointer-to-member of the form %<&X::Y%>");
5494 /* Returns TRUE iff the address of OP is value-dependent.
5496 14.6.2.4 [temp.dep.temp]:
5497 A non-integral non-type template-argument is dependent if its type is
5498 dependent or it has either of the following forms
5501 and contains a nested-name-specifier which specifies a class-name that
5502 names a dependent type.
5504 We generalize this to just say that the address of a member of a
5505 dependent class is value-dependent; the above doesn't cover the
5506 address of a static data member named with an unqualified-id. */
5509 has_value_dependent_address (tree op)
5511 /* We could use get_inner_reference here, but there's no need;
5512 this is only relevant for template non-type arguments, which
5513 can only be expressed as &id-expression. */
5516 tree ctx = CP_DECL_CONTEXT (op);
5517 if (TYPE_P (ctx) && dependent_type_p (ctx))
5524 /* The next set of functions are used for providing helpful explanatory
5525 diagnostics for failed overload resolution. Their messages should be
5526 indented by two spaces for consistency with the messages in
5530 unify_success (bool /*explain_p*/)
5536 unify_parameter_deduction_failure (bool explain_p, tree parm)
5539 inform (input_location,
5540 " couldn't deduce template parameter %qD", parm);
5545 unify_invalid (bool /*explain_p*/)
5551 unify_cv_qual_mismatch (bool explain_p, tree parm, tree arg)
5554 inform (input_location,
5555 " types %qT and %qT have incompatible cv-qualifiers",
5561 unify_type_mismatch (bool explain_p, tree parm, tree arg)
5564 inform (input_location, " mismatched types %qT and %qT", parm, arg);
5569 unify_parameter_pack_mismatch (bool explain_p, tree parm, tree arg)
5572 inform (input_location,
5573 " template parameter %qD is not a parameter pack, but "
5580 unify_ptrmem_cst_mismatch (bool explain_p, tree parm, tree arg)
5583 inform (input_location,
5584 " template argument %qE does not match "
5585 "pointer-to-member constant %qE",
5591 unify_expression_unequal (bool explain_p, tree parm, tree arg)
5594 inform (input_location, " %qE is not equivalent to %qE", parm, arg);
5599 unify_parameter_pack_inconsistent (bool explain_p, tree old_arg, tree new_arg)
5602 inform (input_location,
5603 " inconsistent parameter pack deduction with %qT and %qT",
5609 unify_inconsistency (bool explain_p, tree parm, tree first, tree second)
5614 inform (input_location,
5615 " deduced conflicting types for parameter %qT (%qT and %qT)",
5616 parm, first, second);
5618 inform (input_location,
5619 " deduced conflicting values for non-type parameter "
5620 "%qE (%qE and %qE)", parm, first, second);
5626 unify_vla_arg (bool explain_p, tree arg)
5629 inform (input_location,
5630 " variable-sized array type %qT is not "
5631 "a valid template argument",
5637 unify_method_type_error (bool explain_p, tree arg)
5640 inform (input_location,
5641 " member function type %qT is not a valid template argument",
5647 unify_arity (bool explain_p, int have, int wanted, bool least_p = false)
5652 inform_n (input_location, wanted,
5653 " candidate expects at least %d argument, %d provided",
5654 " candidate expects at least %d arguments, %d provided",
5657 inform_n (input_location, wanted,
5658 " candidate expects %d argument, %d provided",
5659 " candidate expects %d arguments, %d provided",
5666 unify_too_many_arguments (bool explain_p, int have, int wanted)
5668 return unify_arity (explain_p, have, wanted);
5672 unify_too_few_arguments (bool explain_p, int have, int wanted,
5673 bool least_p = false)
5675 return unify_arity (explain_p, have, wanted, least_p);
5679 unify_arg_conversion (bool explain_p, tree to_type,
5680 tree from_type, tree arg)
5683 inform (EXPR_LOC_OR_LOC (arg, input_location),
5684 " cannot convert %qE (type %qT) to type %qT",
5685 arg, from_type, to_type);
5690 unify_no_common_base (bool explain_p, enum template_base_result r,
5691 tree parm, tree arg)
5696 case tbr_ambiguous_baseclass:
5697 inform (input_location, " %qT is an ambiguous base class of %qT",
5701 inform (input_location, " %qT is not derived from %qT", arg, parm);
5708 unify_inconsistent_template_template_parameters (bool explain_p)
5711 inform (input_location,
5712 " template parameters of a template template argument are "
5713 "inconsistent with other deduced template arguments");
5718 unify_template_deduction_failure (bool explain_p, tree parm, tree arg)
5721 inform (input_location,
5722 " can't deduce a template for %qT from non-template type %qT",
5728 unify_template_argument_mismatch (bool explain_p, tree parm, tree arg)
5731 inform (input_location,
5732 " template argument %qE does not match %qD", arg, parm);
5737 unify_overload_resolution_failure (bool explain_p, tree arg)
5740 inform (input_location,
5741 " could not resolve address from overloaded function %qE",
5746 /* Attempt to convert the non-type template parameter EXPR to the
5747 indicated TYPE. If the conversion is successful, return the
5748 converted value. If the conversion is unsuccessful, return
5749 NULL_TREE if we issued an error message, or error_mark_node if we
5750 did not. We issue error messages for out-and-out bad template
5751 parameters, but not simply because the conversion failed, since we
5752 might be just trying to do argument deduction. Both TYPE and EXPR
5753 must be non-dependent.
5755 The conversion follows the special rules described in
5756 [temp.arg.nontype], and it is much more strict than an implicit
5759 This function is called twice for each template argument (see
5760 lookup_template_class for a more accurate description of this
5761 problem). This means that we need to handle expressions which
5762 are not valid in a C++ source, but can be created from the
5763 first call (for instance, casts to perform conversions). These
5764 hacks can go away after we fix the double coercion problem. */
5767 convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain)
5771 /* Detect immediately string literals as invalid non-type argument.
5772 This special-case is not needed for correctness (we would easily
5773 catch this later), but only to provide better diagnostic for this
5774 common user mistake. As suggested by DR 100, we do not mention
5775 linkage issues in the diagnostic as this is not the point. */
5776 /* FIXME we're making this OK. */
5777 if (TREE_CODE (expr) == STRING_CST)
5779 if (complain & tf_error)
5780 error ("%qE is not a valid template argument for type %qT "
5781 "because string literals can never be used in this context",
5786 /* Add the ADDR_EXPR now for the benefit of
5787 value_dependent_expression_p. */
5788 if (TYPE_PTROBV_P (type)
5789 && TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE)
5791 expr = decay_conversion (expr, complain);
5792 if (expr == error_mark_node)
5793 return error_mark_node;
5796 /* If we are in a template, EXPR may be non-dependent, but still
5797 have a syntactic, rather than semantic, form. For example, EXPR
5798 might be a SCOPE_REF, rather than the VAR_DECL to which the
5799 SCOPE_REF refers. Preserving the qualifying scope is necessary
5800 so that access checking can be performed when the template is
5801 instantiated -- but here we need the resolved form so that we can
5802 convert the argument. */
5803 bool non_dep = false;
5804 if (TYPE_REF_OBJ_P (type)
5805 && has_value_dependent_address (expr))
5806 /* If we want the address and it's value-dependent, don't fold. */;
5807 else if (!type_unknown_p (expr)
5808 && processing_template_decl
5809 && !instantiation_dependent_expression_p (expr)
5810 && potential_constant_expression (expr))
5812 if (error_operand_p (expr))
5813 return error_mark_node;
5814 expr_type = TREE_TYPE (expr);
5815 if (TREE_CODE (type) == REFERENCE_TYPE)
5816 expr = mark_lvalue_use (expr);
5818 expr = mark_rvalue_use (expr);
5820 /* If the argument is non-dependent, perform any conversions in
5821 non-dependent context as well. */
5822 processing_template_decl_sentinel s (non_dep);
5824 expr = instantiate_non_dependent_expr_internal (expr, complain);
5826 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
5827 to a non-type argument of "nullptr". */
5828 if (expr == nullptr_node && TYPE_PTR_OR_PTRMEM_P (type))
5829 expr = convert (type, expr);
5831 /* In C++11, integral or enumeration non-type template arguments can be
5832 arbitrary constant expressions. Pointer and pointer to
5833 member arguments can be general constant expressions that evaluate
5834 to a null value, but otherwise still need to be of a specific form. */
5835 if (cxx_dialect >= cxx11)
5837 if (TREE_CODE (expr) == PTRMEM_CST)
5838 /* A PTRMEM_CST is already constant, and a valid template
5839 argument for a parameter of pointer to member type, we just want
5840 to leave it in that form rather than lower it to a
5842 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type))
5843 expr = maybe_constant_value (expr);
5844 else if (TYPE_PTR_OR_PTRMEM_P (type))
5846 tree folded = maybe_constant_value (expr);
5847 if (TYPE_PTR_P (type) ? integer_zerop (folded)
5848 : null_member_pointer_value_p (folded))
5853 /* HACK: Due to double coercion, we can get a
5854 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
5855 which is the tree that we built on the first call (see
5856 below when coercing to reference to object or to reference to
5857 function). We just strip everything and get to the arg.
5858 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
5860 if (TYPE_REF_OBJ_P (type) || TYPE_REFFN_P (type))
5862 tree probe_type, probe = expr;
5863 if (REFERENCE_REF_P (probe))
5864 probe = TREE_OPERAND (probe, 0);
5865 probe_type = TREE_TYPE (probe);
5866 if (TREE_CODE (probe) == NOP_EXPR)
5868 /* ??? Maybe we could use convert_from_reference here, but we
5869 would need to relax its constraints because the NOP_EXPR
5870 could actually change the type to something more cv-qualified,
5871 and this is not folded by convert_from_reference. */
5872 tree addr = TREE_OPERAND (probe, 0);
5873 if (TREE_CODE (probe_type) == REFERENCE_TYPE
5874 && TREE_CODE (addr) == ADDR_EXPR
5875 && TYPE_PTR_P (TREE_TYPE (addr))
5876 && (same_type_ignoring_top_level_qualifiers_p
5877 (TREE_TYPE (probe_type),
5878 TREE_TYPE (TREE_TYPE (addr)))))
5880 expr = TREE_OPERAND (addr, 0);
5881 expr_type = TREE_TYPE (probe_type);
5886 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
5887 parameter is a pointer to object, through decay and
5888 qualification conversion. Let's strip everything. */
5889 else if (TREE_CODE (expr) == NOP_EXPR && TYPE_PTROBV_P (type))
5893 if (TREE_CODE (probe) == ADDR_EXPR
5894 && TYPE_PTR_P (TREE_TYPE (probe)))
5896 /* Skip the ADDR_EXPR only if it is part of the decay for
5897 an array. Otherwise, it is part of the original argument
5898 in the source code. */
5899 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (probe, 0))) == ARRAY_TYPE)
5900 probe = TREE_OPERAND (probe, 0);
5902 expr_type = TREE_TYPE (expr);
5906 /* [temp.arg.nontype]/5, bullet 1
5908 For a non-type template-parameter of integral or enumeration type,
5909 integral promotions (_conv.prom_) and integral conversions
5910 (_conv.integral_) are applied. */
5911 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type))
5913 tree t = build_integral_nontype_arg_conv (type, expr, complain);
5914 t = maybe_constant_value (t);
5915 if (t != error_mark_node)
5918 if (!same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (expr)))
5919 return error_mark_node;
5921 /* Notice that there are constant expressions like '4 % 0' which
5922 do not fold into integer constants. */
5923 if (TREE_CODE (expr) != INTEGER_CST)
5925 if (complain & tf_error)
5927 int errs = errorcount, warns = warningcount + werrorcount;
5928 if (processing_template_decl
5929 && !require_potential_constant_expression (expr))
5931 expr = cxx_constant_value (expr);
5932 if (errorcount > errs || warningcount + werrorcount > warns)
5933 inform (EXPR_LOC_OR_LOC (expr, input_location),
5934 "in template argument for type %qT ", type);
5935 if (expr == error_mark_node)
5937 /* else cxx_constant_value complained but gave us
5938 a real constant, so go ahead. */
5939 gcc_assert (TREE_CODE (expr) == INTEGER_CST);
5945 /* Avoid typedef problems. */
5946 if (TREE_TYPE (expr) != type)
5947 expr = fold_convert (type, expr);
5949 /* [temp.arg.nontype]/5, bullet 2
5951 For a non-type template-parameter of type pointer to object,
5952 qualification conversions (_conv.qual_) and the array-to-pointer
5953 conversion (_conv.array_) are applied. */
5954 else if (TYPE_PTROBV_P (type))
5956 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
5958 A template-argument for a non-type, non-template template-parameter
5959 shall be one of: [...]
5961 -- the name of a non-type template-parameter;
5962 -- the address of an object or function with external linkage, [...]
5963 expressed as "& id-expression" where the & is optional if the name
5964 refers to a function or array, or if the corresponding
5965 template-parameter is a reference.
5967 Here, we do not care about functions, as they are invalid anyway
5968 for a parameter of type pointer-to-object. */
5970 if (DECL_P (expr) && DECL_TEMPLATE_PARM_P (expr))
5971 /* Non-type template parameters are OK. */
5973 else if (cxx_dialect >= cxx11 && integer_zerop (expr))
5974 /* Null pointer values are OK in C++11. */;
5975 else if (TREE_CODE (expr) != ADDR_EXPR
5976 && TREE_CODE (expr_type) != ARRAY_TYPE)
5980 if (complain & tf_error)
5981 error ("%qD is not a valid template argument "
5982 "because %qD is a variable, not the address of "
5983 "a variable", expr, expr);
5986 if (POINTER_TYPE_P (expr_type))
5988 if (complain & tf_error)
5989 error ("%qE is not a valid template argument for %qT "
5990 "because it is not the address of a variable",
5994 /* Other values, like integer constants, might be valid
5995 non-type arguments of some other type. */
5996 return error_mark_node;
6002 decl = ((TREE_CODE (expr) == ADDR_EXPR)
6003 ? TREE_OPERAND (expr, 0) : expr);
6006 if (complain & tf_error)
6007 error ("%qE is not a valid template argument of type %qT "
6008 "because %qE is not a variable", expr, type, decl);
6011 else if (cxx_dialect < cxx11 && !DECL_EXTERNAL_LINKAGE_P (decl))
6013 if (complain & tf_error)
6014 error ("%qE is not a valid template argument of type %qT "
6015 "because %qD does not have external linkage",
6019 else if (cxx_dialect >= cxx11 && decl_linkage (decl) == lk_none)
6021 if (complain & tf_error)
6022 error ("%qE is not a valid template argument of type %qT "
6023 "because %qD has no linkage", expr, type, decl);
6028 expr = decay_conversion (expr, complain);
6029 if (expr == error_mark_node)
6030 return error_mark_node;
6032 expr = perform_qualification_conversions (type, expr);
6033 if (expr == error_mark_node)
6034 return error_mark_node;
6036 /* [temp.arg.nontype]/5, bullet 3
6038 For a non-type template-parameter of type reference to object, no
6039 conversions apply. The type referred to by the reference may be more
6040 cv-qualified than the (otherwise identical) type of the
6041 template-argument. The template-parameter is bound directly to the
6042 template-argument, which must be an lvalue. */
6043 else if (TYPE_REF_OBJ_P (type))
6045 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type),
6047 return error_mark_node;
6049 if (!at_least_as_qualified_p (TREE_TYPE (type), expr_type))
6051 if (complain & tf_error)
6052 error ("%qE is not a valid template argument for type %qT "
6053 "because of conflicts in cv-qualification", expr, type);
6057 if (!real_lvalue_p (expr))
6059 if (complain & tf_error)
6060 error ("%qE is not a valid template argument for type %qT "
6061 "because it is not an lvalue", expr, type);
6065 /* [temp.arg.nontype]/1
6067 A template-argument for a non-type, non-template template-parameter
6068 shall be one of: [...]
6070 -- the address of an object or function with external linkage. */
6071 if (INDIRECT_REF_P (expr)
6072 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr, 0))))
6074 expr = TREE_OPERAND (expr, 0);
6077 if (complain & tf_error)
6078 error ("%q#D is not a valid template argument for type %qT "
6079 "because a reference variable does not have a constant "
6080 "address", expr, type);
6087 if (complain & tf_error)
6088 error ("%qE is not a valid template argument for type %qT "
6089 "because it is not an object with external linkage",
6094 if (!DECL_EXTERNAL_LINKAGE_P (expr))
6096 if (complain & tf_error)
6097 error ("%qE is not a valid template argument for type %qT "
6098 "because object %qD has not external linkage",
6103 expr = build_nop (type, build_address (expr));
6105 /* [temp.arg.nontype]/5, bullet 4
6107 For a non-type template-parameter of type pointer to function, only
6108 the function-to-pointer conversion (_conv.func_) is applied. If the
6109 template-argument represents a set of overloaded functions (or a
6110 pointer to such), the matching function is selected from the set
6112 else if (TYPE_PTRFN_P (type))
6114 /* If the argument is a template-id, we might not have enough
6115 context information to decay the pointer. */
6116 if (!type_unknown_p (expr_type))
6118 expr = decay_conversion (expr, complain);
6119 if (expr == error_mark_node)
6120 return error_mark_node;
6123 if (cxx_dialect >= cxx11 && integer_zerop (expr))
6124 /* Null pointer values are OK in C++11. */
6125 return perform_qualification_conversions (type, expr);
6127 expr = convert_nontype_argument_function (type, expr, complain);
6128 if (!expr || expr == error_mark_node)
6131 /* [temp.arg.nontype]/5, bullet 5
6133 For a non-type template-parameter of type reference to function, no
6134 conversions apply. If the template-argument represents a set of
6135 overloaded functions, the matching function is selected from the set
6137 else if (TYPE_REFFN_P (type))
6139 if (TREE_CODE (expr) == ADDR_EXPR)
6141 if (complain & tf_error)
6143 error ("%qE is not a valid template argument for type %qT "
6144 "because it is a pointer", expr, type);
6145 inform (input_location, "try using %qE instead",
6146 TREE_OPERAND (expr, 0));
6151 expr = convert_nontype_argument_function (type, expr, complain);
6152 if (!expr || expr == error_mark_node)
6155 expr = build_nop (type, build_address (expr));
6157 /* [temp.arg.nontype]/5, bullet 6
6159 For a non-type template-parameter of type pointer to member function,
6160 no conversions apply. If the template-argument represents a set of
6161 overloaded member functions, the matching member function is selected
6162 from the set (_over.over_). */
6163 else if (TYPE_PTRMEMFUNC_P (type))
6165 expr = instantiate_type (type, expr, tf_none);
6166 if (expr == error_mark_node)
6167 return error_mark_node;
6169 /* [temp.arg.nontype] bullet 1 says the pointer to member
6170 expression must be a pointer-to-member constant. */
6171 if (!check_valid_ptrmem_cst_expr (type, expr, complain))
6172 return error_mark_node;
6174 /* There is no way to disable standard conversions in
6175 resolve_address_of_overloaded_function (called by
6176 instantiate_type). It is possible that the call succeeded by
6177 converting &B::I to &D::I (where B is a base of D), so we need
6178 to reject this conversion here.
6180 Actually, even if there was a way to disable standard conversions,
6181 it would still be better to reject them here so that we can
6182 provide a superior diagnostic. */
6183 if (!same_type_p (TREE_TYPE (expr), type))
6185 if (complain & tf_error)
6187 error ("%qE is not a valid template argument for type %qT "
6188 "because it is of type %qT", expr, type,
6190 /* If we are just one standard conversion off, explain. */
6191 if (can_convert_standard (type, TREE_TYPE (expr), complain))
6192 inform (input_location,
6193 "standard conversions are not allowed in this context");
6198 /* [temp.arg.nontype]/5, bullet 7
6200 For a non-type template-parameter of type pointer to data member,
6201 qualification conversions (_conv.qual_) are applied. */
6202 else if (TYPE_PTRDATAMEM_P (type))
6204 /* [temp.arg.nontype] bullet 1 says the pointer to member
6205 expression must be a pointer-to-member constant. */
6206 if (!check_valid_ptrmem_cst_expr (type, expr, complain))
6207 return error_mark_node;
6209 expr = perform_qualification_conversions (type, expr);
6210 if (expr == error_mark_node)
6213 else if (NULLPTR_TYPE_P (type))
6215 if (expr != nullptr_node)
6217 if (complain & tf_error)
6218 error ("%qE is not a valid template argument for type %qT "
6219 "because it is of type %qT", expr, type, TREE_TYPE (expr));
6224 /* A template non-type parameter must be one of the above. */
6228 /* Sanity check: did we actually convert the argument to the
6230 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6231 (type, TREE_TYPE (expr)));
6232 return convert_from_reference (expr);
6235 /* Subroutine of coerce_template_template_parms, which returns 1 if
6236 PARM_PARM and ARG_PARM match using the rule for the template
6237 parameters of template template parameters. Both PARM and ARG are
6238 template parameters; the rest of the arguments are the same as for
6239 coerce_template_template_parms.
6242 coerce_template_template_parm (tree parm,
6244 tsubst_flags_t complain,
6248 if (arg == NULL_TREE || error_operand_p (arg)
6249 || parm == NULL_TREE || error_operand_p (parm))
6252 if (TREE_CODE (arg) != TREE_CODE (parm))
6255 switch (TREE_CODE (parm))
6258 /* We encounter instantiations of templates like
6259 template <template <template <class> class> class TT>
6262 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
6263 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
6265 if (!coerce_template_template_parms
6266 (parmparm, argparm, complain, in_decl, outer_args))
6272 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg))
6273 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm)))
6274 /* Argument is a parameter pack but parameter is not. */
6279 /* The tsubst call is used to handle cases such as
6281 template <int> class C {};
6282 template <class T, template <T> class TT> class D {};
6285 i.e. the parameter list of TT depends on earlier parameters. */
6286 if (!uses_template_parms (TREE_TYPE (arg))
6288 (tsubst (TREE_TYPE (parm), outer_args, complain, in_decl),
6292 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg))
6293 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))
6294 /* Argument is a parameter pack but parameter is not. */
6307 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
6308 template template parameters. Both PARM_PARMS and ARG_PARMS are
6309 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
6312 Consider the example:
6313 template <class T> class A;
6314 template<template <class U> class TT> class B;
6316 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
6317 the parameters to A, and OUTER_ARGS contains A. */
6320 coerce_template_template_parms (tree parm_parms,
6322 tsubst_flags_t complain,
6326 int nparms, nargs, i;
6330 gcc_assert (TREE_CODE (parm_parms) == TREE_VEC);
6331 gcc_assert (TREE_CODE (arg_parms) == TREE_VEC);
6333 nparms = TREE_VEC_LENGTH (parm_parms);
6334 nargs = TREE_VEC_LENGTH (arg_parms);
6336 /* Determine whether we have a parameter pack at the end of the
6337 template template parameter's template parameter list. */
6338 if (TREE_VEC_ELT (parm_parms, nparms - 1) != error_mark_node)
6340 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, nparms - 1));
6342 if (error_operand_p (parm))
6345 switch (TREE_CODE (parm))
6349 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm)))
6354 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))
6364 && !(variadic_p && nargs >= nparms - 1))
6367 /* Check all of the template parameters except the parameter pack at
6368 the end (if any). */
6369 for (i = 0; i < nparms - variadic_p; ++i)
6371 if (TREE_VEC_ELT (parm_parms, i) == error_mark_node
6372 || TREE_VEC_ELT (arg_parms, i) == error_mark_node)
6375 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
6376 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
6378 if (!coerce_template_template_parm (parm, arg, complain, in_decl,
6386 /* Check each of the template parameters in the template
6387 argument against the template parameter pack at the end of
6388 the template template parameter. */
6389 if (TREE_VEC_ELT (parm_parms, i) == error_mark_node)
6392 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
6394 for (; i < nargs; ++i)
6396 if (TREE_VEC_ELT (arg_parms, i) == error_mark_node)
6399 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
6401 if (!coerce_template_template_parm (parm, arg, complain, in_decl,
6410 /* Verifies that the deduced template arguments (in TARGS) for the
6411 template template parameters (in TPARMS) represent valid bindings,
6412 by comparing the template parameter list of each template argument
6413 to the template parameter list of its corresponding template
6414 template parameter, in accordance with DR150. This
6415 routine can only be called after all template arguments have been
6416 deduced. It will return TRUE if all of the template template
6417 parameter bindings are okay, FALSE otherwise. */
6419 template_template_parm_bindings_ok_p (tree tparms, tree targs)
6421 int i, ntparms = TREE_VEC_LENGTH (tparms);
6424 /* We're dealing with template parms in this process. */
6425 ++processing_template_decl;
6427 targs = INNERMOST_TEMPLATE_ARGS (targs);
6429 for (i = 0; i < ntparms; ++i)
6431 tree tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
6432 tree targ = TREE_VEC_ELT (targs, i);
6434 if (TREE_CODE (tparm) == TEMPLATE_DECL && targ)
6436 tree packed_args = NULL_TREE;
6439 if (ARGUMENT_PACK_P (targ))
6441 /* Look inside the argument pack. */
6442 packed_args = ARGUMENT_PACK_ARGS (targ);
6443 len = TREE_VEC_LENGTH (packed_args);
6446 for (idx = 0; idx < len; ++idx)
6448 tree targ_parms = NULL_TREE;
6451 /* Extract the next argument from the argument
6453 targ = TREE_VEC_ELT (packed_args, idx);
6455 if (PACK_EXPANSION_P (targ))
6456 /* Look at the pattern of the pack expansion. */
6457 targ = PACK_EXPANSION_PATTERN (targ);
6459 /* Extract the template parameters from the template
6461 if (TREE_CODE (targ) == TEMPLATE_DECL)
6462 targ_parms = DECL_INNERMOST_TEMPLATE_PARMS (targ);
6463 else if (TREE_CODE (targ) == TEMPLATE_TEMPLATE_PARM)
6464 targ_parms = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ));
6466 /* Verify that we can coerce the template template
6467 parameters from the template argument to the template
6468 parameter. This requires an exact match. */
6470 && !coerce_template_template_parms
6471 (DECL_INNERMOST_TEMPLATE_PARMS (tparm),
6486 --processing_template_decl;
6490 /* Since type attributes aren't mangled, we need to strip them from
6491 template type arguments. */
6494 canonicalize_type_argument (tree arg, tsubst_flags_t complain)
6497 if (!arg || arg == error_mark_node || arg == TYPE_CANONICAL (arg))
6499 mv = TYPE_MAIN_VARIANT (arg);
6500 arg = strip_typedefs (arg);
6501 if (TYPE_ALIGN (arg) != TYPE_ALIGN (mv)
6502 || TYPE_ATTRIBUTES (arg) != TYPE_ATTRIBUTES (mv))
6504 if (complain & tf_warning)
6505 warning (0, "ignoring attributes on template argument %qT", arg);
6506 arg = build_aligned_type (arg, TYPE_ALIGN (mv));
6507 arg = cp_build_type_attribute_variant (arg, TYPE_ATTRIBUTES (mv));
6512 /* Convert the indicated template ARG as necessary to match the
6513 indicated template PARM. Returns the converted ARG, or
6514 error_mark_node if the conversion was unsuccessful. Error and
6515 warning messages are issued under control of COMPLAIN. This
6516 conversion is for the Ith parameter in the parameter list. ARGS is
6517 the full set of template arguments deduced so far. */
6520 convert_template_argument (tree parm,
6523 tsubst_flags_t complain,
6529 int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
6531 if (parm == error_mark_node)
6532 return error_mark_node;
6534 if (TREE_CODE (arg) == TREE_LIST
6535 && TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF)
6537 /* The template argument was the name of some
6538 member function. That's usually
6539 invalid, but static members are OK. In any
6540 case, grab the underlying fields/functions
6541 and issue an error later if required. */
6542 orig_arg = TREE_VALUE (arg);
6543 TREE_TYPE (arg) = unknown_type_node;
6548 requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
6549 requires_type = (TREE_CODE (parm) == TYPE_DECL
6550 || requires_tmpl_type);
6552 /* When determining whether an argument pack expansion is a template,
6553 look at the pattern. */
6554 if (TREE_CODE (arg) == TYPE_PACK_EXPANSION)
6555 arg = PACK_EXPANSION_PATTERN (arg);
6557 /* Deal with an injected-class-name used as a template template arg. */
6558 if (requires_tmpl_type && CLASS_TYPE_P (arg))
6560 tree t = maybe_get_template_decl_from_type_decl (TYPE_NAME (arg));
6561 if (TREE_CODE (t) == TEMPLATE_DECL)
6563 if (cxx_dialect >= cxx11)
6564 /* OK under DR 1004. */;
6565 else if (complain & tf_warning_or_error)
6566 pedwarn (input_location, OPT_Wpedantic, "injected-class-name %qD"
6567 " used as template template argument", TYPE_NAME (arg));
6568 else if (flag_pedantic_errors)
6576 ((TREE_CODE (arg) == TEMPLATE_DECL
6577 && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
6578 || (requires_tmpl_type && TREE_CODE (arg) == TYPE_ARGUMENT_PACK)
6579 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
6580 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
6583 && (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
6584 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE))
6585 arg = TYPE_STUB_DECL (arg);
6587 is_type = TYPE_P (arg) || is_tmpl_type;
6589 if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
6590 && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
6592 if (TREE_CODE (TREE_OPERAND (arg, 1)) == BIT_NOT_EXPR)
6594 if (complain & tf_error)
6595 error ("invalid use of destructor %qE as a type", orig_arg);
6596 return error_mark_node;
6599 permerror (input_location,
6600 "to refer to a type member of a template parameter, "
6601 "use %<typename %E%>", orig_arg);
6603 orig_arg = make_typename_type (TREE_OPERAND (arg, 0),
6604 TREE_OPERAND (arg, 1),
6610 if (is_type != requires_type)
6614 if (complain & tf_error)
6616 error ("type/value mismatch at argument %d in template "
6617 "parameter list for %qD",
6620 inform (input_location,
6621 " expected a constant of type %qT, got %qT",
6623 (DECL_P (arg) ? DECL_NAME (arg) : orig_arg));
6624 else if (requires_tmpl_type)
6625 inform (input_location,
6626 " expected a class template, got %qE", orig_arg);
6628 inform (input_location,
6629 " expected a type, got %qE", orig_arg);
6632 return error_mark_node;
6634 if (is_tmpl_type ^ requires_tmpl_type)
6636 if (in_decl && (complain & tf_error))
6638 error ("type/value mismatch at argument %d in template "
6639 "parameter list for %qD",
6642 inform (input_location,
6643 " expected a type, got %qT", DECL_NAME (arg));
6645 inform (input_location,
6646 " expected a class template, got %qT", orig_arg);
6648 return error_mark_node;
6653 if (requires_tmpl_type)
6655 if (template_parameter_pack_p (parm) && ARGUMENT_PACK_P (orig_arg))
6657 else if (TREE_CODE (TREE_TYPE (arg)) == UNBOUND_CLASS_TEMPLATE)
6658 /* The number of argument required is not known yet.
6659 Just accept it for now. */
6660 val = TREE_TYPE (arg);
6663 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
6666 /* Strip alias templates that are equivalent to another
6668 arg = get_underlying_template (arg);
6669 argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
6671 if (coerce_template_template_parms (parmparm, argparm,
6677 /* TEMPLATE_TEMPLATE_PARM node is preferred over
6679 if (val != error_mark_node)
6681 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val))
6682 val = TREE_TYPE (val);
6683 if (TREE_CODE (orig_arg) == TYPE_PACK_EXPANSION)
6684 val = make_pack_expansion (val);
6689 if (in_decl && (complain & tf_error))
6691 error ("type/value mismatch at argument %d in "
6692 "template parameter list for %qD",
6694 inform (input_location,
6695 " expected a template of type %qD, got %qT",
6699 val = error_mark_node;
6705 /* We only form one instance of each template specialization.
6706 Therefore, if we use a non-canonical variant (i.e., a
6707 typedef), any future messages referring to the type will use
6708 the typedef, which is confusing if those future uses do not
6709 themselves also use the typedef. */
6711 val = canonicalize_type_argument (val, complain);
6715 tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl);
6717 if (invalid_nontype_parm_type_p (t, complain))
6718 return error_mark_node;
6720 if (template_parameter_pack_p (parm) && ARGUMENT_PACK_P (orig_arg))
6722 if (same_type_p (t, TREE_TYPE (orig_arg)))
6726 /* Not sure if this is reachable, but it doesn't hurt
6728 error ("type mismatch in nontype parameter pack");
6729 val = error_mark_node;
6732 else if (!dependent_template_arg_p (orig_arg)
6733 && !uses_template_parms (t))
6734 /* We used to call digest_init here. However, digest_init
6735 will report errors, which we don't want when complain
6736 is zero. More importantly, digest_init will try too
6737 hard to convert things: for example, `0' should not be
6738 converted to pointer type at this point according to
6739 the standard. Accepting this is not merely an
6740 extension, since deciding whether or not these
6741 conversions can occur is part of determining which
6742 function template to call, or whether a given explicit
6743 argument specification is valid. */
6744 val = convert_nontype_argument (t, orig_arg, complain);
6746 val = strip_typedefs_expr (orig_arg);
6748 if (val == NULL_TREE)
6749 val = error_mark_node;
6750 else if (val == error_mark_node && (complain & tf_error))
6751 error ("could not convert template argument %qE to %qT", orig_arg, t);
6753 if (TREE_CODE (val) == SCOPE_REF)
6755 /* Strip typedefs from the SCOPE_REF. */
6756 tree type = canonicalize_type_argument (TREE_TYPE (val), complain);
6757 tree scope = canonicalize_type_argument (TREE_OPERAND (val, 0),
6759 val = build_qualified_name (type, scope, TREE_OPERAND (val, 1),
6760 QUALIFIED_NAME_IS_TEMPLATE (val));
6767 /* Coerces the remaining template arguments in INNER_ARGS (from
6768 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
6769 Returns the coerced argument pack. PARM_IDX is the position of this
6770 parameter in the template parameter list. ARGS is the original
6771 template argument list. */
6773 coerce_template_parameter_pack (tree parms,
6781 tsubst_flags_t complain)
6783 tree parm = TREE_VEC_ELT (parms, parm_idx);
6784 int nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
6787 tree packed_parms = NULL_TREE;
6789 if (arg_idx > nargs)
6792 if (tree packs = fixed_parameter_pack_p (TREE_VALUE (parm)))
6794 /* When the template parameter is a non-type template parameter pack
6795 or template template parameter pack whose type or template
6796 parameters use parameter packs, we know exactly how many arguments
6797 we are looking for. Build a vector of the instantiated decls for
6798 these template parameters in PACKED_PARMS. */
6799 /* We can't use make_pack_expansion here because it would interpret a
6800 _DECL as a use rather than a declaration. */
6801 tree decl = TREE_VALUE (parm);
6802 tree exp = cxx_make_type (TYPE_PACK_EXPANSION);
6803 SET_PACK_EXPANSION_PATTERN (exp, decl);
6804 PACK_EXPANSION_PARAMETER_PACKS (exp) = packs;
6805 SET_TYPE_STRUCTURAL_EQUALITY (exp);
6807 TREE_VEC_LENGTH (args)--;
6808 packed_parms = tsubst_pack_expansion (exp, args, complain, decl);
6809 TREE_VEC_LENGTH (args)++;
6811 if (packed_parms == error_mark_node)
6812 return error_mark_node;
6814 /* If we're doing a partial instantiation of a member template,
6815 verify that all of the types used for the non-type
6816 template parameter pack are, in fact, valid for non-type
6817 template parameters. */
6819 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args, arg_idx)))
6821 int j, len = TREE_VEC_LENGTH (packed_parms);
6822 for (j = 0; j < len; ++j)
6824 tree t = TREE_TYPE (TREE_VEC_ELT (packed_parms, j));
6825 if (invalid_nontype_parm_type_p (t, complain))
6826 return error_mark_node;
6828 /* We don't know how many args we have yet, just
6829 use the unconverted ones for now. */
6833 packed_args = make_tree_vec (TREE_VEC_LENGTH (packed_parms));
6836 packed_args = make_tree_vec (nargs - arg_idx);
6838 /* Convert the remaining arguments, which will be a part of the
6839 parameter pack "parm". */
6840 for (; arg_idx < nargs; ++arg_idx)
6842 tree arg = TREE_VEC_ELT (inner_args, arg_idx);
6843 tree actual_parm = TREE_VALUE (parm);
6844 int pack_idx = arg_idx - parm_idx;
6848 /* Once we've packed as many args as we have types, stop. */
6849 if (pack_idx >= TREE_VEC_LENGTH (packed_parms))
6851 else if (PACK_EXPANSION_P (arg))
6852 /* We don't know how many args we have yet, just
6853 use the unconverted ones for now. */
6856 actual_parm = TREE_VEC_ELT (packed_parms, pack_idx);
6859 if (arg == error_mark_node)
6861 if (complain & tf_error)
6862 error ("template argument %d is invalid", arg_idx + 1);
6865 arg = convert_template_argument (actual_parm,
6866 arg, new_args, complain, parm_idx,
6868 if (arg == error_mark_node)
6870 TREE_VEC_ELT (packed_args, pack_idx) = arg;
6873 if (arg_idx - parm_idx < TREE_VEC_LENGTH (packed_args)
6874 && TREE_VEC_LENGTH (packed_args) > 0)
6876 if (complain & tf_error)
6877 error ("wrong number of template arguments (%d, should be %d)",
6878 arg_idx - parm_idx, TREE_VEC_LENGTH (packed_args));
6879 return error_mark_node;
6882 if (TREE_CODE (TREE_VALUE (parm)) == TYPE_DECL
6883 || TREE_CODE (TREE_VALUE (parm)) == TEMPLATE_DECL)
6884 argument_pack = cxx_make_type (TYPE_ARGUMENT_PACK);
6887 argument_pack = make_node (NONTYPE_ARGUMENT_PACK);
6888 TREE_TYPE (argument_pack)
6889 = tsubst (TREE_TYPE (TREE_VALUE (parm)), new_args, complain, in_decl);
6890 TREE_CONSTANT (argument_pack) = 1;
6893 SET_ARGUMENT_PACK_ARGS (argument_pack, packed_args);
6894 #ifdef ENABLE_CHECKING
6895 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args,
6896 TREE_VEC_LENGTH (packed_args));
6898 return argument_pack;
6901 /* Returns the number of pack expansions in the template argument vector
6905 pack_expansion_args_count (tree args)
6910 for (i = 0; i < TREE_VEC_LENGTH (args); ++i)
6912 tree elt = TREE_VEC_ELT (args, i);
6913 if (elt && PACK_EXPANSION_P (elt))
6919 /* Convert all template arguments to their appropriate types, and
6920 return a vector containing the innermost resulting template
6921 arguments. If any error occurs, return error_mark_node. Error and
6922 warning messages are issued under control of COMPLAIN.
6924 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
6925 for arguments not specified in ARGS. Otherwise, if
6926 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
6927 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
6928 USE_DEFAULT_ARGS is false, then all arguments must be specified in
6932 coerce_template_parms (tree parms,
6935 tsubst_flags_t complain,
6936 bool require_all_args,
6937 bool use_default_args)
6939 int nparms, nargs, parm_idx, arg_idx, lost = 0;
6940 tree orig_inner_args;
6943 tree new_inner_args;
6944 int saved_unevaluated_operand;
6945 int saved_inhibit_evaluation_warnings;
6947 /* When used as a boolean value, indicates whether this is a
6948 variadic template parameter list. Since it's an int, we can also
6949 subtract it from nparms to get the number of non-variadic
6952 int variadic_args_p = 0;
6953 int post_variadic_parms = 0;
6955 /* Likewise for parameters with default arguments. */
6958 if (args == error_mark_node)
6959 return error_mark_node;
6961 nparms = TREE_VEC_LENGTH (parms);
6963 /* Determine if there are any parameter packs or default arguments. */
6964 for (parm_idx = 0; parm_idx < nparms; ++parm_idx)
6966 tree parm = TREE_VEC_ELT (parms, parm_idx);
6968 ++post_variadic_parms;
6969 if (template_parameter_pack_p (TREE_VALUE (parm)))
6971 if (TREE_PURPOSE (parm))
6975 inner_args = orig_inner_args = INNERMOST_TEMPLATE_ARGS (args);
6976 /* If there are no parameters that follow a parameter pack, we need to
6977 expand any argument packs so that we can deduce a parameter pack from
6978 some non-packed args followed by an argument pack, as in variadic85.C.
6979 If there are such parameters, we need to leave argument packs intact
6980 so the arguments are assigned properly. This can happen when dealing
6981 with a nested class inside a partial specialization of a class
6982 template, as in variadic92.C, or when deducing a template parameter pack
6983 from a sub-declarator, as in variadic114.C. */
6984 if (!post_variadic_parms)
6985 inner_args = expand_template_argument_pack (inner_args);
6987 /* Count any pack expansion args. */
6988 variadic_args_p = pack_expansion_args_count (inner_args);
6990 nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
6991 if ((nargs > nparms && !variadic_p)
6992 || (nargs < nparms - variadic_p
6995 && (!use_default_args
6996 || (TREE_VEC_ELT (parms, nargs) != error_mark_node
6997 && !TREE_PURPOSE (TREE_VEC_ELT (parms, nargs))))))
6999 if (complain & tf_error)
7001 if (variadic_p || default_p)
7003 nparms -= variadic_p + default_p;
7004 error ("wrong number of template arguments "
7005 "(%d, should be at least %d)", nargs, nparms);
7008 error ("wrong number of template arguments "
7009 "(%d, should be %d)", nargs, nparms);
7012 inform (input_location, "provided for %q+D", in_decl);
7015 return error_mark_node;
7017 /* We can't pass a pack expansion to a non-pack parameter of an alias
7018 template (DR 1430). */
7019 else if (in_decl && DECL_ALIAS_TEMPLATE_P (in_decl)
7021 && nargs - variadic_args_p < nparms - variadic_p)
7023 if (complain & tf_error)
7025 for (int i = 0; i < TREE_VEC_LENGTH (inner_args); ++i)
7027 tree arg = TREE_VEC_ELT (inner_args, i);
7028 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
7030 if (PACK_EXPANSION_P (arg)
7031 && !template_parameter_pack_p (parm))
7033 error ("pack expansion argument for non-pack parameter "
7034 "%qD of alias template %qD", parm, in_decl);
7035 inform (DECL_SOURCE_LOCATION (parm), "declared here");
7042 return error_mark_node;
7045 /* We need to evaluate the template arguments, even though this
7046 template-id may be nested within a "sizeof". */
7047 saved_unevaluated_operand = cp_unevaluated_operand;
7048 cp_unevaluated_operand = 0;
7049 saved_inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
7050 c_inhibit_evaluation_warnings = 0;
7051 new_inner_args = make_tree_vec (nparms);
7052 new_args = add_outermost_template_args (args, new_inner_args);
7053 int pack_adjust = 0;
7054 for (parm_idx = 0, arg_idx = 0; parm_idx < nparms; parm_idx++, arg_idx++)
7059 /* Get the Ith template parameter. */
7060 parm = TREE_VEC_ELT (parms, parm_idx);
7062 if (parm == error_mark_node)
7064 TREE_VEC_ELT (new_inner_args, arg_idx) = error_mark_node;
7068 /* Calculate the next argument. */
7069 if (arg_idx < nargs)
7070 arg = TREE_VEC_ELT (inner_args, arg_idx);
7074 if (template_parameter_pack_p (TREE_VALUE (parm))
7075 && !(arg && ARGUMENT_PACK_P (arg)))
7077 /* Some arguments will be placed in the
7078 template parameter pack PARM. */
7079 arg = coerce_template_parameter_pack (parms, parm_idx, args,
7080 inner_args, arg_idx,
7084 if (arg == NULL_TREE)
7086 /* We don't know how many args we have yet, just use the
7087 unconverted (and still packed) ones for now. */
7088 new_inner_args = orig_inner_args;
7093 TREE_VEC_ELT (new_inner_args, parm_idx) = arg;
7095 /* Store this argument. */
7096 if (arg == error_mark_node)
7099 /* We are done with all of the arguments. */
7104 pack_adjust = TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) - 1;
7105 arg_idx += pack_adjust;
7112 if (PACK_EXPANSION_P (arg))
7114 /* "If every valid specialization of a variadic template
7115 requires an empty template parameter pack, the template is
7116 ill-formed, no diagnostic required." So check that the
7117 pattern works with this parameter. */
7118 tree pattern = PACK_EXPANSION_PATTERN (arg);
7119 tree conv = convert_template_argument (TREE_VALUE (parm),
7123 if (conv == error_mark_node)
7125 inform (input_location, "so any instantiation with a "
7126 "non-empty parameter pack would be ill-formed");
7129 else if (TYPE_P (conv) && !TYPE_P (pattern))
7130 /* Recover from missing typename. */
7131 TREE_VEC_ELT (inner_args, arg_idx)
7132 = make_pack_expansion (conv);
7134 /* We don't know how many args we have yet, just
7135 use the unconverted ones for now. */
7136 new_inner_args = inner_args;
7141 else if (require_all_args)
7143 /* There must be a default arg in this case. */
7144 arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
7146 /* The position of the first default template argument,
7147 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
7149 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args))
7150 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args,
7151 arg_idx - pack_adjust);
7156 if (arg == error_mark_node)
7158 if (complain & tf_error)
7159 error ("template argument %d is invalid", arg_idx + 1);
7162 /* This only occurs if there was an error in the template
7163 parameter list itself (which we would already have
7164 reported) that we are trying to recover from, e.g., a class
7165 template with a parameter list such as
7166 template<typename..., typename>. */
7169 arg = convert_template_argument (TREE_VALUE (parm),
7170 arg, new_args, complain,
7173 if (arg == error_mark_node)
7175 TREE_VEC_ELT (new_inner_args, arg_idx - pack_adjust) = arg;
7177 cp_unevaluated_operand = saved_unevaluated_operand;
7178 c_inhibit_evaluation_warnings = saved_inhibit_evaluation_warnings;
7180 if (variadic_p && arg_idx < nargs)
7182 if (complain & tf_error)
7184 error ("wrong number of template arguments "
7185 "(%d, should be %d)", nargs, arg_idx);
7187 error ("provided for %q+D", in_decl);
7189 return error_mark_node;
7193 return error_mark_node;
7195 #ifdef ENABLE_CHECKING
7196 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args))
7197 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args,
7198 TREE_VEC_LENGTH (new_inner_args));
7201 return new_inner_args;
7204 /* Like coerce_template_parms. If PARMS represents all template
7205 parameters levels, this function returns a vector of vectors
7206 representing all the resulting argument levels. Note that in this
7207 case, only the innermost arguments are coerced because the
7208 outermost ones are supposed to have been coerced already.
7210 Otherwise, if PARMS represents only (the innermost) vector of
7211 parameters, this function returns a vector containing just the
7212 innermost resulting arguments. */
7215 coerce_innermost_template_parms (tree parms,
7218 tsubst_flags_t complain,
7219 bool require_all_args,
7220 bool use_default_args)
7222 int parms_depth = TMPL_PARMS_DEPTH (parms);
7223 int args_depth = TMPL_ARGS_DEPTH (args);
7226 if (parms_depth > 1)
7228 coerced_args = make_tree_vec (parms_depth);
7232 for (level = parms, cur_depth = parms_depth;
7233 parms_depth > 0 && level != NULL_TREE;
7234 level = TREE_CHAIN (level), --cur_depth)
7237 if (cur_depth == args_depth)
7238 l = coerce_template_parms (TREE_VALUE (level),
7239 args, in_decl, complain,
7243 l = TMPL_ARGS_LEVEL (args, cur_depth);
7245 if (l == error_mark_node)
7246 return error_mark_node;
7248 SET_TMPL_ARGS_LEVEL (coerced_args, cur_depth, l);
7252 coerced_args = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parms),
7253 args, in_decl, complain,
7256 return coerced_args;
7259 /* Returns 1 if template args OT and NT are equivalent. */
7262 template_args_equal (tree ot, tree nt)
7266 if (nt == NULL_TREE || ot == NULL_TREE)
7269 if (TREE_CODE (nt) == TREE_VEC)
7270 /* For member templates */
7271 return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt);
7272 else if (PACK_EXPANSION_P (ot))
7273 return (PACK_EXPANSION_P (nt)
7274 && template_args_equal (PACK_EXPANSION_PATTERN (ot),
7275 PACK_EXPANSION_PATTERN (nt))
7276 && template_args_equal (PACK_EXPANSION_EXTRA_ARGS (ot),
7277 PACK_EXPANSION_EXTRA_ARGS (nt)));
7278 else if (ARGUMENT_PACK_P (ot))
7283 if (!ARGUMENT_PACK_P (nt))
7286 opack = ARGUMENT_PACK_ARGS (ot);
7287 npack = ARGUMENT_PACK_ARGS (nt);
7288 len = TREE_VEC_LENGTH (opack);
7289 if (TREE_VEC_LENGTH (npack) != len)
7291 for (i = 0; i < len; ++i)
7292 if (!template_args_equal (TREE_VEC_ELT (opack, i),
7293 TREE_VEC_ELT (npack, i)))
7297 else if (ot && TREE_CODE (ot) == ARGUMENT_PACK_SELECT)
7299 /* We get here probably because we are in the middle of substituting
7300 into the pattern of a pack expansion. In that case the
7301 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
7302 interested in. So we want to use the initial pack argument for
7304 ot = ARGUMENT_PACK_SELECT_FROM_PACK (ot);
7305 if (nt && TREE_CODE (nt) == ARGUMENT_PACK_SELECT)
7306 nt = ARGUMENT_PACK_SELECT_FROM_PACK (nt);
7307 return template_args_equal (ot, nt);
7309 else if (TYPE_P (nt))
7313 /* Don't treat an alias template specialization with dependent
7314 arguments as equivalent to its underlying type when used as a
7315 template argument; we need them to be distinct so that we
7316 substitute into the specialization arguments at instantiation
7317 time. And aliases can't be equivalent without being ==, so
7318 we don't need to look any deeper. */
7319 if (TYPE_ALIAS_P (nt) || TYPE_ALIAS_P (ot))
7322 return same_type_p (ot, nt);
7324 else if (TREE_CODE (ot) == TREE_VEC || TYPE_P (ot))
7328 /* Try to treat a template non-type argument that has been converted
7329 to the parameter type as equivalent to one that hasn't yet. */
7330 for (enum tree_code code1 = TREE_CODE (ot);
7331 CONVERT_EXPR_CODE_P (code1)
7332 || code1 == NON_LVALUE_EXPR;
7333 code1 = TREE_CODE (ot))
7334 ot = TREE_OPERAND (ot, 0);
7335 for (enum tree_code code2 = TREE_CODE (nt);
7336 CONVERT_EXPR_CODE_P (code2)
7337 || code2 == NON_LVALUE_EXPR;
7338 code2 = TREE_CODE (nt))
7339 nt = TREE_OPERAND (nt, 0);
7341 return cp_tree_equal (ot, nt);
7345 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
7346 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
7347 NEWARG_PTR with the offending arguments if they are non-NULL. */
7350 comp_template_args_with_info (tree oldargs, tree newargs,
7351 tree *oldarg_ptr, tree *newarg_ptr)
7355 if (oldargs == newargs)
7358 if (!oldargs || !newargs)
7361 if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
7364 for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
7366 tree nt = TREE_VEC_ELT (newargs, i);
7367 tree ot = TREE_VEC_ELT (oldargs, i);
7369 if (! template_args_equal (ot, nt))
7371 if (oldarg_ptr != NULL)
7373 if (newarg_ptr != NULL)
7381 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
7382 of template arguments. Returns 0 otherwise. */
7385 comp_template_args (tree oldargs, tree newargs)
7387 return comp_template_args_with_info (oldargs, newargs, NULL, NULL);
7391 add_pending_template (tree d)
7393 tree ti = (TYPE_P (d)
7394 ? CLASSTYPE_TEMPLATE_INFO (d)
7395 : DECL_TEMPLATE_INFO (d));
7396 struct pending_template *pt;
7399 if (TI_PENDING_TEMPLATE_FLAG (ti))
7402 /* We are called both from instantiate_decl, where we've already had a
7403 tinst_level pushed, and instantiate_template, where we haven't.
7405 level = !current_tinst_level || current_tinst_level->decl != d;
7408 push_tinst_level (d);
7410 pt = ggc_alloc<pending_template> ();
7412 pt->tinst = current_tinst_level;
7413 if (last_pending_template)
7414 last_pending_template->next = pt;
7416 pending_templates = pt;
7418 last_pending_template = pt;
7420 TI_PENDING_TEMPLATE_FLAG (ti) = 1;
7427 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
7428 ARGLIST. Valid choices for FNS are given in the cp-tree.def
7429 documentation for TEMPLATE_ID_EXPR. */
7432 lookup_template_function (tree fns, tree arglist)
7436 if (fns == error_mark_node || arglist == error_mark_node)
7437 return error_mark_node;
7439 gcc_assert (!arglist || TREE_CODE (arglist) == TREE_VEC);
7441 if (!is_overloaded_fn (fns) && !identifier_p (fns))
7443 error ("%q#D is not a function template", fns);
7444 return error_mark_node;
7447 if (BASELINK_P (fns))
7449 BASELINK_FUNCTIONS (fns) = build2 (TEMPLATE_ID_EXPR,
7451 BASELINK_FUNCTIONS (fns),
7456 type = TREE_TYPE (fns);
7457 if (TREE_CODE (fns) == OVERLOAD || !type)
7458 type = unknown_type_node;
7460 return build2 (TEMPLATE_ID_EXPR, type, fns, arglist);
7463 /* Within the scope of a template class S<T>, the name S gets bound
7464 (in build_self_reference) to a TYPE_DECL for the class, not a
7465 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
7466 or one of its enclosing classes, and that type is a template,
7467 return the associated TEMPLATE_DECL. Otherwise, the original
7470 Also handle the case when DECL is a TREE_LIST of ambiguous
7471 injected-class-names from different bases. */
7474 maybe_get_template_decl_from_type_decl (tree decl)
7476 if (decl == NULL_TREE)
7479 /* DR 176: A lookup that finds an injected-class-name (10.2
7480 [class.member.lookup]) can result in an ambiguity in certain cases
7481 (for example, if it is found in more than one base class). If all of
7482 the injected-class-names that are found refer to specializations of
7483 the same class template, and if the name is followed by a
7484 template-argument-list, the reference refers to the class template
7485 itself and not a specialization thereof, and is not ambiguous. */
7486 if (TREE_CODE (decl) == TREE_LIST)
7488 tree t, tmpl = NULL_TREE;
7489 for (t = decl; t; t = TREE_CHAIN (t))
7491 tree elt = maybe_get_template_decl_from_type_decl (TREE_VALUE (t));
7494 else if (tmpl != elt)
7497 if (tmpl && t == NULL_TREE)
7503 return (decl != NULL_TREE
7504 && DECL_SELF_REFERENCE_P (decl)
7505 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
7506 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl;
7509 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
7510 parameters, find the desired type.
7512 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
7514 IN_DECL, if non-NULL, is the template declaration we are trying to
7517 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
7518 the class we are looking up.
7520 Issue error and warning messages under control of COMPLAIN.
7522 If the template class is really a local class in a template
7523 function, then the FUNCTION_CONTEXT is the function in which it is
7526 ??? Note that this function is currently called *twice* for each
7527 template-id: the first time from the parser, while creating the
7528 incomplete type (finish_template_type), and the second type during the
7529 real instantiation (instantiate_template_class). This is surely something
7530 that we want to avoid. It also causes some problems with argument
7531 coercion (see convert_nontype_argument for more information on this). */
7534 lookup_template_class_1 (tree d1, tree arglist, tree in_decl, tree context,
7535 int entering_scope, tsubst_flags_t complain)
7537 tree templ = NULL_TREE, parmlist;
7544 if (identifier_p (d1))
7546 tree value = innermost_non_namespace_value (d1);
7547 if (value && DECL_TEMPLATE_TEMPLATE_PARM_P (value))
7552 push_decl_namespace (context);
7553 templ = lookup_name (d1);
7554 templ = maybe_get_template_decl_from_type_decl (templ);
7556 pop_decl_namespace ();
7559 context = DECL_CONTEXT (templ);
7561 else if (TREE_CODE (d1) == TYPE_DECL && MAYBE_CLASS_TYPE_P (TREE_TYPE (d1)))
7563 tree type = TREE_TYPE (d1);
7565 /* If we are declaring a constructor, say A<T>::A<T>, we will get
7566 an implicit typename for the second A. Deal with it. */
7567 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
7568 type = TREE_TYPE (type);
7570 if (CLASSTYPE_TEMPLATE_INFO (type))
7572 templ = CLASSTYPE_TI_TEMPLATE (type);
7573 d1 = DECL_NAME (templ);
7576 else if (TREE_CODE (d1) == ENUMERAL_TYPE
7577 || (TYPE_P (d1) && MAYBE_CLASS_TYPE_P (d1)))
7579 templ = TYPE_TI_TEMPLATE (d1);
7580 d1 = DECL_NAME (templ);
7582 else if (DECL_TYPE_TEMPLATE_P (d1))
7585 d1 = DECL_NAME (templ);
7586 context = DECL_CONTEXT (templ);
7588 else if (DECL_TEMPLATE_TEMPLATE_PARM_P (d1))
7591 d1 = DECL_NAME (templ);
7594 /* Issue an error message if we didn't find a template. */
7597 if (complain & tf_error)
7598 error ("%qT is not a template", d1);
7599 return error_mark_node;
7602 if (TREE_CODE (templ) != TEMPLATE_DECL
7603 /* Make sure it's a user visible template, if it was named by
7605 || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (templ)
7606 && !PRIMARY_TEMPLATE_P (templ)))
7608 if (complain & tf_error)
7610 error ("non-template type %qT used as a template", d1);
7612 error ("for template declaration %q+D", in_decl);
7614 return error_mark_node;
7617 complain &= ~tf_user;
7619 /* An alias that just changes the name of a template is equivalent to the
7620 other template, so if any of the arguments are pack expansions, strip
7621 the alias to avoid problems with a pack expansion passed to a non-pack
7622 alias template parameter (DR 1430). */
7623 if (pack_expansion_args_count (INNERMOST_TEMPLATE_ARGS (arglist)))
7624 templ = get_underlying_template (templ);
7626 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ))
7628 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
7629 template arguments */
7635 parmlist = DECL_INNERMOST_TEMPLATE_PARMS (templ);
7637 /* Consider an example where a template template parameter declared as
7639 template <class T, class U = std::allocator<T> > class TT
7641 The template parameter level of T and U are one level larger than
7642 of TT. To proper process the default argument of U, say when an
7643 instantiation `TT<int>' is seen, we need to build the full
7644 arguments containing {int} as the innermost level. Outer levels,
7645 available when not appearing as default template argument, can be
7646 obtained from the arguments of the enclosing template.
7648 Suppose that TT is later substituted with std::vector. The above
7649 instantiation is `TT<int, std::allocator<T> >' with TT at
7650 level 1, and T at level 2, while the template arguments at level 1
7651 becomes {std::vector} and the inner level 2 is {int}. */
7653 outer = DECL_CONTEXT (templ);
7655 outer = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer)));
7656 else if (current_template_parms)
7657 /* This is an argument of the current template, so we haven't set
7658 DECL_CONTEXT yet. */
7659 outer = current_template_args ();
7662 arglist = add_to_template_args (outer, arglist);
7664 arglist2 = coerce_template_parms (parmlist, arglist, templ,
7666 /*require_all_args=*/true,
7667 /*use_default_args=*/true);
7668 if (arglist2 == error_mark_node
7669 || (!uses_template_parms (arglist2)
7670 && check_instantiated_args (templ, arglist2, complain)))
7671 return error_mark_node;
7673 parm = bind_template_template_parm (TREE_TYPE (templ), arglist2);
7678 tree template_type = TREE_TYPE (templ);
7681 tree found = NULL_TREE;
7684 int is_dependent_type;
7685 int use_partial_inst_tmpl = false;
7687 if (template_type == error_mark_node)
7688 /* An error occurred while building the template TEMPL, and a
7689 diagnostic has most certainly been emitted for that
7690 already. Let's propagate that error. */
7691 return error_mark_node;
7693 gen_tmpl = most_general_template (templ);
7694 parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
7695 parm_depth = TMPL_PARMS_DEPTH (parmlist);
7696 arg_depth = TMPL_ARGS_DEPTH (arglist);
7698 if (arg_depth == 1 && parm_depth > 1)
7700 /* We've been given an incomplete set of template arguments.
7703 template <class T> struct S1 {
7704 template <class U> struct S2 {};
7705 template <class U> struct S2<U*> {};
7708 we will be called with an ARGLIST of `U*', but the
7709 TEMPLATE will be `template <class T> template
7710 <class U> struct S1<T>::S2'. We must fill in the missing
7713 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (templ)),
7715 arg_depth = TMPL_ARGS_DEPTH (arglist);
7718 /* Now we should have enough arguments. */
7719 gcc_assert (parm_depth == arg_depth);
7721 /* From here on, we're only interested in the most general
7724 /* Calculate the BOUND_ARGS. These will be the args that are
7725 actually tsubst'd into the definition to create the
7727 arglist = coerce_innermost_template_parms (parmlist, arglist, gen_tmpl,
7729 /*require_all_args=*/true,
7730 /*use_default_args=*/true);
7732 if (arglist == error_mark_node)
7733 /* We were unable to bind the arguments. */
7734 return error_mark_node;
7736 /* In the scope of a template class, explicit references to the
7737 template class refer to the type of the template, not any
7738 instantiation of it. For example, in:
7740 template <class T> class C { void f(C<T>); }
7742 the `C<T>' is just the same as `C'. Outside of the
7743 class, however, such a reference is an instantiation. */
7745 || !PRIMARY_TEMPLATE_P (gen_tmpl)
7746 || currently_open_class (template_type))
7747 /* comp_template_args is expensive, check it last. */
7748 && comp_template_args (TYPE_TI_ARGS (template_type),
7750 return template_type;
7752 /* If we already have this specialization, return it. */
7753 elt.tmpl = gen_tmpl;
7755 hash = spec_hasher::hash (&elt);
7756 entry = type_specializations->find_with_hash (&elt, hash);
7761 is_dependent_type = uses_template_parms (arglist);
7763 /* If the deduced arguments are invalid, then the binding
7765 if (!is_dependent_type
7766 && check_instantiated_args (gen_tmpl,
7767 INNERMOST_TEMPLATE_ARGS (arglist),
7769 return error_mark_node;
7771 if (!is_dependent_type
7772 && !PRIMARY_TEMPLATE_P (gen_tmpl)
7773 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl))
7774 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl)) == NAMESPACE_DECL)
7776 found = xref_tag_from_type (TREE_TYPE (gen_tmpl),
7777 DECL_NAME (gen_tmpl),
7778 /*tag_scope=*/ts_global);
7782 context = tsubst (DECL_CONTEXT (gen_tmpl), arglist,
7784 if (context == error_mark_node)
7785 return error_mark_node;
7788 context = global_namespace;
7790 /* Create the type. */
7791 if (DECL_ALIAS_TEMPLATE_P (gen_tmpl))
7793 /* The user referred to a specialization of an alias
7794 template represented by GEN_TMPL.
7796 [temp.alias]/2 says:
7798 When a template-id refers to the specialization of an
7799 alias template, it is equivalent to the associated
7800 type obtained by substitution of its
7801 template-arguments for the template-parameters in the
7802 type-id of the alias template. */
7804 t = tsubst (TREE_TYPE (gen_tmpl), arglist, complain, in_decl);
7805 /* Note that the call above (by indirectly calling
7806 register_specialization in tsubst_decl) registers the
7807 TYPE_DECL representing the specialization of the alias
7808 template. So next time someone substitutes ARGLIST for
7809 the template parms into the alias template (GEN_TMPL),
7810 she'll get that TYPE_DECL back. */
7812 if (t == error_mark_node)
7815 else if (TREE_CODE (template_type) == ENUMERAL_TYPE)
7817 if (!is_dependent_type)
7819 set_current_access_from_decl (TYPE_NAME (template_type));
7820 t = start_enum (TYPE_IDENTIFIER (template_type), NULL_TREE,
7821 tsubst (ENUM_UNDERLYING_TYPE (template_type),
7822 arglist, complain, in_decl),
7823 SCOPED_ENUM_P (template_type), NULL);
7825 if (t == error_mark_node)
7830 /* We don't want to call start_enum for this type, since
7831 the values for the enumeration constants may involve
7832 template parameters. And, no one should be interested
7833 in the enumeration constants for such a type. */
7834 t = cxx_make_type (ENUMERAL_TYPE);
7835 SET_SCOPED_ENUM_P (t, SCOPED_ENUM_P (template_type));
7837 SET_OPAQUE_ENUM_P (t, OPAQUE_ENUM_P (template_type));
7838 ENUM_FIXED_UNDERLYING_TYPE_P (t)
7839 = ENUM_FIXED_UNDERLYING_TYPE_P (template_type);
7841 else if (CLASS_TYPE_P (template_type))
7843 t = make_class_type (TREE_CODE (template_type));
7844 CLASSTYPE_DECLARED_CLASS (t)
7845 = CLASSTYPE_DECLARED_CLASS (template_type);
7846 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
7847 TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);
7849 /* A local class. Make sure the decl gets registered properly. */
7850 if (context == current_function_decl)
7851 pushtag (DECL_NAME (gen_tmpl), t, /*tag_scope=*/ts_current);
7853 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type), arglist))
7854 /* This instantiation is another name for the primary
7855 template type. Set the TYPE_CANONICAL field
7857 TYPE_CANONICAL (t) = template_type;
7858 else if (any_template_arguments_need_structural_equality_p (arglist))
7859 /* Some of the template arguments require structural
7860 equality testing, so this template class requires
7861 structural equality testing. */
7862 SET_TYPE_STRUCTURAL_EQUALITY (t);
7867 /* If we called start_enum or pushtag above, this information
7868 will already be set up. */
7871 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
7873 type_decl = create_implicit_typedef (DECL_NAME (gen_tmpl), t);
7874 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
7875 DECL_SOURCE_LOCATION (type_decl)
7876 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type));
7879 type_decl = TYPE_NAME (t);
7881 if (CLASS_TYPE_P (template_type))
7883 TREE_PRIVATE (type_decl)
7884 = TREE_PRIVATE (TYPE_MAIN_DECL (template_type));
7885 TREE_PROTECTED (type_decl)
7886 = TREE_PROTECTED (TYPE_MAIN_DECL (template_type));
7887 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type))
7889 DECL_VISIBILITY_SPECIFIED (type_decl) = 1;
7890 DECL_VISIBILITY (type_decl) = CLASSTYPE_VISIBILITY (template_type);
7894 if (OVERLOAD_TYPE_P (t)
7895 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl))
7898 = lookup_attribute ("abi_tag", TYPE_ATTRIBUTES (template_type)))
7900 if (!TREE_CHAIN (attributes))
7901 TYPE_ATTRIBUTES (t) = attributes;
7904 = build_tree_list (TREE_PURPOSE (attributes),
7905 TREE_VALUE (attributes));
7909 /* Let's consider the explicit specialization of a member
7910 of a class template specialization that is implicitly instantiated,
7915 template<class U> struct M {}; //#0
7920 struct S<int>::M<char> //#1
7924 [temp.expl.spec]/4 says this is valid.
7926 In this case, when we write:
7929 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
7932 When we encounter #1, we want to store the partial instantiation
7933 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
7935 For all cases other than this "explicit specialization of member of a
7936 class template", we just want to store the most general template into
7937 the CLASSTYPE_TI_TEMPLATE of M.
7939 This case of "explicit specialization of member of a class template"
7941 1/ the enclosing class is an instantiation of, and therefore not
7942 the same as, the context of the most general template, and
7943 2/ we aren't looking at the partial instantiation itself, i.e.
7944 the innermost arguments are not the same as the innermost parms of
7945 the most general template.
7947 So it's only when 1/ and 2/ happens that we want to use the partial
7948 instantiation of the member template in lieu of its most general
7951 if (PRIMARY_TEMPLATE_P (gen_tmpl)
7952 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist)
7953 /* the enclosing class must be an instantiation... */
7954 && CLASS_TYPE_P (context)
7955 && !same_type_p (context, DECL_CONTEXT (gen_tmpl)))
7957 tree partial_inst_args;
7958 TREE_VEC_LENGTH (arglist)--;
7959 ++processing_template_decl;
7961 tsubst (INNERMOST_TEMPLATE_ARGS
7962 (TYPE_TI_ARGS (TREE_TYPE (gen_tmpl))),
7963 arglist, complain, NULL_TREE);
7964 --processing_template_decl;
7965 TREE_VEC_LENGTH (arglist)++;
7966 use_partial_inst_tmpl =
7967 /*...and we must not be looking at the partial instantiation
7969 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist),
7973 if (!use_partial_inst_tmpl)
7974 /* This case is easy; there are no member templates involved. */
7978 /* This is a full instantiation of a member template. Find
7979 the partial instantiation of which this is an instance. */
7981 /* Temporarily reduce by one the number of levels in the ARGLIST
7982 so as to avoid comparing the last set of arguments. */
7983 TREE_VEC_LENGTH (arglist)--;
7984 found = tsubst (gen_tmpl, arglist, complain, NULL_TREE);
7985 TREE_VEC_LENGTH (arglist)++;
7986 /* FOUND is either a proper class type, or an alias
7987 template specialization. In the later case, it's a
7988 TYPE_DECL, resulting from the substituting of arguments
7989 for parameters in the TYPE_DECL of the alias template
7990 done earlier. So be careful while getting the template
7992 found = TREE_CODE (found) == TYPE_DECL
7993 ? TYPE_TI_TEMPLATE (TREE_TYPE (found))
7994 : CLASSTYPE_TI_TEMPLATE (found);
7997 SET_TYPE_TEMPLATE_INFO (t, build_template_info (found, arglist));
8000 slot = type_specializations->find_slot_with_hash (&elt, hash, INSERT);
8001 entry = ggc_alloc<spec_entry> ();
8005 /* Note this use of the partial instantiation so we can check it
8006 later in maybe_process_partial_specialization. */
8007 DECL_TEMPLATE_INSTANTIATIONS (found)
8008 = tree_cons (arglist, t,
8009 DECL_TEMPLATE_INSTANTIATIONS (found));
8011 if (TREE_CODE (template_type) == ENUMERAL_TYPE && !is_dependent_type
8012 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl))
8013 /* Now that the type has been registered on the instantiations
8014 list, we set up the enumerators. Because the enumeration
8015 constants may involve the enumeration type itself, we make
8016 sure to register the type first, and then create the
8017 constants. That way, doing tsubst_expr for the enumeration
8018 constants won't result in recursive calls here; we'll find
8019 the instantiation and exit above. */
8020 tsubst_enum (template_type, t, arglist);
8022 if (CLASS_TYPE_P (template_type) && is_dependent_type)
8023 /* If the type makes use of template parameters, the
8024 code that generates debugging information will crash. */
8025 DECL_IGNORED_P (TYPE_MAIN_DECL (t)) = 1;
8027 /* Possibly limit visibility based on template args. */
8028 TREE_PUBLIC (type_decl) = 1;
8029 determine_visibility (type_decl);
8031 inherit_targ_abi_tags (t);
8037 /* Wrapper for lookup_template_class_1. */
8040 lookup_template_class (tree d1, tree arglist, tree in_decl, tree context,
8041 int entering_scope, tsubst_flags_t complain)
8044 timevar_push (TV_TEMPLATE_INST);
8045 ret = lookup_template_class_1 (d1, arglist, in_decl, context,
8046 entering_scope, complain);
8047 timevar_pop (TV_TEMPLATE_INST);
8051 /* Return a TEMPLATE_ID_EXPR for the given variable template and ARGLIST.
8052 The type of the expression is the unknown_type_node since the
8053 template-id could refer to an explicit or partial specialization. */
8056 lookup_template_variable (tree templ, tree arglist)
8058 tree type = unknown_type_node;
8059 return build2 (TEMPLATE_ID_EXPR, type, templ, arglist);
8062 /* Instantiate a variable declaration from a TEMPLATE_ID_EXPR for use. */
8065 finish_template_variable (tree var)
8067 tree templ = TREE_OPERAND (var, 0);
8069 tree arglist = TREE_OPERAND (var, 1);
8070 tree tmpl_args = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (templ));
8071 arglist = add_outermost_template_args (tmpl_args, arglist);
8073 tree parms = DECL_TEMPLATE_PARMS (templ);
8074 tsubst_flags_t complain = tf_warning_or_error;
8075 arglist = coerce_innermost_template_parms (parms, arglist, templ, complain,
8077 /*use_default*/true);
8079 return instantiate_template (templ, arglist, complain);
8086 /* True when we should also visit template parameters that occur in
8087 non-deduced contexts. */
8088 bool include_nondeduced_p;
8089 hash_set<tree> *visited;
8092 /* Called from for_each_template_parm via walk_tree. */
8095 for_each_template_parm_r (tree *tp, int *walk_subtrees, void *d)
8098 struct pair_fn_data *pfd = (struct pair_fn_data *) d;
8099 tree_fn_t fn = pfd->fn;
8100 void *data = pfd->data;
8103 && (pfd->include_nondeduced_p || TREE_CODE (t) != TYPENAME_TYPE)
8104 && for_each_template_parm (TYPE_CONTEXT (t), fn, data, pfd->visited,
8105 pfd->include_nondeduced_p))
8106 return error_mark_node;
8108 switch (TREE_CODE (t))
8111 if (TYPE_PTRMEMFUNC_P (t))
8117 if (!TYPE_TEMPLATE_INFO (t))
8119 else if (for_each_template_parm (TYPE_TI_ARGS (t),
8120 fn, data, pfd->visited,
8121 pfd->include_nondeduced_p))
8122 return error_mark_node;
8126 if (for_each_template_parm (TYPE_MIN_VALUE (t),
8127 fn, data, pfd->visited,
8128 pfd->include_nondeduced_p)
8129 || for_each_template_parm (TYPE_MAX_VALUE (t),
8130 fn, data, pfd->visited,
8131 pfd->include_nondeduced_p))
8132 return error_mark_node;
8136 /* Since we're not going to walk subtrees, we have to do this
8138 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data,
8139 pfd->visited, pfd->include_nondeduced_p))
8140 return error_mark_node;
8144 /* Check the return type. */
8145 if (for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited,
8146 pfd->include_nondeduced_p))
8147 return error_mark_node;
8149 /* Check the parameter types. Since default arguments are not
8150 instantiated until they are needed, the TYPE_ARG_TYPES may
8151 contain expressions that involve template parameters. But,
8152 no-one should be looking at them yet. And, once they're
8153 instantiated, they don't contain template parameters, so
8154 there's no point in looking at them then, either. */
8158 for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm))
8159 if (for_each_template_parm (TREE_VALUE (parm), fn, data,
8160 pfd->visited, pfd->include_nondeduced_p))
8161 return error_mark_node;
8163 /* Since we've already handled the TYPE_ARG_TYPES, we don't
8164 want walk_tree walking into them itself. */
8170 case UNDERLYING_TYPE:
8171 if (pfd->include_nondeduced_p
8172 && for_each_template_parm (TYPE_FIELDS (t), fn, data,
8174 pfd->include_nondeduced_p))
8175 return error_mark_node;
8180 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
8181 && for_each_template_parm (DECL_TI_ARGS (t), fn, data,
8182 pfd->visited, pfd->include_nondeduced_p))
8183 return error_mark_node;
8188 if (TREE_CODE (t) == CONST_DECL && DECL_TEMPLATE_PARM_P (t)
8189 && for_each_template_parm (DECL_INITIAL (t), fn, data,
8190 pfd->visited, pfd->include_nondeduced_p))
8191 return error_mark_node;
8192 if (DECL_CONTEXT (t)
8193 && pfd->include_nondeduced_p
8194 && for_each_template_parm (DECL_CONTEXT (t), fn, data,
8195 pfd->visited, pfd->include_nondeduced_p))
8196 return error_mark_node;
8199 case BOUND_TEMPLATE_TEMPLATE_PARM:
8200 /* Record template parameters such as `T' inside `TT<T>'. */
8201 if (for_each_template_parm (TYPE_TI_ARGS (t), fn, data, pfd->visited,
8202 pfd->include_nondeduced_p))
8203 return error_mark_node;
8206 case TEMPLATE_TEMPLATE_PARM:
8207 case TEMPLATE_TYPE_PARM:
8208 case TEMPLATE_PARM_INDEX:
8209 if (fn && (*fn)(t, data))
8210 return error_mark_node;
8212 return error_mark_node;
8216 /* A template template parameter is encountered. */
8217 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)
8218 && for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited,
8219 pfd->include_nondeduced_p))
8220 return error_mark_node;
8222 /* Already substituted template template parameter */
8228 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t), fn,
8230 pfd->include_nondeduced_p))
8231 return error_mark_node;
8235 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))
8236 && pfd->include_nondeduced_p
8237 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
8238 (TREE_TYPE (t)), fn, data,
8239 pfd->visited, pfd->include_nondeduced_p))
8240 return error_mark_node;
8245 /* If there's no type, then this thing must be some expression
8246 involving template parameters. */
8247 if (!fn && !TREE_TYPE (t))
8248 return error_mark_node;
8253 case IMPLICIT_CONV_EXPR:
8254 case REINTERPRET_CAST_EXPR:
8255 case CONST_CAST_EXPR:
8256 case STATIC_CAST_EXPR:
8257 case DYNAMIC_CAST_EXPR:
8261 case PSEUDO_DTOR_EXPR:
8263 return error_mark_node;
8270 /* We didn't find any template parameters we liked. */
8274 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
8275 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
8276 call FN with the parameter and the DATA.
8277 If FN returns nonzero, the iteration is terminated, and
8278 for_each_template_parm returns 1. Otherwise, the iteration
8279 continues. If FN never returns a nonzero value, the value
8280 returned by for_each_template_parm is 0. If FN is NULL, it is
8281 considered to be the function which always returns 1.
8283 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
8284 parameters that occur in non-deduced contexts. When false, only
8285 visits those template parameters that can be deduced. */
8288 for_each_template_parm (tree t, tree_fn_t fn, void* data,
8289 hash_set<tree> *visited,
8290 bool include_nondeduced_p)
8292 struct pair_fn_data pfd;
8298 pfd.include_nondeduced_p = include_nondeduced_p;
8300 /* Walk the tree. (Conceptually, we would like to walk without
8301 duplicates, but for_each_template_parm_r recursively calls
8302 for_each_template_parm, so we would need to reorganize a fair
8303 bit to use walk_tree_without_duplicates, so we keep our own
8306 pfd.visited = visited;
8308 pfd.visited = new hash_set<tree>;
8309 result = cp_walk_tree (&t,
8310 for_each_template_parm_r,
8312 pfd.visited) != NULL_TREE;
8324 /* Returns true if T depends on any template parameter. */
8327 uses_template_parms (tree t)
8333 int saved_processing_template_decl;
8335 saved_processing_template_decl = processing_template_decl;
8336 if (!saved_processing_template_decl)
8337 processing_template_decl = 1;
8339 dependent_p = dependent_type_p (t);
8340 else if (TREE_CODE (t) == TREE_VEC)
8341 dependent_p = any_dependent_template_arguments_p (t);
8342 else if (TREE_CODE (t) == TREE_LIST)
8343 dependent_p = (uses_template_parms (TREE_VALUE (t))
8344 || uses_template_parms (TREE_CHAIN (t)));
8345 else if (TREE_CODE (t) == TYPE_DECL)
8346 dependent_p = dependent_type_p (TREE_TYPE (t));
8349 || TREE_CODE (t) == TEMPLATE_PARM_INDEX
8350 || TREE_CODE (t) == OVERLOAD
8353 || TREE_CODE (t) == TRAIT_EXPR
8354 || TREE_CODE (t) == CONSTRUCTOR
8355 || CONSTANT_CLASS_P (t))
8356 dependent_p = (type_dependent_expression_p (t)
8357 || value_dependent_expression_p (t));
8360 gcc_assert (t == error_mark_node);
8361 dependent_p = false;
8364 processing_template_decl = saved_processing_template_decl;
8369 /* Returns true iff current_function_decl is an incompletely instantiated
8370 template. Useful instead of processing_template_decl because the latter
8371 is set to 0 during instantiate_non_dependent_expr. */
8374 in_template_function (void)
8376 tree fn = current_function_decl;
8378 ++processing_template_decl;
8379 ret = (fn && DECL_LANG_SPECIFIC (fn)
8380 && DECL_TEMPLATE_INFO (fn)
8381 && any_dependent_template_arguments_p (DECL_TI_ARGS (fn)));
8382 --processing_template_decl;
8386 /* Returns true if T depends on any template parameter with level LEVEL. */
8389 uses_template_parms_level (tree t, int level)
8391 return for_each_template_parm (t, template_parm_this_level_p, &level, NULL,
8392 /*include_nondeduced_p=*/true);
8395 /* Returns TRUE iff INST is an instantiation we don't need to do in an
8396 ill-formed translation unit, i.e. a variable or function that isn't
8397 usable in a constant expression. */
8400 neglectable_inst_p (tree d)
8403 && !(TREE_CODE (d) == FUNCTION_DECL ? DECL_DECLARED_CONSTEXPR_P (d)
8404 : decl_maybe_constant_var_p (d)));
8407 /* Returns TRUE iff we should refuse to instantiate DECL because it's
8408 neglectable and instantiated from within an erroneous instantiation. */
8411 limit_bad_template_recursion (tree decl)
8413 struct tinst_level *lev = current_tinst_level;
8414 int errs = errorcount + sorrycount;
8415 if (lev == NULL || errs == 0 || !neglectable_inst_p (decl))
8418 for (; lev; lev = lev->next)
8419 if (neglectable_inst_p (lev->decl))
8422 return (lev && errs > lev->errors);
8425 static int tinst_depth;
8426 extern int max_tinst_depth;
8429 static GTY(()) struct tinst_level *last_error_tinst_level;
8431 /* We're starting to instantiate D; record the template instantiation context
8432 for diagnostics and to restore it later. */
8435 push_tinst_level (tree d)
8437 return push_tinst_level_loc (d, input_location);
8440 /* We're starting to instantiate D; record the template instantiation context
8441 at LOC for diagnostics and to restore it later. */
8444 push_tinst_level_loc (tree d, location_t loc)
8446 struct tinst_level *new_level;
8448 if (tinst_depth >= max_tinst_depth)
8450 fatal_error (input_location,
8451 "template instantiation depth exceeds maximum of %d"
8452 " (use -ftemplate-depth= to increase the maximum)",
8457 /* If the current instantiation caused problems, don't let it instantiate
8458 anything else. Do allow deduction substitution and decls usable in
8459 constant expressions. */
8460 if (limit_bad_template_recursion (d))
8463 new_level = ggc_alloc<tinst_level> ();
8464 new_level->decl = d;
8465 new_level->locus = loc;
8466 new_level->errors = errorcount+sorrycount;
8467 new_level->in_system_header_p = in_system_header_at (input_location);
8468 new_level->next = current_tinst_level;
8469 current_tinst_level = new_level;
8472 if (GATHER_STATISTICS && (tinst_depth > depth_reached))
8473 depth_reached = tinst_depth;
8478 /* We're done instantiating this template; return to the instantiation
8482 pop_tinst_level (void)
8484 /* Restore the filename and line number stashed away when we started
8485 this instantiation. */
8486 input_location = current_tinst_level->locus;
8487 current_tinst_level = current_tinst_level->next;
8491 /* We're instantiating a deferred template; restore the template
8492 instantiation context in which the instantiation was requested, which
8493 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
8496 reopen_tinst_level (struct tinst_level *level)
8498 struct tinst_level *t;
8501 for (t = level; t; t = t->next)
8504 current_tinst_level = level;
8506 if (current_tinst_level)
8507 current_tinst_level->errors = errorcount+sorrycount;
8511 /* Returns the TINST_LEVEL which gives the original instantiation
8514 struct tinst_level *
8515 outermost_tinst_level (void)
8517 struct tinst_level *level = current_tinst_level;
8520 level = level->next;
8524 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
8525 vector of template arguments, as for tsubst.
8527 Returns an appropriate tsubst'd friend declaration. */
8530 tsubst_friend_function (tree decl, tree args)
8534 if (TREE_CODE (decl) == FUNCTION_DECL
8535 && DECL_TEMPLATE_INSTANTIATION (decl)
8536 && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
8537 /* This was a friend declared with an explicit template
8538 argument list, e.g.:
8542 to indicate that f was a template instantiation, not a new
8543 function declaration. Now, we have to figure out what
8544 instantiation of what template. */
8546 tree template_id, arglist, fns;
8549 tree ns = decl_namespace_context (TYPE_MAIN_DECL (current_class_type));
8551 /* Friend functions are looked up in the containing namespace scope.
8552 We must enter that scope, to avoid finding member functions of the
8553 current class with same name. */
8554 push_nested_namespace (ns);
8555 fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args,
8556 tf_warning_or_error, NULL_TREE,
8557 /*integral_constant_expression_p=*/false);
8558 pop_nested_namespace (ns);
8559 arglist = tsubst (DECL_TI_ARGS (decl), args,
8560 tf_warning_or_error, NULL_TREE);
8561 template_id = lookup_template_function (fns, arglist);
8563 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
8564 tmpl = determine_specialization (template_id, new_friend,
8566 /*need_member_template=*/0,
8567 TREE_VEC_LENGTH (args),
8569 return instantiate_template (tmpl, new_args, tf_error);
8572 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
8574 /* The NEW_FRIEND will look like an instantiation, to the
8575 compiler, but is not an instantiation from the point of view of
8576 the language. For example, we might have had:
8578 template <class T> struct S {
8579 template <class U> friend void f(T, U);
8582 Then, in S<int>, template <class U> void f(int, U) is not an
8583 instantiation of anything. */
8584 if (new_friend == error_mark_node)
8585 return error_mark_node;
8587 DECL_USE_TEMPLATE (new_friend) = 0;
8588 if (TREE_CODE (decl) == TEMPLATE_DECL)
8590 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0;
8591 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend))
8592 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
8595 /* The mangled name for the NEW_FRIEND is incorrect. The function
8596 is not a template instantiation and should not be mangled like
8597 one. Therefore, we forget the mangling here; we'll recompute it
8598 later if we need it. */
8599 if (TREE_CODE (new_friend) != TEMPLATE_DECL)
8601 SET_DECL_RTL (new_friend, NULL);
8602 SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE);
8605 if (DECL_NAMESPACE_SCOPE_P (new_friend))
8608 tree new_friend_template_info;
8609 tree new_friend_result_template_info;
8611 int new_friend_is_defn;
8613 /* We must save some information from NEW_FRIEND before calling
8614 duplicate decls since that function will free NEW_FRIEND if
8616 new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
8617 new_friend_is_defn =
8618 (DECL_INITIAL (DECL_TEMPLATE_RESULT
8619 (template_for_substitution (new_friend)))
8621 if (TREE_CODE (new_friend) == TEMPLATE_DECL)
8623 /* This declaration is a `primary' template. */
8624 DECL_PRIMARY_TEMPLATE (new_friend) = new_friend;
8626 new_friend_result_template_info
8627 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend));
8630 new_friend_result_template_info = NULL_TREE;
8632 /* Make the init_value nonzero so pushdecl knows this is a defn. */
8633 if (new_friend_is_defn)
8634 DECL_INITIAL (new_friend) = error_mark_node;
8636 /* Inside pushdecl_namespace_level, we will push into the
8637 current namespace. However, the friend function should go
8638 into the namespace of the template. */
8639 ns = decl_namespace_context (new_friend);
8640 push_nested_namespace (ns);
8641 old_decl = pushdecl_namespace_level (new_friend, /*is_friend=*/true);
8642 pop_nested_namespace (ns);
8644 if (old_decl == error_mark_node)
8645 return error_mark_node;
8647 if (old_decl != new_friend)
8649 /* This new friend declaration matched an existing
8650 declaration. For example, given:
8652 template <class T> void f(T);
8653 template <class U> class C {
8654 template <class T> friend void f(T) {}
8657 the friend declaration actually provides the definition
8658 of `f', once C has been instantiated for some type. So,
8659 old_decl will be the out-of-class template declaration,
8660 while new_friend is the in-class definition.
8662 But, if `f' was called before this point, the
8663 instantiation of `f' will have DECL_TI_ARGS corresponding
8664 to `T' but not to `U', references to which might appear
8665 in the definition of `f'. Previously, the most general
8666 template for an instantiation of `f' was the out-of-class
8667 version; now it is the in-class version. Therefore, we
8668 run through all specialization of `f', adding to their
8669 DECL_TI_ARGS appropriately. In particular, they need a
8670 new set of outer arguments, corresponding to the
8671 arguments for this class instantiation.
8673 The same situation can arise with something like this:
8676 template <class T> class C {
8680 when `C<int>' is instantiated. Now, `f(int)' is defined
8683 if (!new_friend_is_defn)
8684 /* On the other hand, if the in-class declaration does
8685 *not* provide a definition, then we don't want to alter
8686 existing definitions. We can just leave everything
8691 tree new_template = TI_TEMPLATE (new_friend_template_info);
8692 tree new_args = TI_ARGS (new_friend_template_info);
8694 /* Overwrite whatever template info was there before, if
8695 any, with the new template information pertaining to
8697 DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
8699 if (TREE_CODE (old_decl) != TEMPLATE_DECL)
8701 /* We should have called reregister_specialization in
8703 gcc_assert (retrieve_specialization (new_template,
8707 /* Instantiate it if the global has already been used. */
8708 if (DECL_ODR_USED (old_decl))
8709 instantiate_decl (old_decl, /*defer_ok=*/true,
8710 /*expl_inst_class_mem_p=*/false);
8716 /* Indicate that the old function template is a partial
8718 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl))
8719 = new_friend_result_template_info;
8721 gcc_assert (new_template
8722 == most_general_template (new_template));
8723 gcc_assert (new_template != old_decl);
8725 /* Reassign any specializations already in the hash table
8726 to the new more general template, and add the
8727 additional template args. */
8728 for (t = DECL_TEMPLATE_INSTANTIATIONS (old_decl);
8732 tree spec = TREE_VALUE (t);
8735 elt.tmpl = old_decl;
8736 elt.args = DECL_TI_ARGS (spec);
8737 elt.spec = NULL_TREE;
8739 decl_specializations->remove_elt (&elt);
8742 = add_outermost_template_args (new_args,
8743 DECL_TI_ARGS (spec));
8745 register_specialization
8746 (spec, new_template, DECL_TI_ARGS (spec), true, 0);
8749 DECL_TEMPLATE_INSTANTIATIONS (old_decl) = NULL_TREE;
8753 /* The information from NEW_FRIEND has been merged into OLD_DECL
8754 by duplicate_decls. */
8755 new_friend = old_decl;
8760 tree context = DECL_CONTEXT (new_friend);
8764 template <class T> class C {
8765 template <class U> friend void C1<U>::f (); // case 1
8766 friend void C2<T>::f (); // case 2
8768 we only need to make sure CONTEXT is a complete type for
8769 case 2. To distinguish between the two cases, we note that
8770 CONTEXT of case 1 remains dependent type after tsubst while
8771 this isn't true for case 2. */
8772 ++processing_template_decl;
8773 dependent_p = dependent_type_p (context);
8774 --processing_template_decl;
8777 && !complete_type_or_else (context, NULL_TREE))
8778 return error_mark_node;
8780 if (COMPLETE_TYPE_P (context))
8782 tree fn = new_friend;
8783 /* do_friend adds the TEMPLATE_DECL for any member friend
8784 template even if it isn't a member template, i.e.
8785 template <class T> friend A<T>::f();
8786 Look through it in that case. */
8787 if (TREE_CODE (fn) == TEMPLATE_DECL
8788 && !PRIMARY_TEMPLATE_P (fn))
8789 fn = DECL_TEMPLATE_RESULT (fn);
8790 /* Check to see that the declaration is really present, and,
8791 possibly obtain an improved declaration. */
8792 fn = check_classfn (context, fn, NULL_TREE);
8802 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
8803 template arguments, as for tsubst.
8805 Returns an appropriate tsubst'd friend type or error_mark_node on
8809 tsubst_friend_class (tree friend_tmpl, tree args)
8815 if (DECL_TEMPLATE_TEMPLATE_PARM_P (friend_tmpl))
8817 tree t = tsubst (TREE_TYPE (friend_tmpl), args, tf_none, NULL_TREE);
8818 return TREE_TYPE (t);
8821 context = CP_DECL_CONTEXT (friend_tmpl);
8823 if (context != global_namespace)
8825 if (TREE_CODE (context) == NAMESPACE_DECL)
8826 push_nested_namespace (context);
8828 push_nested_class (tsubst (context, args, tf_none, NULL_TREE));
8831 /* Look for a class template declaration. We look for hidden names
8832 because two friend declarations of the same template are the
8833 same. For example, in:
8836 template <typename> friend class F;
8838 template <typename> struct B {
8839 template <typename> friend class F;
8842 both F templates are the same. */
8843 tmpl = lookup_name_real (DECL_NAME (friend_tmpl), 0, 0,
8844 /*block_p=*/true, 0, LOOKUP_HIDDEN);
8846 /* But, if we don't find one, it might be because we're in a
8847 situation like this:
8855 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
8856 for `S<int>', not the TEMPLATE_DECL. */
8857 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
8859 tmpl = lookup_name_prefer_type (DECL_NAME (friend_tmpl), 1);
8860 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
8863 if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
8865 /* The friend template has already been declared. Just
8866 check to see that the declarations match, and install any new
8867 default parameters. We must tsubst the default parameters,
8868 of course. We only need the innermost template parameters
8869 because that is all that redeclare_class_template will look
8871 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl))
8872 > TMPL_ARGS_DEPTH (args))
8875 location_t saved_input_location;
8876 parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
8877 args, tf_warning_or_error);
8879 saved_input_location = input_location;
8880 input_location = DECL_SOURCE_LOCATION (friend_tmpl);
8881 redeclare_class_template (TREE_TYPE (tmpl), parms);
8882 input_location = saved_input_location;
8886 friend_type = TREE_TYPE (tmpl);
8890 /* The friend template has not already been declared. In this
8891 case, the instantiation of the template class will cause the
8892 injection of this template into the global scope. */
8893 tmpl = tsubst (friend_tmpl, args, tf_warning_or_error, NULL_TREE);
8894 if (tmpl == error_mark_node)
8895 return error_mark_node;
8897 /* The new TMPL is not an instantiation of anything, so we
8898 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
8899 the new type because that is supposed to be the corresponding
8900 template decl, i.e., TMPL. */
8901 DECL_USE_TEMPLATE (tmpl) = 0;
8902 DECL_TEMPLATE_INFO (tmpl) = NULL_TREE;
8903 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0;
8904 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl))
8905 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)));
8907 /* Inject this template into the global scope. */
8908 friend_type = TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl, true));
8911 if (context != global_namespace)
8913 if (TREE_CODE (context) == NAMESPACE_DECL)
8914 pop_nested_namespace (context);
8916 pop_nested_class ();
8922 /* Returns zero if TYPE cannot be completed later due to circularity.
8923 Otherwise returns one. */
8926 can_complete_type_without_circularity (tree type)
8928 if (type == NULL_TREE || type == error_mark_node)
8930 else if (COMPLETE_TYPE_P (type))
8932 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
8933 return can_complete_type_without_circularity (TREE_TYPE (type));
8934 else if (CLASS_TYPE_P (type)
8935 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type)))
8941 static tree tsubst_omp_clauses (tree, bool, tree, tsubst_flags_t, tree);
8943 /* Apply any attributes which had to be deferred until instantiation
8944 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
8945 ARGS, COMPLAIN, IN_DECL are as tsubst. */
8948 apply_late_template_attributes (tree *decl_p, tree attributes, int attr_flags,
8949 tree args, tsubst_flags_t complain, tree in_decl)
8951 tree last_dep = NULL_TREE;
8955 for (t = attributes; t; t = TREE_CHAIN (t))
8956 if (ATTR_IS_DEPENDENT (t))
8959 attributes = copy_list (attributes);
8963 if (DECL_P (*decl_p))
8965 if (TREE_TYPE (*decl_p) == error_mark_node)
8967 p = &DECL_ATTRIBUTES (*decl_p);
8970 p = &TYPE_ATTRIBUTES (*decl_p);
8974 tree late_attrs = NULL_TREE;
8975 tree *q = &late_attrs;
8977 for (*p = attributes; *p; )
8980 if (ATTR_IS_DEPENDENT (t))
8982 *p = TREE_CHAIN (t);
8983 TREE_CHAIN (t) = NULL_TREE;
8984 if ((flag_openmp || flag_cilkplus)
8985 && is_attribute_p ("omp declare simd",
8986 get_attribute_name (t))
8989 tree clauses = TREE_VALUE (TREE_VALUE (t));
8990 clauses = tsubst_omp_clauses (clauses, true, args,
8992 c_omp_declare_simd_clauses_to_decls (*decl_p, clauses);
8993 clauses = finish_omp_clauses (clauses);
8994 tree parms = DECL_ARGUMENTS (*decl_p);
8996 = c_omp_declare_simd_clauses_to_numbers (parms, clauses);
8998 TREE_VALUE (TREE_VALUE (t)) = clauses;
9000 TREE_VALUE (t) = NULL_TREE;
9002 /* If the first attribute argument is an identifier, don't
9003 pass it through tsubst. Attributes like mode, format,
9004 cleanup and several target specific attributes expect it
9006 else if (attribute_takes_identifier_p (get_attribute_name (t))
9010 = tsubst_expr (TREE_CHAIN (TREE_VALUE (t)), args, complain,
9012 /*integral_constant_expression_p=*/false);
9013 if (chain != TREE_CHAIN (TREE_VALUE (t)))
9015 = tree_cons (NULL_TREE, TREE_VALUE (TREE_VALUE (t)),
9020 = tsubst_expr (TREE_VALUE (t), args, complain, in_decl,
9021 /*integral_constant_expression_p=*/false);
9023 q = &TREE_CHAIN (t);
9026 p = &TREE_CHAIN (t);
9029 cplus_decl_attributes (decl_p, late_attrs, attr_flags);
9033 /* Perform (or defer) access check for typedefs that were referenced
9034 from within the template TMPL code.
9035 This is a subroutine of instantiate_decl and instantiate_class_template.
9036 TMPL is the template to consider and TARGS is the list of arguments of
9040 perform_typedefs_access_check (tree tmpl, tree targs)
9042 location_t saved_location;
9044 qualified_typedef_usage_t *iter;
9047 || (!CLASS_TYPE_P (tmpl)
9048 && TREE_CODE (tmpl) != FUNCTION_DECL))
9051 saved_location = input_location;
9052 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (tmpl), i, iter)
9054 tree type_decl = iter->typedef_decl;
9055 tree type_scope = iter->context;
9057 if (!type_decl || !type_scope || !CLASS_TYPE_P (type_scope))
9060 if (uses_template_parms (type_decl))
9061 type_decl = tsubst (type_decl, targs, tf_error, NULL_TREE);
9062 if (uses_template_parms (type_scope))
9063 type_scope = tsubst (type_scope, targs, tf_error, NULL_TREE);
9065 /* Make access check error messages point to the location
9066 of the use of the typedef. */
9067 input_location = iter->locus;
9068 perform_or_defer_access_check (TYPE_BINFO (type_scope),
9069 type_decl, type_decl,
9070 tf_warning_or_error);
9072 input_location = saved_location;
9076 instantiate_class_template_1 (tree type)
9078 tree templ, args, pattern, t, member;
9082 unsigned int saved_maximum_field_alignment;
9085 if (type == error_mark_node)
9086 return error_mark_node;
9088 if (COMPLETE_OR_OPEN_TYPE_P (type)
9089 || uses_template_parms (type))
9092 /* Figure out which template is being instantiated. */
9093 templ = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
9094 gcc_assert (TREE_CODE (templ) == TEMPLATE_DECL);
9096 /* Determine what specialization of the original template to
9098 t = most_specialized_partial_spec (type, tf_warning_or_error);
9099 if (t == error_mark_node)
9101 TYPE_BEING_DEFINED (type) = 1;
9102 return error_mark_node;
9106 /* This TYPE is actually an instantiation of a partial
9107 specialization. We replace the innermost set of ARGS with
9108 the arguments appropriate for substitution. For example,
9111 template <class T> struct S {};
9112 template <class T> struct S<T*> {};
9114 and supposing that we are instantiating S<int*>, ARGS will
9115 presently be {int*} -- but we need {int}. */
9116 pattern = TREE_TYPE (t);
9117 args = TREE_PURPOSE (t);
9121 pattern = TREE_TYPE (templ);
9122 args = CLASSTYPE_TI_ARGS (type);
9125 /* If the template we're instantiating is incomplete, then clearly
9126 there's nothing we can do. */
9127 if (!COMPLETE_TYPE_P (pattern))
9130 /* If we've recursively instantiated too many templates, stop. */
9131 if (! push_tinst_level (type))
9134 /* Now we're really doing the instantiation. Mark the type as in
9135 the process of being defined. */
9136 TYPE_BEING_DEFINED (type) = 1;
9138 /* We may be in the middle of deferred access check. Disable
9140 push_deferring_access_checks (dk_no_deferred);
9142 fn_context = decl_function_context (TYPE_MAIN_DECL (type));
9143 /* Also avoid push_to_top_level for a lambda in an NSDMI. */
9144 if (!fn_context && LAMBDA_TYPE_P (type) && TYPE_CLASS_SCOPE_P (type))
9145 fn_context = error_mark_node;
9147 push_to_top_level ();
9148 /* Use #pragma pack from the template context. */
9149 saved_maximum_field_alignment = maximum_field_alignment;
9150 maximum_field_alignment = TYPE_PRECISION (pattern);
9152 SET_CLASSTYPE_INTERFACE_UNKNOWN (type);
9154 /* Set the input location to the most specialized template definition.
9155 This is needed if tsubsting causes an error. */
9156 typedecl = TYPE_MAIN_DECL (pattern);
9157 input_location = DECL_SOURCE_LOCATION (TYPE_NAME (type)) =
9158 DECL_SOURCE_LOCATION (typedecl);
9160 TYPE_PACKED (type) = TYPE_PACKED (pattern);
9161 TYPE_ALIGN (type) = TYPE_ALIGN (pattern);
9162 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);
9163 TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */
9164 if (ANON_AGGR_TYPE_P (pattern))
9165 SET_ANON_AGGR_TYPE_P (type);
9166 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern))
9168 CLASSTYPE_VISIBILITY_SPECIFIED (type) = 1;
9169 CLASSTYPE_VISIBILITY (type) = CLASSTYPE_VISIBILITY (pattern);
9170 /* Adjust visibility for template arguments. */
9171 determine_visibility (TYPE_MAIN_DECL (type));
9173 if (CLASS_TYPE_P (type))
9174 CLASSTYPE_FINAL (type) = CLASSTYPE_FINAL (pattern);
9176 pbinfo = TYPE_BINFO (pattern);
9178 /* We should never instantiate a nested class before its enclosing
9179 class; we need to look up the nested class by name before we can
9180 instantiate it, and that lookup should instantiate the enclosing
9182 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))
9183 || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type)));
9185 base_list = NULL_TREE;
9186 if (BINFO_N_BASE_BINFOS (pbinfo))
9192 /* We must enter the scope containing the type, as that is where
9193 the accessibility of types named in dependent bases are
9195 pushed_scope = push_scope (CP_TYPE_CONTEXT (type));
9197 /* Substitute into each of the bases to determine the actual
9199 for (i = 0; BINFO_BASE_ITERATE (pbinfo, i, pbase_binfo); i++)
9202 tree access = BINFO_BASE_ACCESS (pbinfo, i);
9203 tree expanded_bases = NULL_TREE;
9206 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo)))
9209 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo),
9210 args, tf_error, NULL_TREE);
9211 if (expanded_bases == error_mark_node)
9214 len = TREE_VEC_LENGTH (expanded_bases);
9217 for (idx = 0; idx < len; idx++)
9220 /* Extract the already-expanded base class. */
9221 base = TREE_VEC_ELT (expanded_bases, idx);
9223 /* Substitute to figure out the base class. */
9224 base = tsubst (BINFO_TYPE (pbase_binfo), args, tf_error,
9227 if (base == error_mark_node)
9230 base_list = tree_cons (access, base, base_list);
9231 if (BINFO_VIRTUAL_P (pbase_binfo))
9232 TREE_TYPE (base_list) = integer_type_node;
9236 /* The list is now in reverse order; correct that. */
9237 base_list = nreverse (base_list);
9240 pop_scope (pushed_scope);
9242 /* Now call xref_basetypes to set up all the base-class
9244 xref_basetypes (type, base_list);
9246 apply_late_template_attributes (&type, TYPE_ATTRIBUTES (pattern),
9247 (int) ATTR_FLAG_TYPE_IN_PLACE,
9248 args, tf_error, NULL_TREE);
9249 fixup_attribute_variants (type);
9251 /* Now that our base classes are set up, enter the scope of the
9252 class, so that name lookups into base classes, etc. will work
9253 correctly. This is precisely analogous to what we do in
9254 begin_class_definition when defining an ordinary non-template
9255 class, except we also need to push the enclosing classes. */
9256 push_nested_class (type);
9258 /* Now members are processed in the order of declaration. */
9259 for (member = CLASSTYPE_DECL_LIST (pattern);
9260 member; member = TREE_CHAIN (member))
9262 tree t = TREE_VALUE (member);
9264 if (TREE_PURPOSE (member))
9268 /* Build new CLASSTYPE_NESTED_UTDS. */
9271 bool class_template_p;
9273 class_template_p = (TREE_CODE (t) != ENUMERAL_TYPE
9274 && TYPE_LANG_SPECIFIC (t)
9275 && CLASSTYPE_IS_TEMPLATE (t));
9276 /* If the member is a class template, then -- even after
9277 substitution -- there may be dependent types in the
9278 template argument list for the class. We increment
9279 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
9280 that function will assume that no types are dependent
9281 when outside of a template. */
9282 if (class_template_p)
9283 ++processing_template_decl;
9284 newtag = tsubst (t, args, tf_error, NULL_TREE);
9285 if (class_template_p)
9286 --processing_template_decl;
9287 if (newtag == error_mark_node)
9290 if (TREE_CODE (newtag) != ENUMERAL_TYPE)
9292 tree name = TYPE_IDENTIFIER (t);
9294 if (class_template_p)
9295 /* Unfortunately, lookup_template_class sets
9296 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
9297 instantiation (i.e., for the type of a member
9298 template class nested within a template class.)
9299 This behavior is required for
9300 maybe_process_partial_specialization to work
9301 correctly, but is not accurate in this case;
9302 the TAG is not an instantiation of anything.
9303 (The corresponding TEMPLATE_DECL is an
9304 instantiation, but the TYPE is not.) */
9305 CLASSTYPE_USE_TEMPLATE (newtag) = 0;
9307 /* Now, we call pushtag to put this NEWTAG into the scope of
9308 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
9309 pushtag calling push_template_decl. We don't have to do
9310 this for enums because it will already have been done in
9313 SET_IDENTIFIER_TYPE_VALUE (name, newtag);
9314 pushtag (name, newtag, /*tag_scope=*/ts_current);
9317 else if (DECL_DECLARES_FUNCTION_P (t))
9319 /* Build new TYPE_METHODS. */
9322 if (TREE_CODE (t) == TEMPLATE_DECL)
9323 ++processing_template_decl;
9324 r = tsubst (t, args, tf_error, NULL_TREE);
9325 if (TREE_CODE (t) == TEMPLATE_DECL)
9326 --processing_template_decl;
9327 set_current_access_from_decl (r);
9328 finish_member_declaration (r);
9329 /* Instantiate members marked with attribute used. */
9330 if (r != error_mark_node && DECL_PRESERVE_P (r))
9332 if (TREE_CODE (r) == FUNCTION_DECL
9333 && DECL_OMP_DECLARE_REDUCTION_P (r))
9334 cp_check_omp_declare_reduction (r);
9336 else if (DECL_CLASS_TEMPLATE_P (t)
9337 && LAMBDA_TYPE_P (TREE_TYPE (t)))
9338 /* A closure type for a lambda in a default argument for a
9339 member template. Ignore it; it will be instantiated with
9340 the default argument. */;
9343 /* Build new TYPE_FIELDS. */
9344 if (TREE_CODE (t) == STATIC_ASSERT)
9348 ++c_inhibit_evaluation_warnings;
9350 tsubst_expr (STATIC_ASSERT_CONDITION (t), args,
9351 tf_warning_or_error, NULL_TREE,
9352 /*integral_constant_expression_p=*/true);
9353 --c_inhibit_evaluation_warnings;
9355 finish_static_assert (condition,
9356 STATIC_ASSERT_MESSAGE (t),
9357 STATIC_ASSERT_SOURCE_LOCATION (t),
9360 else if (TREE_CODE (t) != CONST_DECL)
9363 tree vec = NULL_TREE;
9366 /* The file and line for this declaration, to
9367 assist in error message reporting. Since we
9368 called push_tinst_level above, we don't need to
9370 input_location = DECL_SOURCE_LOCATION (t);
9372 if (TREE_CODE (t) == TEMPLATE_DECL)
9373 ++processing_template_decl;
9374 r = tsubst (t, args, tf_warning_or_error, NULL_TREE);
9375 if (TREE_CODE (t) == TEMPLATE_DECL)
9376 --processing_template_decl;
9378 if (TREE_CODE (r) == TREE_VEC)
9380 /* A capture pack became multiple fields. */
9382 len = TREE_VEC_LENGTH (vec);
9385 for (int i = 0; i < len; ++i)
9388 r = TREE_VEC_ELT (vec, i);
9393 [t]he initialization (and any associated
9394 side-effects) of a static data member does
9395 not occur unless the static data member is
9396 itself used in a way that requires the
9397 definition of the static data member to
9400 Therefore, we do not substitute into the
9401 initialized for the static data member here. */
9402 finish_static_data_member_decl
9405 /*init_const_expr_p=*/false,
9406 /*asmspec_tree=*/NULL_TREE,
9408 /* Instantiate members marked with attribute used. */
9409 if (r != error_mark_node && DECL_PRESERVE_P (r))
9412 else if (TREE_CODE (r) == FIELD_DECL)
9414 /* Determine whether R has a valid type and can be
9415 completed later. If R is invalid, then its type
9416 is replaced by error_mark_node. */
9417 tree rtype = TREE_TYPE (r);
9418 if (can_complete_type_without_circularity (rtype))
9419 complete_type (rtype);
9421 if (!COMPLETE_TYPE_P (rtype))
9423 cxx_incomplete_type_error (r, rtype);
9424 TREE_TYPE (r) = error_mark_node;
9428 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
9429 such a thing will already have been added to the field
9430 list by tsubst_enum in finish_member_declaration in the
9431 CLASSTYPE_NESTED_UTDS case above. */
9432 if (!(TREE_CODE (r) == TYPE_DECL
9433 && TREE_CODE (TREE_TYPE (r)) == ENUMERAL_TYPE
9434 && DECL_ARTIFICIAL (r)))
9436 set_current_access_from_decl (r);
9437 finish_member_declaration (r);
9445 if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t)
9446 || DECL_TEMPLATE_TEMPLATE_PARM_P (t))
9448 /* Build new CLASSTYPE_FRIEND_CLASSES. */
9450 tree friend_type = t;
9451 bool adjust_processing_template_decl = false;
9453 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
9455 /* template <class T> friend class C; */
9456 friend_type = tsubst_friend_class (friend_type, args);
9457 adjust_processing_template_decl = true;
9459 else if (TREE_CODE (friend_type) == UNBOUND_CLASS_TEMPLATE)
9461 /* template <class T> friend class C::D; */
9462 friend_type = tsubst (friend_type, args,
9463 tf_warning_or_error, NULL_TREE);
9464 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
9465 friend_type = TREE_TYPE (friend_type);
9466 adjust_processing_template_decl = true;
9468 else if (TREE_CODE (friend_type) == TYPENAME_TYPE
9469 || TREE_CODE (friend_type) == TEMPLATE_TYPE_PARM)
9471 /* This could be either
9475 when dependent_type_p is false or
9477 template <class U> friend class T::C;
9480 friend_type = tsubst (friend_type, args,
9481 tf_warning_or_error, NULL_TREE);
9482 /* Bump processing_template_decl for correct
9483 dependent_type_p calculation. */
9484 ++processing_template_decl;
9485 if (dependent_type_p (friend_type))
9486 adjust_processing_template_decl = true;
9487 --processing_template_decl;
9489 else if (!CLASSTYPE_USE_TEMPLATE (friend_type)
9490 && hidden_name_p (TYPE_NAME (friend_type)))
9494 where C hasn't been declared yet. Let's lookup name
9495 from namespace scope directly, bypassing any name that
9496 come from dependent base class. */
9497 tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type));
9499 /* The call to xref_tag_from_type does injection for friend
9501 push_nested_namespace (ns);
9503 xref_tag_from_type (friend_type, NULL_TREE,
9504 /*tag_scope=*/ts_current);
9505 pop_nested_namespace (ns);
9507 else if (uses_template_parms (friend_type))
9508 /* friend class C<T>; */
9509 friend_type = tsubst (friend_type, args,
9510 tf_warning_or_error, NULL_TREE);
9515 where C is already declared or
9517 friend class C<int>;
9519 We don't have to do anything in these cases. */
9521 if (adjust_processing_template_decl)
9522 /* Trick make_friend_class into realizing that the friend
9523 we're adding is a template, not an ordinary class. It's
9524 important that we use make_friend_class since it will
9525 perform some error-checking and output cross-reference
9527 ++processing_template_decl;
9529 if (friend_type != error_mark_node)
9530 make_friend_class (type, friend_type, /*complain=*/false);
9532 if (adjust_processing_template_decl)
9533 --processing_template_decl;
9537 /* Build new DECL_FRIENDLIST. */
9540 /* The file and line for this declaration, to
9541 assist in error message reporting. Since we
9542 called push_tinst_level above, we don't need to
9544 input_location = DECL_SOURCE_LOCATION (t);
9546 if (TREE_CODE (t) == TEMPLATE_DECL)
9548 ++processing_template_decl;
9549 push_deferring_access_checks (dk_no_check);
9552 r = tsubst_friend_function (t, args);
9553 add_friend (type, r, /*complain=*/false);
9554 if (TREE_CODE (t) == TEMPLATE_DECL)
9556 pop_deferring_access_checks ();
9557 --processing_template_decl;
9563 if (tree expr = CLASSTYPE_LAMBDA_EXPR (type))
9565 tree decl = lambda_function (type);
9568 if (!DECL_TEMPLATE_INFO (decl)
9569 || DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (decl)) != decl)
9570 instantiate_decl (decl, false, false);
9572 /* We need to instantiate the capture list from the template
9573 after we've instantiated the closure members, but before we
9574 consider adding the conversion op. Also keep any captures
9575 that may have been added during instantiation of the op(). */
9576 tree tmpl_expr = CLASSTYPE_LAMBDA_EXPR (pattern);
9578 = tsubst_copy_and_build (LAMBDA_EXPR_CAPTURE_LIST (tmpl_expr),
9579 args, tf_warning_or_error, NULL_TREE,
9582 LAMBDA_EXPR_CAPTURE_LIST (expr)
9583 = chainon (tmpl_cap, nreverse (LAMBDA_EXPR_CAPTURE_LIST (expr)));
9585 maybe_add_lambda_conv_op (type);
9588 gcc_assert (errorcount);
9591 /* Set the file and line number information to whatever is given for
9592 the class itself. This puts error messages involving generated
9593 implicit functions at a predictable point, and the same point
9594 that would be used for non-template classes. */
9595 input_location = DECL_SOURCE_LOCATION (typedecl);
9597 unreverse_member_declarations (type);
9598 finish_struct_1 (type);
9599 TYPE_BEING_DEFINED (type) = 0;
9601 /* We don't instantiate default arguments for member functions. 14.7.1:
9603 The implicit instantiation of a class template specialization causes
9604 the implicit instantiation of the declarations, but not of the
9605 definitions or default arguments, of the class member functions,
9606 member classes, static data members and member templates.... */
9608 /* Some typedefs referenced from within the template code need to be access
9609 checked at template instantiation time, i.e now. These types were
9610 added to the template at parsing time. Let's get those and perform
9611 the access checks then. */
9612 perform_typedefs_access_check (pattern, args);
9613 perform_deferred_access_checks (tf_warning_or_error);
9614 pop_nested_class ();
9615 maximum_field_alignment = saved_maximum_field_alignment;
9617 pop_from_top_level ();
9618 pop_deferring_access_checks ();
9621 /* The vtable for a template class can be emitted in any translation
9622 unit in which the class is instantiated. When there is no key
9623 method, however, finish_struct_1 will already have added TYPE to
9624 the keyed_classes list. */
9625 if (TYPE_CONTAINS_VPTR_P (type) && CLASSTYPE_KEY_METHOD (type))
9626 keyed_classes = tree_cons (NULL_TREE, type, keyed_classes);
9631 /* Wrapper for instantiate_class_template_1. */
9634 instantiate_class_template (tree type)
9637 timevar_push (TV_TEMPLATE_INST);
9638 ret = instantiate_class_template_1 (type);
9639 timevar_pop (TV_TEMPLATE_INST);
9644 tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl)
9650 else if (TYPE_P (t))
9651 r = tsubst (t, args, complain, in_decl);
9654 if (!(complain & tf_warning))
9655 ++c_inhibit_evaluation_warnings;
9656 r = tsubst_expr (t, args, complain, in_decl,
9657 /*integral_constant_expression_p=*/true);
9658 if (!(complain & tf_warning))
9659 --c_inhibit_evaluation_warnings;
9664 /* Given a function parameter pack TMPL_PARM and some function parameters
9665 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
9666 and set *SPEC_P to point at the next point in the list. */
9669 extract_fnparm_pack (tree tmpl_parm, tree *spec_p)
9671 /* Collect all of the extra "packed" parameters into an
9675 tree argpack = make_node (NONTYPE_ARGUMENT_PACK);
9676 tree argtypepack = cxx_make_type (TYPE_ARGUMENT_PACK);
9677 tree spec_parm = *spec_p;
9680 for (len = 0; spec_parm; ++len, spec_parm = TREE_CHAIN (spec_parm))
9682 && !function_parameter_expanded_from_pack_p (spec_parm, tmpl_parm))
9685 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
9686 parmvec = make_tree_vec (len);
9687 parmtypevec = make_tree_vec (len);
9688 spec_parm = *spec_p;
9689 for (i = 0; i < len; i++, spec_parm = DECL_CHAIN (spec_parm))
9691 TREE_VEC_ELT (parmvec, i) = spec_parm;
9692 TREE_VEC_ELT (parmtypevec, i) = TREE_TYPE (spec_parm);
9695 /* Build the argument packs. */
9696 SET_ARGUMENT_PACK_ARGS (argpack, parmvec);
9697 SET_ARGUMENT_PACK_ARGS (argtypepack, parmtypevec);
9698 TREE_TYPE (argpack) = argtypepack;
9699 *spec_p = spec_parm;
9704 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
9705 NONTYPE_ARGUMENT_PACK. */
9708 make_fnparm_pack (tree spec_parm)
9710 return extract_fnparm_pack (NULL_TREE, &spec_parm);
9713 /* Return true iff the Ith element of the argument pack ARG_PACK is a
9717 argument_pack_element_is_expansion_p (tree arg_pack, int i)
9719 tree vec = ARGUMENT_PACK_ARGS (arg_pack);
9720 if (i >= TREE_VEC_LENGTH (vec))
9722 return PACK_EXPANSION_P (TREE_VEC_ELT (vec, i));
9726 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
9729 make_argument_pack_select (tree arg_pack, unsigned index)
9731 tree aps = make_node (ARGUMENT_PACK_SELECT);
9733 ARGUMENT_PACK_SELECT_FROM_PACK (aps) = arg_pack;
9734 ARGUMENT_PACK_SELECT_INDEX (aps) = index;
9739 /* This is a subroutine of tsubst_pack_expansion.
9741 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
9742 mechanism to store the (non complete list of) arguments of the
9743 substitution and return a non substituted pack expansion, in order
9744 to wait for when we have enough arguments to really perform the
9748 use_pack_expansion_extra_args_p (tree parm_packs,
9752 /* If one pack has an expansion and another pack has a normal
9753 argument or if one pack has an empty argument and an another
9754 one hasn't then tsubst_pack_expansion cannot perform the
9755 substitution and need to fall back on the
9756 PACK_EXPANSION_EXTRA mechanism. */
9757 if (parm_packs == NULL_TREE)
9759 else if (has_empty_arg)
9762 bool has_expansion_arg = false;
9763 for (int i = 0 ; i < arg_pack_len; ++i)
9765 bool has_non_expansion_arg = false;
9766 for (tree parm_pack = parm_packs;
9768 parm_pack = TREE_CHAIN (parm_pack))
9770 tree arg = TREE_VALUE (parm_pack);
9772 if (argument_pack_element_is_expansion_p (arg, i))
9773 has_expansion_arg = true;
9775 has_non_expansion_arg = true;
9778 if (has_expansion_arg && has_non_expansion_arg)
9784 /* [temp.variadic]/6 says that:
9786 The instantiation of a pack expansion [...]
9787 produces a list E1,E2, ..., En, where N is the number of elements
9788 in the pack expansion parameters.
9790 This subroutine of tsubst_pack_expansion produces one of these Ei.
9792 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
9793 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
9794 PATTERN, and each TREE_VALUE is its corresponding argument pack.
9795 INDEX is the index 'i' of the element Ei to produce. ARGS,
9796 COMPLAIN, and IN_DECL are the same parameters as for the
9797 tsubst_pack_expansion function.
9799 The function returns the resulting Ei upon successful completion,
9802 Note that this function possibly modifies the ARGS parameter, so
9803 it's the responsibility of the caller to restore it. */
9806 gen_elem_of_pack_expansion_instantiation (tree pattern,
9809 tree args /* This parm gets
9811 tsubst_flags_t complain,
9815 bool ith_elem_is_expansion = false;
9817 /* For each parameter pack, change the substitution of the parameter
9818 pack to the ith argument in its argument pack, then expand the
9820 for (tree pack = parm_packs; pack; pack = TREE_CHAIN (pack))
9822 tree parm = TREE_PURPOSE (pack);
9823 tree arg_pack = TREE_VALUE (pack);
9824 tree aps; /* instance of ARGUMENT_PACK_SELECT. */
9826 ith_elem_is_expansion |=
9827 argument_pack_element_is_expansion_p (arg_pack, index);
9829 /* Select the Ith argument from the pack. */
9830 if (TREE_CODE (parm) == PARM_DECL
9831 || TREE_CODE (parm) == FIELD_DECL)
9835 aps = make_argument_pack_select (arg_pack, index);
9837 register_local_specialization (aps, parm);
9840 aps = retrieve_local_specialization (parm);
9845 template_parm_level_and_index (parm, &level, &idx);
9849 aps = make_argument_pack_select (arg_pack, index);
9850 /* Update the corresponding argument. */
9851 TMPL_ARG (args, level, idx) = aps;
9854 /* Re-use the ARGUMENT_PACK_SELECT. */
9855 aps = TMPL_ARG (args, level, idx);
9857 ARGUMENT_PACK_SELECT_INDEX (aps) = index;
9860 /* Substitute into the PATTERN with the (possibly altered)
9862 if (pattern == in_decl)
9863 /* Expanding a fixed parameter pack from
9864 coerce_template_parameter_pack. */
9865 t = tsubst_decl (pattern, args, complain);
9866 else if (!TYPE_P (pattern))
9867 t = tsubst_expr (pattern, args, complain, in_decl,
9868 /*integral_constant_expression_p=*/false);
9870 t = tsubst (pattern, args, complain, in_decl);
9872 /* If the Ith argument pack element is a pack expansion, then
9873 the Ith element resulting from the substituting is going to
9874 be a pack expansion as well. */
9875 if (ith_elem_is_expansion)
9876 t = make_pack_expansion (t);
9881 /* Substitute ARGS into T, which is an pack expansion
9882 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
9883 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
9884 (if only a partial substitution could be performed) or
9885 ERROR_MARK_NODE if there was an error. */
9887 tsubst_pack_expansion (tree t, tree args, tsubst_flags_t complain,
9891 tree pack, packs = NULL_TREE;
9892 bool unsubstituted_packs = false;
9895 hash_map<tree, tree> *saved_local_specializations = NULL;
9896 bool need_local_specializations = false;
9899 gcc_assert (PACK_EXPANSION_P (t));
9900 pattern = PACK_EXPANSION_PATTERN (t);
9902 /* Add in any args remembered from an earlier partial instantiation. */
9903 args = add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (t), args);
9905 levels = TMPL_ARGS_DEPTH (args);
9907 /* Determine the argument packs that will instantiate the parameter
9908 packs used in the expansion expression. While we're at it,
9909 compute the number of arguments to be expanded and make sure it
9911 for (pack = PACK_EXPANSION_PARAMETER_PACKS (t); pack;
9912 pack = TREE_CHAIN (pack))
9914 tree parm_pack = TREE_VALUE (pack);
9915 tree arg_pack = NULL_TREE;
9916 tree orig_arg = NULL_TREE;
9919 if (TREE_CODE (parm_pack) == BASES)
9921 if (BASES_DIRECT (parm_pack))
9922 return calculate_direct_bases (tsubst_expr (BASES_TYPE (parm_pack),
9923 args, complain, in_decl, false));
9925 return calculate_bases (tsubst_expr (BASES_TYPE (parm_pack),
9926 args, complain, in_decl, false));
9928 if (TREE_CODE (parm_pack) == PARM_DECL)
9930 if (PACK_EXPANSION_LOCAL_P (t))
9931 arg_pack = retrieve_local_specialization (parm_pack);
9934 /* We can't rely on local_specializations for a parameter
9935 name used later in a function declaration (such as in a
9936 late-specified return type). Even if it exists, it might
9937 have the wrong value for a recursive call. Just make a
9938 dummy decl, since it's only used for its type. */
9939 arg_pack = tsubst_decl (parm_pack, args, complain);
9940 if (arg_pack && DECL_PACK_P (arg_pack))
9941 /* Partial instantiation of the parm_pack, we can't build
9942 up an argument pack yet. */
9943 arg_pack = NULL_TREE;
9945 arg_pack = make_fnparm_pack (arg_pack);
9946 need_local_specializations = true;
9949 else if (TREE_CODE (parm_pack) == FIELD_DECL)
9950 arg_pack = tsubst_copy (parm_pack, args, complain, in_decl);
9954 template_parm_level_and_index (parm_pack, &level, &idx);
9956 if (level <= levels)
9957 arg_pack = TMPL_ARG (args, level, idx);
9960 orig_arg = arg_pack;
9961 if (arg_pack && TREE_CODE (arg_pack) == ARGUMENT_PACK_SELECT)
9962 arg_pack = ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack);
9964 if (arg_pack && !ARGUMENT_PACK_P (arg_pack))
9965 /* This can only happen if we forget to expand an argument
9966 pack somewhere else. Just return an error, silently. */
9968 result = make_tree_vec (1);
9969 TREE_VEC_ELT (result, 0) = error_mark_node;
9976 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack));
9978 /* Don't bother trying to do a partial substitution with
9979 incomplete packs; we'll try again after deduction. */
9980 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack))
9985 else if (len != my_len)
9987 if (!(complain & tf_error))
9988 /* Fail quietly. */;
9989 else if (TREE_CODE (t) == TYPE_PACK_EXPANSION)
9990 error ("mismatched argument pack lengths while expanding "
9994 error ("mismatched argument pack lengths while expanding "
9997 return error_mark_node;
10000 /* Keep track of the parameter packs and their corresponding
10002 packs = tree_cons (parm_pack, arg_pack, packs);
10003 TREE_TYPE (packs) = orig_arg;
10007 /* We can't substitute for this parameter pack. We use a flag as
10008 well as the missing_level counter because function parameter
10009 packs don't have a level. */
10010 unsubstituted_packs = true;
10014 /* If the expansion is just T..., return the matching argument pack. */
10015 if (!unsubstituted_packs
10016 && TREE_PURPOSE (packs) == pattern)
10018 tree args = ARGUMENT_PACK_ARGS (TREE_VALUE (packs));
10019 if (TREE_CODE (t) == TYPE_PACK_EXPANSION
10020 || pack_expansion_args_count (args))
10022 /* Otherwise use the normal path so we get convert_from_reference. */
10025 /* We cannot expand this expansion expression, because we don't have
10026 all of the argument packs we need. */
10027 if (use_pack_expansion_extra_args_p (packs, len, unsubstituted_packs))
10029 /* We got some full packs, but we can't substitute them in until we
10030 have values for all the packs. So remember these until then. */
10032 t = make_pack_expansion (pattern);
10033 PACK_EXPANSION_EXTRA_ARGS (t) = args;
10036 else if (unsubstituted_packs)
10038 /* There were no real arguments, we're just replacing a parameter
10039 pack with another version of itself. Substitute into the
10040 pattern and return a PACK_EXPANSION_*. The caller will need to
10042 if (TREE_CODE (t) == EXPR_PACK_EXPANSION)
10043 t = tsubst_expr (pattern, args, complain, in_decl,
10044 /*integral_constant_expression_p=*/false);
10046 t = tsubst (pattern, args, complain, in_decl);
10047 t = make_pack_expansion (t);
10051 gcc_assert (len >= 0);
10053 if (need_local_specializations)
10055 /* We're in a late-specified return type, so create our own local
10056 specializations map; the current map is either NULL or (in the
10057 case of recursive unification) might have bindings that we don't
10058 want to use or alter. */
10059 saved_local_specializations = local_specializations;
10060 local_specializations = new hash_map<tree, tree>;
10063 /* For each argument in each argument pack, substitute into the
10065 result = make_tree_vec (len);
10066 for (i = 0; i < len; ++i)
10068 t = gen_elem_of_pack_expansion_instantiation (pattern, packs,
10072 TREE_VEC_ELT (result, i) = t;
10073 if (t == error_mark_node)
10075 result = error_mark_node;
10080 /* Update ARGS to restore the substitution from parameter packs to
10081 their argument packs. */
10082 for (pack = packs; pack; pack = TREE_CHAIN (pack))
10084 tree parm = TREE_PURPOSE (pack);
10086 if (TREE_CODE (parm) == PARM_DECL
10087 || TREE_CODE (parm) == FIELD_DECL)
10088 register_local_specialization (TREE_TYPE (pack), parm);
10093 if (TREE_VALUE (pack) == NULL_TREE)
10096 template_parm_level_and_index (parm, &level, &idx);
10098 /* Update the corresponding argument. */
10099 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
10100 TREE_VEC_ELT (TREE_VEC_ELT (args, level -1 ), idx) =
10103 TREE_VEC_ELT (args, idx) = TREE_TYPE (pack);
10107 if (need_local_specializations)
10109 delete local_specializations;
10110 local_specializations = saved_local_specializations;
10116 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
10117 TMPL. We do this using DECL_PARM_INDEX, which should work even with
10118 parameter packs; all parms generated from a function parameter pack will
10119 have the same DECL_PARM_INDEX. */
10122 get_pattern_parm (tree parm, tree tmpl)
10124 tree pattern = DECL_TEMPLATE_RESULT (tmpl);
10127 if (DECL_ARTIFICIAL (parm))
10129 for (patparm = DECL_ARGUMENTS (pattern);
10130 patparm; patparm = DECL_CHAIN (patparm))
10131 if (DECL_ARTIFICIAL (patparm)
10132 && DECL_NAME (parm) == DECL_NAME (patparm))
10137 patparm = FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl));
10138 patparm = chain_index (DECL_PARM_INDEX (parm)-1, patparm);
10139 gcc_assert (DECL_PARM_INDEX (patparm)
10140 == DECL_PARM_INDEX (parm));
10146 /* Substitute ARGS into the vector or list of template arguments T. */
10149 tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl)
10152 int len, need_new = 0, i, expanded_len_adjust = 0, out;
10155 if (t == error_mark_node)
10156 return error_mark_node;
10158 len = TREE_VEC_LENGTH (t);
10159 elts = XALLOCAVEC (tree, len);
10161 for (i = 0; i < len; i++)
10163 tree orig_arg = TREE_VEC_ELT (t, i);
10166 if (TREE_CODE (orig_arg) == TREE_VEC)
10167 new_arg = tsubst_template_args (orig_arg, args, complain, in_decl);
10168 else if (PACK_EXPANSION_P (orig_arg))
10170 /* Substitute into an expansion expression. */
10171 new_arg = tsubst_pack_expansion (orig_arg, args, complain, in_decl);
10173 if (TREE_CODE (new_arg) == TREE_VEC)
10174 /* Add to the expanded length adjustment the number of
10175 expanded arguments. We subtract one from this
10176 measurement, because the argument pack expression
10177 itself is already counted as 1 in
10178 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
10179 the argument pack is empty. */
10180 expanded_len_adjust += TREE_VEC_LENGTH (new_arg) - 1;
10182 else if (ARGUMENT_PACK_P (orig_arg))
10184 /* Substitute into each of the arguments. */
10185 new_arg = TYPE_P (orig_arg)
10186 ? cxx_make_type (TREE_CODE (orig_arg))
10187 : make_node (TREE_CODE (orig_arg));
10189 SET_ARGUMENT_PACK_ARGS (
10191 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg),
10192 args, complain, in_decl));
10194 if (ARGUMENT_PACK_ARGS (new_arg) == error_mark_node)
10195 new_arg = error_mark_node;
10197 if (TREE_CODE (new_arg) == NONTYPE_ARGUMENT_PACK) {
10198 TREE_TYPE (new_arg) = tsubst (TREE_TYPE (orig_arg), args,
10199 complain, in_decl);
10200 TREE_CONSTANT (new_arg) = TREE_CONSTANT (orig_arg);
10202 if (TREE_TYPE (new_arg) == error_mark_node)
10203 new_arg = error_mark_node;
10207 new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl);
10209 if (new_arg == error_mark_node)
10210 return error_mark_node;
10213 if (new_arg != orig_arg)
10220 /* Make space for the expanded arguments coming from template
10222 t = make_tree_vec (len + expanded_len_adjust);
10223 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
10224 arguments for a member template.
10225 In that case each TREE_VEC in ORIG_T represents a level of template
10226 arguments, and ORIG_T won't carry any non defaulted argument count.
10227 It will rather be the nested TREE_VECs that will carry one.
10228 In other words, ORIG_T carries a non defaulted argument count only
10229 if it doesn't contain any nested TREE_VEC. */
10230 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t))
10232 int count = GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t);
10233 count += expanded_len_adjust;
10234 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t, count);
10236 for (i = 0, out = 0; i < len; i++)
10238 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t, i))
10239 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t, i)))
10240 && TREE_CODE (elts[i]) == TREE_VEC)
10244 /* Now expand the template argument pack "in place". */
10245 for (idx = 0; idx < TREE_VEC_LENGTH (elts[i]); idx++, out++)
10246 TREE_VEC_ELT (t, out) = TREE_VEC_ELT (elts[i], idx);
10250 TREE_VEC_ELT (t, out) = elts[i];
10258 /* Return the result of substituting ARGS into the template parameters
10259 given by PARMS. If there are m levels of ARGS and m + n levels of
10260 PARMS, then the result will contain n levels of PARMS. For
10261 example, if PARMS is `template <class T> template <class U>
10262 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
10263 result will be `template <int*, double, class V>'. */
10266 tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain)
10268 tree r = NULL_TREE;
10271 /* When substituting into a template, we must set
10272 PROCESSING_TEMPLATE_DECL as the template parameters may be
10273 dependent if they are based on one-another, and the dependency
10274 predicates are short-circuit outside of templates. */
10275 ++processing_template_decl;
10277 for (new_parms = &r;
10278 parms && TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args);
10279 new_parms = &(TREE_CHAIN (*new_parms)),
10280 parms = TREE_CHAIN (parms))
10283 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms)));
10286 for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i)
10290 if (parms == error_mark_node)
10293 tuple = TREE_VEC_ELT (TREE_VALUE (parms), i);
10295 if (tuple == error_mark_node)
10298 TREE_VEC_ELT (new_vec, i) =
10299 tsubst_template_parm (tuple, args, complain);
10303 tree_cons (size_int (TMPL_PARMS_DEPTH (parms)
10304 - TMPL_ARGS_DEPTH (args)),
10305 new_vec, NULL_TREE);
10308 --processing_template_decl;
10313 /* Return the result of substituting ARGS into one template parameter
10314 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
10315 parameter and which TREE_PURPOSE is the default argument of the
10316 template parameter. */
10319 tsubst_template_parm (tree t, tree args, tsubst_flags_t complain)
10321 tree default_value, parm_decl;
10323 if (args == NULL_TREE
10325 || t == error_mark_node)
10328 gcc_assert (TREE_CODE (t) == TREE_LIST);
10330 default_value = TREE_PURPOSE (t);
10331 parm_decl = TREE_VALUE (t);
10333 parm_decl = tsubst (parm_decl, args, complain, NULL_TREE);
10334 if (TREE_CODE (parm_decl) == PARM_DECL
10335 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl), complain))
10336 parm_decl = error_mark_node;
10337 default_value = tsubst_template_arg (default_value, args,
10338 complain, NULL_TREE);
10340 return build_tree_list (default_value, parm_decl);
10343 /* Substitute the ARGS into the indicated aggregate (or enumeration)
10344 type T. If T is not an aggregate or enumeration type, it is
10345 handled as if by tsubst. IN_DECL is as for tsubst. If
10346 ENTERING_SCOPE is nonzero, T is the context for a template which
10347 we are presently tsubst'ing. Return the substituted value. */
10350 tsubst_aggr_type (tree t,
10352 tsubst_flags_t complain,
10354 int entering_scope)
10356 if (t == NULL_TREE)
10359 switch (TREE_CODE (t))
10362 if (TYPE_PTRMEMFUNC_P (t))
10363 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl);
10365 /* Else fall through. */
10366 case ENUMERAL_TYPE:
10368 if (TYPE_TEMPLATE_INFO (t) && uses_template_parms (t))
10373 int saved_unevaluated_operand;
10374 int saved_inhibit_evaluation_warnings;
10376 /* In "sizeof(X<I>)" we need to evaluate "I". */
10377 saved_unevaluated_operand = cp_unevaluated_operand;
10378 cp_unevaluated_operand = 0;
10379 saved_inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
10380 c_inhibit_evaluation_warnings = 0;
10382 /* First, determine the context for the type we are looking
10384 context = TYPE_CONTEXT (t);
10385 if (context && TYPE_P (context))
10387 context = tsubst_aggr_type (context, args, complain,
10388 in_decl, /*entering_scope=*/1);
10389 /* If context is a nested class inside a class template,
10390 it may still need to be instantiated (c++/33959). */
10391 context = complete_type (context);
10394 /* Then, figure out what arguments are appropriate for the
10395 type we are trying to find. For example, given:
10397 template <class T> struct S;
10398 template <class T, class U> void f(T, U) { S<U> su; }
10400 and supposing that we are instantiating f<int, double>,
10401 then our ARGS will be {int, double}, but, when looking up
10402 S we only want {double}. */
10403 argvec = tsubst_template_args (TYPE_TI_ARGS (t), args,
10404 complain, in_decl);
10405 if (argvec == error_mark_node)
10406 r = error_mark_node;
10409 r = lookup_template_class (t, argvec, in_decl, context,
10410 entering_scope, complain);
10411 r = cp_build_qualified_type_real (r, cp_type_quals (t), complain);
10414 cp_unevaluated_operand = saved_unevaluated_operand;
10415 c_inhibit_evaluation_warnings = saved_inhibit_evaluation_warnings;
10420 /* This is not a template type, so there's nothing to do. */
10424 return tsubst (t, args, complain, in_decl);
10428 /* Substitute into the default argument ARG (a default argument for
10429 FN), which has the indicated TYPE. */
10432 tsubst_default_argument (tree fn, tree type, tree arg, tsubst_flags_t complain)
10434 tree saved_class_ptr = NULL_TREE;
10435 tree saved_class_ref = NULL_TREE;
10436 int errs = errorcount + sorrycount;
10438 /* This can happen in invalid code. */
10439 if (TREE_CODE (arg) == DEFAULT_ARG)
10442 /* This default argument came from a template. Instantiate the
10443 default argument here, not in tsubst. In the case of
10452 we must be careful to do name lookup in the scope of S<T>,
10453 rather than in the current class. */
10454 push_access_scope (fn);
10455 /* The "this" pointer is not valid in a default argument. */
10458 saved_class_ptr = current_class_ptr;
10459 cp_function_chain->x_current_class_ptr = NULL_TREE;
10460 saved_class_ref = current_class_ref;
10461 cp_function_chain->x_current_class_ref = NULL_TREE;
10464 push_deferring_access_checks(dk_no_deferred);
10465 /* The default argument expression may cause implicitly defined
10466 member functions to be synthesized, which will result in garbage
10467 collection. We must treat this situation as if we were within
10468 the body of function so as to avoid collecting live data on the
10471 arg = tsubst_expr (arg, DECL_TI_ARGS (fn),
10472 complain, NULL_TREE,
10473 /*integral_constant_expression_p=*/false);
10475 pop_deferring_access_checks();
10477 /* Restore the "this" pointer. */
10480 cp_function_chain->x_current_class_ptr = saved_class_ptr;
10481 cp_function_chain->x_current_class_ref = saved_class_ref;
10484 if (errorcount+sorrycount > errs
10485 && (complain & tf_warning_or_error))
10486 inform (input_location,
10487 " when instantiating default argument for call to %D", fn);
10489 /* Make sure the default argument is reasonable. */
10490 arg = check_default_argument (type, arg, complain);
10492 pop_access_scope (fn);
10497 /* Substitute into all the default arguments for FN. */
10500 tsubst_default_arguments (tree fn, tsubst_flags_t complain)
10505 tmpl_args = DECL_TI_ARGS (fn);
10507 /* If this function is not yet instantiated, we certainly don't need
10508 its default arguments. */
10509 if (uses_template_parms (tmpl_args))
10511 /* Don't do this again for clones. */
10512 if (DECL_CLONED_FUNCTION_P (fn))
10515 for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
10517 arg = TREE_CHAIN (arg))
10518 if (TREE_PURPOSE (arg))
10519 TREE_PURPOSE (arg) = tsubst_default_argument (fn,
10521 TREE_PURPOSE (arg),
10525 /* Substitute the ARGS into the T, which is a _DECL. Return the
10526 result of the substitution. Issue error and warning messages under
10527 control of COMPLAIN. */
10530 tsubst_decl (tree t, tree args, tsubst_flags_t complain)
10532 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
10533 location_t saved_loc;
10534 tree r = NULL_TREE;
10536 hashval_t hash = 0;
10538 /* Set the filename and linenumber to improve error-reporting. */
10539 saved_loc = input_location;
10540 input_location = DECL_SOURCE_LOCATION (t);
10542 switch (TREE_CODE (t))
10544 case TEMPLATE_DECL:
10546 /* We can get here when processing a member function template,
10547 member class template, or template template parameter. */
10548 tree decl = DECL_TEMPLATE_RESULT (t);
10553 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
10555 /* Template template parameter is treated here. */
10556 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10557 if (new_type == error_mark_node)
10558 RETURN (error_mark_node);
10559 /* If we get a real template back, return it. This can happen in
10560 the context of most_specialized_partial_spec. */
10561 if (TREE_CODE (new_type) == TEMPLATE_DECL)
10565 DECL_CHAIN (r) = NULL_TREE;
10566 TREE_TYPE (r) = new_type;
10567 DECL_TEMPLATE_RESULT (r)
10568 = build_decl (DECL_SOURCE_LOCATION (decl),
10569 TYPE_DECL, DECL_NAME (decl), new_type);
10570 DECL_TEMPLATE_PARMS (r)
10571 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
10573 TYPE_NAME (new_type) = r;
10577 /* We might already have an instance of this template.
10578 The ARGS are for the surrounding class type, so the
10579 full args contain the tsubst'd args for the context,
10580 plus the innermost args from the template decl. */
10581 tmpl_args = DECL_CLASS_TEMPLATE_P (t)
10582 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t))
10583 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t));
10584 /* Because this is a template, the arguments will still be
10585 dependent, even after substitution. If
10586 PROCESSING_TEMPLATE_DECL is not set, the dependency
10587 predicates will short-circuit. */
10588 ++processing_template_decl;
10589 full_args = tsubst_template_args (tmpl_args, args,
10590 complain, in_decl);
10591 --processing_template_decl;
10592 if (full_args == error_mark_node)
10593 RETURN (error_mark_node);
10595 /* If this is a default template template argument,
10596 tsubst might not have changed anything. */
10597 if (full_args == tmpl_args)
10600 hash = hash_tmpl_and_args (t, full_args);
10601 spec = retrieve_specialization (t, full_args, hash);
10602 if (spec != NULL_TREE)
10608 /* Make a new template decl. It will be similar to the
10609 original, but will record the current template arguments.
10610 We also create a new function declaration, which is just
10611 like the old one, but points to this new template, rather
10612 than the old one. */
10614 gcc_assert (DECL_LANG_SPECIFIC (r) != 0);
10615 DECL_CHAIN (r) = NULL_TREE;
10617 DECL_TEMPLATE_INFO (r) = build_template_info (t, args);
10619 if (TREE_CODE (decl) == TYPE_DECL
10620 && !TYPE_DECL_ALIAS_P (decl))
10623 ++processing_template_decl;
10624 new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10625 --processing_template_decl;
10626 if (new_type == error_mark_node)
10627 RETURN (error_mark_node);
10629 TREE_TYPE (r) = new_type;
10630 /* For a partial specialization, we need to keep pointing to
10631 the primary template. */
10632 if (!DECL_TEMPLATE_SPECIALIZATION (t))
10633 CLASSTYPE_TI_TEMPLATE (new_type) = r;
10634 DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type);
10635 DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type);
10636 DECL_CONTEXT (r) = TYPE_CONTEXT (new_type);
10641 ++processing_template_decl;
10642 new_decl = tsubst (decl, args, complain, in_decl);
10643 --processing_template_decl;
10644 if (new_decl == error_mark_node)
10645 RETURN (error_mark_node);
10647 DECL_TEMPLATE_RESULT (r) = new_decl;
10648 DECL_TI_TEMPLATE (new_decl) = r;
10649 TREE_TYPE (r) = TREE_TYPE (new_decl);
10650 DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl);
10651 DECL_CONTEXT (r) = DECL_CONTEXT (new_decl);
10654 SET_DECL_IMPLICIT_INSTANTIATION (r);
10655 DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE;
10656 DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE;
10658 /* The template parameters for this new template are all the
10659 template parameters for the old template, except the
10660 outermost level of parameters. */
10661 DECL_TEMPLATE_PARMS (r)
10662 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
10665 if (PRIMARY_TEMPLATE_P (t))
10666 DECL_PRIMARY_TEMPLATE (r) = r;
10668 if (TREE_CODE (decl) != TYPE_DECL && TREE_CODE (decl) != VAR_DECL)
10669 /* Record this non-type partial instantiation. */
10670 register_specialization (r, t,
10671 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r)),
10676 case FUNCTION_DECL:
10679 tree argvec = NULL_TREE;
10687 /* Nobody should be tsubst'ing into non-template functions. */
10688 gcc_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE);
10690 if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL)
10695 /* If T is not dependent, just return it. We have to
10696 increment PROCESSING_TEMPLATE_DECL because
10697 value_dependent_expression_p assumes that nothing is
10698 dependent when PROCESSING_TEMPLATE_DECL is zero. */
10699 ++processing_template_decl;
10700 dependent_p = value_dependent_expression_p (t);
10701 --processing_template_decl;
10705 /* Calculate the most general template of which R is a
10706 specialization, and the complete set of arguments used to
10708 gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
10709 argvec = tsubst_template_args (DECL_TI_ARGS
10710 (DECL_TEMPLATE_RESULT
10711 (DECL_TI_TEMPLATE (t))),
10712 args, complain, in_decl);
10713 if (argvec == error_mark_node)
10714 RETURN (error_mark_node);
10716 /* Check to see if we already have this specialization. */
10717 hash = hash_tmpl_and_args (gen_tmpl, argvec);
10718 spec = retrieve_specialization (gen_tmpl, argvec, hash);
10726 /* We can see more levels of arguments than parameters if
10727 there was a specialization of a member template, like
10730 template <class T> struct S { template <class U> void f(); }
10731 template <> template <class U> void S<int>::f(U);
10733 Here, we'll be substituting into the specialization,
10734 because that's where we can find the code we actually
10735 want to generate, but we'll have enough arguments for
10736 the most general template.
10738 We also deal with the peculiar case:
10740 template <class T> struct S {
10741 template <class U> friend void f();
10743 template <class U> void f() {}
10745 template void f<double>();
10747 Here, the ARGS for the instantiation of will be {int,
10748 double}. But, we only need as many ARGS as there are
10749 levels of template parameters in CODE_PATTERN. We are
10750 careful not to get fooled into reducing the ARGS in
10753 template <class T> struct S { template <class U> void f(U); }
10754 template <class T> template <> void S<T>::f(int) {}
10756 which we can spot because the pattern will be a
10757 specialization in this case. */
10758 args_depth = TMPL_ARGS_DEPTH (args);
10760 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t)));
10761 if (args_depth > parms_depth
10762 && !DECL_TEMPLATE_SPECIALIZATION (t))
10763 args = get_innermost_template_args (args, parms_depth);
10767 /* This special case arises when we have something like this:
10769 template <class T> struct S {
10770 friend void f<int>(int, double);
10773 Here, the DECL_TI_TEMPLATE for the friend declaration
10774 will be an IDENTIFIER_NODE. We are being called from
10775 tsubst_friend_function, and we want only to create a
10776 new decl (R) with appropriate types so that we can call
10777 determine_specialization. */
10778 gen_tmpl = NULL_TREE;
10781 if (DECL_CLASS_SCOPE_P (t))
10783 if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t)))
10787 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
10788 complain, t, /*entering_scope=*/1);
10793 ctx = DECL_CONTEXT (t);
10795 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10796 if (type == error_mark_node)
10797 RETURN (error_mark_node);
10799 /* If we hit excessive deduction depth, the type is bogus even if
10800 it isn't error_mark_node, so don't build a decl. */
10801 if (excessive_deduction_depth)
10802 RETURN (error_mark_node);
10804 /* We do NOT check for matching decls pushed separately at this
10805 point, as they may not represent instantiations of this
10806 template, and in any case are considered separate under the
10809 DECL_USE_TEMPLATE (r) = 0;
10810 TREE_TYPE (r) = type;
10811 /* Clear out the mangled name and RTL for the instantiation. */
10812 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
10813 SET_DECL_RTL (r, NULL);
10814 /* Leave DECL_INITIAL set on deleted instantiations. */
10815 if (!DECL_DELETED_FN (r))
10816 DECL_INITIAL (r) = NULL_TREE;
10817 DECL_CONTEXT (r) = ctx;
10819 /* OpenMP UDRs have the only argument a reference to the declared
10820 type. We want to diagnose if the declared type is a reference,
10821 which is invalid, but as references to references are usually
10822 quietly merged, diagnose it here. */
10823 if (DECL_OMP_DECLARE_REDUCTION_P (t))
10826 = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (t))));
10827 argtype = tsubst (argtype, args, complain, in_decl);
10828 if (TREE_CODE (argtype) == REFERENCE_TYPE)
10829 error_at (DECL_SOURCE_LOCATION (t),
10830 "reference type %qT in "
10831 "%<#pragma omp declare reduction%>", argtype);
10832 if (strchr (IDENTIFIER_POINTER (DECL_NAME (t)), '~') == NULL)
10833 DECL_NAME (r) = omp_reduction_id (ERROR_MARK, DECL_NAME (t),
10837 if (member && DECL_CONV_FN_P (r))
10838 /* Type-conversion operator. Reconstruct the name, in
10839 case it's the name of one of the template's parameters. */
10840 DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type));
10842 DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args,
10844 DECL_RESULT (r) = NULL_TREE;
10846 TREE_STATIC (r) = 0;
10847 TREE_PUBLIC (r) = TREE_PUBLIC (t);
10848 DECL_EXTERNAL (r) = 1;
10849 /* If this is an instantiation of a function with internal
10850 linkage, we already know what object file linkage will be
10851 assigned to the instantiation. */
10852 DECL_INTERFACE_KNOWN (r) = !TREE_PUBLIC (r);
10853 DECL_DEFER_OUTPUT (r) = 0;
10854 DECL_CHAIN (r) = NULL_TREE;
10855 DECL_PENDING_INLINE_INFO (r) = 0;
10856 DECL_PENDING_INLINE_P (r) = 0;
10857 DECL_SAVED_TREE (r) = NULL_TREE;
10858 DECL_STRUCT_FUNCTION (r) = NULL;
10860 /* We'll re-clone as appropriate in instantiate_template. */
10861 DECL_CLONED_FUNCTION (r) = NULL_TREE;
10863 /* If we aren't complaining now, return on error before we register
10864 the specialization so that we'll complain eventually. */
10865 if ((complain & tf_error) == 0
10866 && IDENTIFIER_OPNAME_P (DECL_NAME (r))
10867 && !grok_op_properties (r, /*complain=*/false))
10868 RETURN (error_mark_node);
10870 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
10871 this in the special friend case mentioned above where
10872 GEN_TMPL is NULL. */
10875 DECL_TEMPLATE_INFO (r)
10876 = build_template_info (gen_tmpl, argvec);
10877 SET_DECL_IMPLICIT_INSTANTIATION (r);
10880 = register_specialization (r, gen_tmpl, argvec, false, hash);
10882 /* We instantiated this while substituting into
10883 the type earlier (template/friend54.C). */
10886 /* We're not supposed to instantiate default arguments
10887 until they are called, for a template. But, for a
10890 template <class T> void f ()
10891 { extern void g(int i = T()); }
10893 we should do the substitution when the template is
10894 instantiated. We handle the member function case in
10895 instantiate_class_template since the default arguments
10896 might refer to other members of the class. */
10898 && !PRIMARY_TEMPLATE_P (gen_tmpl)
10899 && !uses_template_parms (argvec))
10900 tsubst_default_arguments (r, complain);
10903 DECL_TEMPLATE_INFO (r) = NULL_TREE;
10905 /* Copy the list of befriending classes. */
10906 for (friends = &DECL_BEFRIENDING_CLASSES (r);
10908 friends = &TREE_CHAIN (*friends))
10910 *friends = copy_node (*friends);
10911 TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends),
10916 if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r))
10918 maybe_retrofit_in_chrg (r);
10919 if (DECL_CONSTRUCTOR_P (r))
10920 grok_ctor_properties (ctx, r);
10921 if (DECL_INHERITED_CTOR_BASE (r))
10922 deduce_inheriting_ctor (r);
10923 /* If this is an instantiation of a member template, clone it.
10924 If it isn't, that'll be handled by
10925 clone_constructors_and_destructors. */
10926 if (PRIMARY_TEMPLATE_P (gen_tmpl))
10927 clone_function_decl (r, /*update_method_vec_p=*/0);
10929 else if ((complain & tf_error) != 0
10930 && IDENTIFIER_OPNAME_P (DECL_NAME (r))
10931 && !grok_op_properties (r, /*complain=*/true))
10932 RETURN (error_mark_node);
10934 if (DECL_FRIEND_P (t) && DECL_FRIEND_CONTEXT (t))
10935 SET_DECL_FRIEND_CONTEXT (r,
10936 tsubst (DECL_FRIEND_CONTEXT (t),
10937 args, complain, in_decl));
10939 /* Possibly limit visibility based on template args. */
10940 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
10941 if (DECL_VISIBILITY_SPECIFIED (t))
10943 DECL_VISIBILITY_SPECIFIED (r) = 0;
10944 DECL_ATTRIBUTES (r)
10945 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
10947 determine_visibility (r);
10948 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r)
10949 && !processing_template_decl)
10950 defaulted_late_check (r);
10952 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
10953 args, complain, in_decl);
10959 tree type = NULL_TREE;
10961 tree expanded_types = NULL_TREE;
10962 tree prev_r = NULL_TREE;
10963 tree first_r = NULL_TREE;
10965 if (DECL_PACK_P (t))
10967 /* If there is a local specialization that isn't a
10968 parameter pack, it means that we're doing a "simple"
10969 substitution from inside tsubst_pack_expansion. Just
10970 return the local specialization (which will be a single
10972 tree spec = retrieve_local_specialization (t);
10974 && TREE_CODE (spec) == PARM_DECL
10975 && TREE_CODE (TREE_TYPE (spec)) != TYPE_PACK_EXPANSION)
10978 /* Expand the TYPE_PACK_EXPANSION that provides the types for
10979 the parameters in this function parameter pack. */
10980 expanded_types = tsubst_pack_expansion (TREE_TYPE (t), args,
10981 complain, in_decl);
10982 if (TREE_CODE (expanded_types) == TREE_VEC)
10984 len = TREE_VEC_LENGTH (expanded_types);
10986 /* Zero-length parameter packs are boring. Just substitute
10989 RETURN (tsubst (TREE_CHAIN (t), args, complain,
10994 /* All we did was update the type. Make a note of that. */
10995 type = expanded_types;
10996 expanded_types = NULL_TREE;
11000 /* Loop through all of the parameters we'll build. When T is
11001 a function parameter pack, LEN is the number of expanded
11002 types in EXPANDED_TYPES; otherwise, LEN is 1. */
11004 for (i = 0; i < len; ++i)
11008 if (DECL_TEMPLATE_PARM_P (t))
11009 SET_DECL_TEMPLATE_PARM_P (r);
11011 if (expanded_types)
11012 /* We're on the Ith parameter of the function parameter
11015 /* Get the Ith type. */
11016 type = TREE_VEC_ELT (expanded_types, i);
11018 /* Rename the parameter to include the index. */
11020 = make_ith_pack_parameter_name (DECL_NAME (r), i);
11023 /* We're dealing with a normal parameter. */
11024 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
11026 type = type_decays_to (type);
11027 TREE_TYPE (r) = type;
11028 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
11030 if (DECL_INITIAL (r))
11032 if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
11033 DECL_INITIAL (r) = TREE_TYPE (r);
11035 DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
11036 complain, in_decl);
11039 DECL_CONTEXT (r) = NULL_TREE;
11041 if (!DECL_TEMPLATE_PARM_P (r))
11042 DECL_ARG_TYPE (r) = type_passed_as (type);
11044 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
11045 args, complain, in_decl);
11047 /* Keep track of the first new parameter we
11048 generate. That's what will be returned to the
11053 /* Build a proper chain of parameters when substituting
11054 into a function parameter pack. */
11056 DECL_CHAIN (prev_r) = r;
11059 /* If cp_unevaluated_operand is set, we're just looking for a
11060 single dummy parameter, so don't keep going. */
11061 if (DECL_CHAIN (t) && !cp_unevaluated_operand)
11062 DECL_CHAIN (r) = tsubst (DECL_CHAIN (t), args,
11063 complain, DECL_CHAIN (t));
11065 /* FIRST_R contains the start of the chain we've built. */
11072 tree type = NULL_TREE;
11073 tree vec = NULL_TREE;
11074 tree expanded_types = NULL_TREE;
11077 if (PACK_EXPANSION_P (TREE_TYPE (t)))
11079 /* This field is a lambda capture pack. Return a TREE_VEC of
11080 the expanded fields to instantiate_class_template_1 and
11081 store them in the specializations hash table as a
11082 NONTYPE_ARGUMENT_PACK so that tsubst_copy can find them. */
11083 expanded_types = tsubst_pack_expansion (TREE_TYPE (t), args,
11084 complain, in_decl);
11085 if (TREE_CODE (expanded_types) == TREE_VEC)
11087 len = TREE_VEC_LENGTH (expanded_types);
11088 vec = make_tree_vec (len);
11092 /* All we did was update the type. Make a note of that. */
11093 type = expanded_types;
11094 expanded_types = NULL_TREE;
11098 for (int i = 0; i < len; ++i)
11101 if (expanded_types)
11103 type = TREE_VEC_ELT (expanded_types, i);
11105 = make_ith_pack_parameter_name (DECL_NAME (r), i);
11108 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
11110 if (type == error_mark_node)
11111 RETURN (error_mark_node);
11112 TREE_TYPE (r) = type;
11113 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
11115 if (DECL_C_BIT_FIELD (r))
11116 /* For bit-fields, DECL_INITIAL gives the number of bits. For
11117 non-bit-fields DECL_INITIAL is a non-static data member
11118 initializer, which gets deferred instantiation. */
11120 = tsubst_expr (DECL_INITIAL (t), args,
11122 /*integral_constant_expression_p=*/true);
11123 else if (DECL_INITIAL (t))
11125 /* Set up DECL_TEMPLATE_INFO so that we can get at the
11126 NSDMI in perform_member_init. Still set DECL_INITIAL
11127 so that we know there is one. */
11128 DECL_INITIAL (r) = void_node;
11129 gcc_assert (DECL_LANG_SPECIFIC (r) == NULL);
11130 retrofit_lang_decl (r);
11131 DECL_TEMPLATE_INFO (r) = build_template_info (t, args);
11133 /* We don't have to set DECL_CONTEXT here; it is set by
11134 finish_member_declaration. */
11135 DECL_CHAIN (r) = NULL_TREE;
11137 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
11138 args, complain, in_decl);
11141 TREE_VEC_ELT (vec, i) = r;
11147 tree pack = make_node (NONTYPE_ARGUMENT_PACK);
11148 tree tpack = cxx_make_type (TYPE_ARGUMENT_PACK);
11149 SET_ARGUMENT_PACK_ARGS (pack, vec);
11150 SET_ARGUMENT_PACK_ARGS (tpack, expanded_types);
11151 TREE_TYPE (pack) = tpack;
11152 register_specialization (pack, t, args, false, 0);
11158 /* We reach here only for member using decls. We also need to check
11159 uses_template_parms because DECL_DEPENDENT_P is not set for a
11160 using-declaration that designates a member of the current
11161 instantiation (c++/53549). */
11162 if (DECL_DEPENDENT_P (t)
11163 || uses_template_parms (USING_DECL_SCOPE (t)))
11165 tree inst_scope = tsubst_copy (USING_DECL_SCOPE (t), args,
11166 complain, in_decl);
11167 tree name = tsubst_copy (DECL_NAME (t), args, complain, in_decl);
11168 r = do_class_using_decl (inst_scope, name);
11170 r = error_mark_node;
11173 TREE_PROTECTED (r) = TREE_PROTECTED (t);
11174 TREE_PRIVATE (r) = TREE_PRIVATE (t);
11180 DECL_CHAIN (r) = NULL_TREE;
11187 tree argvec = NULL_TREE;
11188 tree gen_tmpl = NULL_TREE;
11190 tree tmpl = NULL_TREE;
11192 tree type = NULL_TREE;
11195 if (TREE_TYPE (t) == error_mark_node)
11196 RETURN (error_mark_node);
11198 if (TREE_CODE (t) == TYPE_DECL
11199 && t == TYPE_MAIN_DECL (TREE_TYPE (t)))
11201 /* If this is the canonical decl, we don't have to
11202 mess with instantiations, and often we can't (for
11203 typename, template type parms and such). Note that
11204 TYPE_NAME is not correct for the above test if
11205 we've copied the type for a typedef. */
11206 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
11207 if (type == error_mark_node)
11208 RETURN (error_mark_node);
11209 r = TYPE_NAME (type);
11213 /* Check to see if we already have the specialization we
11216 if (DECL_CLASS_SCOPE_P (t) || DECL_NAMESPACE_SCOPE_P (t))
11218 /* T is a static data member or namespace-scope entity.
11219 We have to substitute into namespace-scope variables
11220 (even though such entities are never templates) because
11223 template <class T> void f() { extern T t; }
11225 where the entity referenced is not known until
11226 instantiation time. */
11228 ctx = DECL_CONTEXT (t);
11229 if (DECL_CLASS_SCOPE_P (t))
11231 ctx = tsubst_aggr_type (ctx, args,
11233 in_decl, /*entering_scope=*/1);
11234 /* If CTX is unchanged, then T is in fact the
11235 specialization we want. That situation occurs when
11236 referencing a static data member within in its own
11237 class. We can use pointer equality, rather than
11238 same_type_p, because DECL_CONTEXT is always
11240 if (ctx == DECL_CONTEXT (t)
11241 /* ... unless T is a member template; in which
11242 case our caller can be willing to create a
11243 specialization of that template represented
11245 && !(DECL_TI_TEMPLATE (t)
11246 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
11252 tmpl = DECL_TI_TEMPLATE (t);
11253 gen_tmpl = most_general_template (tmpl);
11254 argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl);
11255 if (argvec == error_mark_node)
11256 RETURN (error_mark_node);
11257 hash = hash_tmpl_and_args (gen_tmpl, argvec);
11258 spec = retrieve_specialization (gen_tmpl, argvec, hash);
11263 /* A local variable. */
11265 /* Subsequent calls to pushdecl will fill this in. */
11267 spec = retrieve_local_specialization (t);
11269 /* If we already have the specialization we need, there is
11270 nothing more to do. */
11277 /* Create a new node for the specialization we need. */
11279 if (type == NULL_TREE)
11281 if (is_typedef_decl (t))
11282 type = DECL_ORIGINAL_TYPE (t);
11284 type = TREE_TYPE (t);
11286 && VAR_HAD_UNKNOWN_BOUND (t)
11287 && type != error_mark_node)
11288 type = strip_array_domain (type);
11289 type = tsubst (type, args, complain, in_decl);
11293 /* Even if the original location is out of scope, the
11294 newly substituted one is not. */
11295 DECL_DEAD_FOR_LOCAL (r) = 0;
11296 DECL_INITIALIZED_P (r) = 0;
11297 DECL_TEMPLATE_INSTANTIATED (r) = 0;
11298 if (type == error_mark_node)
11299 RETURN (error_mark_node);
11300 if (TREE_CODE (type) == FUNCTION_TYPE)
11302 /* It may seem that this case cannot occur, since:
11307 declares a function, not a variable. However:
11310 template <typename T> void g() { T t; }
11311 template void g<f>();
11313 is an attempt to declare a variable with function
11315 error ("variable %qD has function type",
11316 /* R is not yet sufficiently initialized, so we
11317 just use its name. */
11319 RETURN (error_mark_node);
11321 type = complete_type (type);
11322 /* Wait until cp_finish_decl to set this again, to handle
11323 circular dependency (template/instantiate6.C). */
11324 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r) = 0;
11325 type = check_var_type (DECL_NAME (r), type);
11327 if (DECL_HAS_VALUE_EXPR_P (t))
11329 tree ve = DECL_VALUE_EXPR (t);
11330 ve = tsubst_expr (ve, args, complain, in_decl,
11331 /*constant_expression_p=*/false);
11332 if (REFERENCE_REF_P (ve))
11334 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
11335 ve = TREE_OPERAND (ve, 0);
11337 SET_DECL_VALUE_EXPR (r, ve);
11339 if (TREE_STATIC (r) || DECL_EXTERNAL (r))
11340 set_decl_tls_model (r, decl_tls_model (t));
11342 else if (DECL_SELF_REFERENCE_P (t))
11343 SET_DECL_SELF_REFERENCE_P (r);
11344 TREE_TYPE (r) = type;
11345 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
11346 DECL_CONTEXT (r) = ctx;
11347 /* Clear out the mangled name and RTL for the instantiation. */
11348 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
11349 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
11350 SET_DECL_RTL (r, NULL);
11351 /* The initializer must not be expanded until it is required;
11352 see [temp.inst]. */
11353 DECL_INITIAL (r) = NULL_TREE;
11354 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
11355 SET_DECL_RTL (r, NULL);
11356 DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0;
11359 /* Possibly limit visibility based on template args. */
11360 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
11361 if (DECL_VISIBILITY_SPECIFIED (t))
11363 DECL_VISIBILITY_SPECIFIED (r) = 0;
11364 DECL_ATTRIBUTES (r)
11365 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
11367 determine_visibility (r);
11372 /* A static data member declaration is always marked
11373 external when it is declared in-class, even if an
11374 initializer is present. We mimic the non-template
11375 processing here. */
11376 DECL_EXTERNAL (r) = 1;
11378 register_specialization (r, gen_tmpl, argvec, false, hash);
11379 DECL_TEMPLATE_INFO (r) = build_template_info (tmpl, argvec);
11380 SET_DECL_IMPLICIT_INSTANTIATION (r);
11382 else if (!cp_unevaluated_operand)
11383 register_local_specialization (r, t);
11385 DECL_CHAIN (r) = NULL_TREE;
11387 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r),
11389 args, complain, in_decl);
11391 /* Preserve a typedef that names a type. */
11392 if (is_typedef_decl (r))
11394 DECL_ORIGINAL_TYPE (r) = NULL_TREE;
11395 set_underlying_type (r);
11398 layout_decl (r, 0);
11403 gcc_unreachable ();
11408 /* Restore the file and line information. */
11409 input_location = saved_loc;
11414 /* Substitute into the ARG_TYPES of a function type.
11415 If END is a TREE_CHAIN, leave it and any following types
11419 tsubst_arg_types (tree arg_types,
11422 tsubst_flags_t complain,
11425 tree remaining_arg_types;
11426 tree type = NULL_TREE;
11428 tree expanded_args = NULL_TREE;
11431 if (!arg_types || arg_types == void_list_node || arg_types == end)
11434 remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types),
11435 args, end, complain, in_decl);
11436 if (remaining_arg_types == error_mark_node)
11437 return error_mark_node;
11439 if (PACK_EXPANSION_P (TREE_VALUE (arg_types)))
11441 /* For a pack expansion, perform substitution on the
11442 entire expression. Later on, we'll handle the arguments
11444 expanded_args = tsubst_pack_expansion (TREE_VALUE (arg_types),
11445 args, complain, in_decl);
11447 if (TREE_CODE (expanded_args) == TREE_VEC)
11448 /* So that we'll spin through the parameters, one by one. */
11449 i = TREE_VEC_LENGTH (expanded_args);
11452 /* We only partially substituted into the parameter
11453 pack. Our type is TYPE_PACK_EXPANSION. */
11454 type = expanded_args;
11455 expanded_args = NULL_TREE;
11463 type = TREE_VEC_ELT (expanded_args, i);
11465 type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
11467 if (type == error_mark_node)
11468 return error_mark_node;
11469 if (VOID_TYPE_P (type))
11471 if (complain & tf_error)
11473 error ("invalid parameter type %qT", type);
11475 error ("in declaration %q+D", in_decl);
11477 return error_mark_node;
11480 if (abstract_virtuals_error_sfinae (ACU_PARM, type, complain))
11481 return error_mark_node;
11483 /* Do array-to-pointer, function-to-pointer conversion, and ignore
11484 top-level qualifiers as required. */
11485 type = cv_unqualified (type_decays_to (type));
11487 /* We do not substitute into default arguments here. The standard
11488 mandates that they be instantiated only when needed, which is
11489 done in build_over_call. */
11490 default_arg = TREE_PURPOSE (arg_types);
11492 if (default_arg && TREE_CODE (default_arg) == DEFAULT_ARG)
11494 /* We've instantiated a template before its default arguments
11495 have been parsed. This can happen for a nested template
11496 class, and is not an error unless we require the default
11497 argument in a call of this function. */
11498 remaining_arg_types =
11499 tree_cons (default_arg, type, remaining_arg_types);
11500 vec_safe_push (DEFARG_INSTANTIATIONS(default_arg), remaining_arg_types);
11503 remaining_arg_types =
11504 hash_tree_cons (default_arg, type, remaining_arg_types);
11507 return remaining_arg_types;
11510 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
11511 *not* handle the exception-specification for FNTYPE, because the
11512 initial substitution of explicitly provided template parameters
11513 during argument deduction forbids substitution into the
11514 exception-specification:
11518 All references in the function type of the function template to the
11519 corresponding template parameters are replaced by the specified tem-
11520 plate argument values. If a substitution in a template parameter or
11521 in the function type of the function template results in an invalid
11522 type, type deduction fails. [Note: The equivalent substitution in
11523 exception specifications is done only when the function is instanti-
11524 ated, at which point a program is ill-formed if the substitution
11525 results in an invalid type.] */
11528 tsubst_function_type (tree t,
11530 tsubst_flags_t complain,
11534 tree arg_types = NULL_TREE;
11537 /* The TYPE_CONTEXT is not used for function/method types. */
11538 gcc_assert (TYPE_CONTEXT (t) == NULL_TREE);
11540 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
11542 bool late_return_type_p = TYPE_HAS_LATE_RETURN_TYPE (t);
11544 if (late_return_type_p)
11546 /* Substitute the argument types. */
11547 arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args, NULL_TREE,
11548 complain, in_decl);
11549 if (arg_types == error_mark_node)
11550 return error_mark_node;
11552 tree save_ccp = current_class_ptr;
11553 tree save_ccr = current_class_ref;
11554 tree this_type = (TREE_CODE (t) == METHOD_TYPE
11555 ? TREE_TYPE (TREE_VALUE (arg_types)) : NULL_TREE);
11556 bool do_inject = this_type && CLASS_TYPE_P (this_type);
11559 /* DR 1207: 'this' is in scope in the trailing return type. */
11560 inject_this_parameter (this_type, cp_type_quals (this_type));
11563 /* Substitute the return type. */
11564 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
11568 current_class_ptr = save_ccp;
11569 current_class_ref = save_ccr;
11573 /* Substitute the return type. */
11574 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
11576 if (return_type == error_mark_node)
11577 return error_mark_node;
11578 /* DR 486 clarifies that creation of a function type with an
11579 invalid return type is a deduction failure. */
11580 if (TREE_CODE (return_type) == ARRAY_TYPE
11581 || TREE_CODE (return_type) == FUNCTION_TYPE)
11583 if (complain & tf_error)
11585 if (TREE_CODE (return_type) == ARRAY_TYPE)
11586 error ("function returning an array");
11588 error ("function returning a function");
11590 return error_mark_node;
11593 if (abstract_virtuals_error_sfinae (ACU_RETURN, return_type, complain))
11594 return error_mark_node;
11596 if (!late_return_type_p)
11598 /* Substitute the argument types. */
11599 arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args, NULL_TREE,
11600 complain, in_decl);
11601 if (arg_types == error_mark_node)
11602 return error_mark_node;
11605 /* Construct a new type node and return it. */
11606 if (TREE_CODE (t) == FUNCTION_TYPE)
11608 fntype = build_function_type (return_type, arg_types);
11609 fntype = apply_memfn_quals (fntype,
11610 type_memfn_quals (t),
11611 type_memfn_rqual (t));
11615 tree r = TREE_TYPE (TREE_VALUE (arg_types));
11616 /* Don't pick up extra function qualifiers from the basetype. */
11617 r = cp_build_qualified_type_real (r, type_memfn_quals (t), complain);
11618 if (! MAYBE_CLASS_TYPE_P (r))
11622 Type deduction may fail for any of the following
11625 -- Attempting to create "pointer to member of T" when T
11626 is not a class type. */
11627 if (complain & tf_error)
11628 error ("creating pointer to member function of non-class type %qT",
11630 return error_mark_node;
11633 fntype = build_method_type_directly (r, return_type,
11634 TREE_CHAIN (arg_types));
11635 fntype = build_ref_qualified_type (fntype, type_memfn_rqual (t));
11637 fntype = cp_build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t));
11639 if (late_return_type_p)
11640 TYPE_HAS_LATE_RETURN_TYPE (fntype) = 1;
11645 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
11646 ARGS into that specification, and return the substituted
11647 specification. If there is no specification, return NULL_TREE. */
11650 tsubst_exception_specification (tree fntype,
11652 tsubst_flags_t complain,
11659 specs = TYPE_RAISES_EXCEPTIONS (fntype);
11660 new_specs = NULL_TREE;
11661 if (specs && TREE_PURPOSE (specs))
11663 /* A noexcept-specifier. */
11664 tree expr = TREE_PURPOSE (specs);
11665 if (TREE_CODE (expr) == INTEGER_CST)
11669 /* Defer instantiation of noexcept-specifiers to avoid
11670 excessive instantiations (c++/49107). */
11671 new_specs = make_node (DEFERRED_NOEXCEPT);
11672 if (DEFERRED_NOEXCEPT_SPEC_P (specs))
11674 /* We already partially instantiated this member template,
11675 so combine the new args with the old. */
11676 DEFERRED_NOEXCEPT_PATTERN (new_specs)
11677 = DEFERRED_NOEXCEPT_PATTERN (expr);
11678 DEFERRED_NOEXCEPT_ARGS (new_specs)
11679 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr), args);
11683 DEFERRED_NOEXCEPT_PATTERN (new_specs) = expr;
11684 DEFERRED_NOEXCEPT_ARGS (new_specs) = args;
11688 new_specs = tsubst_copy_and_build
11689 (expr, args, complain, in_decl, /*function_p=*/false,
11690 /*integral_constant_expression_p=*/true);
11691 new_specs = build_noexcept_spec (new_specs, complain);
11695 if (! TREE_VALUE (specs))
11702 tree expanded_specs = NULL_TREE;
11704 if (PACK_EXPANSION_P (TREE_VALUE (specs)))
11706 /* Expand the pack expansion type. */
11707 expanded_specs = tsubst_pack_expansion (TREE_VALUE (specs),
11711 if (expanded_specs == error_mark_node)
11712 return error_mark_node;
11713 else if (TREE_CODE (expanded_specs) == TREE_VEC)
11714 len = TREE_VEC_LENGTH (expanded_specs);
11717 /* We're substituting into a member template, so
11718 we got a TYPE_PACK_EXPANSION back. Add that
11719 expansion and move on. */
11720 gcc_assert (TREE_CODE (expanded_specs)
11721 == TYPE_PACK_EXPANSION);
11722 new_specs = add_exception_specifier (new_specs,
11725 specs = TREE_CHAIN (specs);
11730 for (i = 0; i < len; ++i)
11732 if (expanded_specs)
11733 spec = TREE_VEC_ELT (expanded_specs, i);
11735 spec = tsubst (TREE_VALUE (specs), args, complain, in_decl);
11736 if (spec == error_mark_node)
11738 new_specs = add_exception_specifier (new_specs, spec,
11742 specs = TREE_CHAIN (specs);
11748 /* Take the tree structure T and replace template parameters used
11749 therein with the argument vector ARGS. IN_DECL is an associated
11750 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
11751 Issue error and warning messages under control of COMPLAIN. Note
11752 that we must be relatively non-tolerant of extensions here, in
11753 order to preserve conformance; if we allow substitutions that
11754 should not be allowed, we may allow argument deductions that should
11755 not succeed, and therefore report ambiguous overload situations
11756 where there are none. In theory, we could allow the substitution,
11757 but indicate that it should have failed, and allow our caller to
11758 make sure that the right thing happens, but we don't try to do this
11761 This function is used for dealing with types, decls and the like;
11762 for expressions, use tsubst_expr or tsubst_copy. */
11765 tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
11767 enum tree_code code;
11768 tree type, r = NULL_TREE;
11770 if (t == NULL_TREE || t == error_mark_node
11771 || t == integer_type_node
11772 || t == void_type_node
11773 || t == char_type_node
11774 || t == unknown_type_node
11775 || TREE_CODE (t) == NAMESPACE_DECL
11776 || TREE_CODE (t) == TRANSLATION_UNIT_DECL)
11780 return tsubst_decl (t, args, complain);
11782 if (args == NULL_TREE)
11785 code = TREE_CODE (t);
11787 if (code == IDENTIFIER_NODE)
11788 type = IDENTIFIER_TYPE_VALUE (t);
11790 type = TREE_TYPE (t);
11792 gcc_assert (type != unknown_type_node);
11794 /* Reuse typedefs. We need to do this to handle dependent attributes,
11795 such as attribute aligned. */
11797 && typedef_variant_p (t))
11799 tree decl = TYPE_NAME (t);
11801 if (alias_template_specialization_p (t))
11803 /* DECL represents an alias template and we want to
11805 tree tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
11806 tree gen_args = tsubst (DECL_TI_ARGS (decl), args, complain, in_decl);
11807 r = instantiate_alias_template (tmpl, gen_args, complain);
11809 else if (DECL_CLASS_SCOPE_P (decl)
11810 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl))
11811 && uses_template_parms (DECL_CONTEXT (decl)))
11813 tree tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
11814 tree gen_args = tsubst (DECL_TI_ARGS (decl), args, complain, in_decl);
11815 r = retrieve_specialization (tmpl, gen_args, 0);
11817 else if (DECL_FUNCTION_SCOPE_P (decl)
11818 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl))
11819 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl))))
11820 r = retrieve_local_specialization (decl);
11822 /* The typedef is from a non-template context. */
11828 r = cp_build_qualified_type_real
11829 (r, cp_type_quals (t) | cp_type_quals (r),
11830 complain | tf_ignore_bad_quals);
11835 /* We don't have an instantiation yet, so drop the typedef. */
11836 int quals = cp_type_quals (t);
11837 t = DECL_ORIGINAL_TYPE (decl);
11838 t = cp_build_qualified_type_real (t, quals,
11839 complain | tf_ignore_bad_quals);
11844 && code != TYPENAME_TYPE
11845 && code != TEMPLATE_TYPE_PARM
11846 && code != IDENTIFIER_NODE
11847 && code != FUNCTION_TYPE
11848 && code != METHOD_TYPE)
11849 type = tsubst (type, args, complain, in_decl);
11850 if (type == error_mark_node)
11851 return error_mark_node;
11857 case ENUMERAL_TYPE:
11858 return tsubst_aggr_type (t, args, complain, in_decl,
11859 /*entering_scope=*/0);
11862 case IDENTIFIER_NODE:
11873 if (t == integer_type_node)
11876 if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
11877 && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
11881 tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);
11883 max = tsubst_expr (omax, args, complain, in_decl,
11884 /*integral_constant_expression_p=*/false);
11886 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
11888 if (TREE_CODE (max) == NOP_EXPR
11889 && TREE_SIDE_EFFECTS (omax)
11890 && !TREE_TYPE (max))
11891 TREE_TYPE (max) = TREE_TYPE (TREE_OPERAND (max, 0));
11893 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
11894 with TREE_SIDE_EFFECTS that indicates this is not an integral
11895 constant expression. */
11896 if (processing_template_decl
11897 && TREE_SIDE_EFFECTS (omax) && TREE_CODE (omax) == NOP_EXPR)
11899 gcc_assert (TREE_CODE (max) == NOP_EXPR);
11900 TREE_SIDE_EFFECTS (max) = 1;
11903 return compute_array_index_type (NULL_TREE, max, complain);
11906 case TEMPLATE_TYPE_PARM:
11907 case TEMPLATE_TEMPLATE_PARM:
11908 case BOUND_TEMPLATE_TEMPLATE_PARM:
11909 case TEMPLATE_PARM_INDEX:
11914 tree arg = NULL_TREE;
11918 gcc_assert (TREE_VEC_LENGTH (args) > 0);
11919 template_parm_level_and_index (t, &level, &idx);
11921 levels = TMPL_ARGS_DEPTH (args);
11922 if (level <= levels)
11924 arg = TMPL_ARG (args, level, idx);
11926 if (arg && TREE_CODE (arg) == ARGUMENT_PACK_SELECT)
11928 /* See through ARGUMENT_PACK_SELECT arguments. */
11929 arg = ARGUMENT_PACK_SELECT_ARG (arg);
11930 /* If the selected argument is an expansion E, that most
11931 likely means we were called from
11932 gen_elem_of_pack_expansion_instantiation during the
11933 substituting of pack an argument pack (which Ith
11934 element is a pack expansion, where I is
11935 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
11936 In this case, the Ith element resulting from this
11937 substituting is going to be a pack expansion, which
11938 pattern is the pattern of E. Let's return the
11940 gen_elem_of_pack_expansion_instantiation will
11941 build the resulting pack expansion from it. */
11942 if (PACK_EXPANSION_P (arg))
11944 /* Make sure we aren't throwing away arg info. */
11945 gcc_assert (!PACK_EXPANSION_EXTRA_ARGS (arg));
11946 arg = PACK_EXPANSION_PATTERN (arg);
11951 if (arg == error_mark_node)
11952 return error_mark_node;
11953 else if (arg != NULL_TREE)
11955 if (ARGUMENT_PACK_P (arg))
11956 /* If ARG is an argument pack, we don't actually want to
11957 perform a substitution here, because substitutions
11958 for argument packs are only done
11959 element-by-element. We can get to this point when
11960 substituting the type of a non-type template
11961 parameter pack, when that type actually contains
11962 template parameter packs from an outer template, e.g.,
11964 template<typename... Types> struct A {
11965 template<Types... Values> struct B { };
11969 if (code == TEMPLATE_TYPE_PARM)
11972 gcc_assert (TYPE_P (arg));
11974 quals = cp_type_quals (arg) | cp_type_quals (t);
11976 return cp_build_qualified_type_real
11977 (arg, quals, complain | tf_ignore_bad_quals);
11979 else if (code == BOUND_TEMPLATE_TEMPLATE_PARM)
11981 /* We are processing a type constructed from a
11982 template template parameter. */
11983 tree argvec = tsubst (TYPE_TI_ARGS (t),
11984 args, complain, in_decl);
11985 if (argvec == error_mark_node)
11986 return error_mark_node;
11988 gcc_assert (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
11989 || TREE_CODE (arg) == TEMPLATE_DECL
11990 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
11992 if (TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
11993 /* Consider this code:
11995 template <template <class> class Template>
11997 template <class Arg> using Bind = Template<Arg>;
12000 template <template <class> class Template, class Arg>
12001 using Instantiate = Template<Arg>; //#0
12003 template <template <class> class Template,
12006 Instantiate<Internal<Template>::template Bind,
12009 When #1 is parsed, the
12010 BOUND_TEMPLATE_TEMPLATE_PARM representing the
12011 parameter `Template' in #0 matches the
12012 UNBOUND_CLASS_TEMPLATE representing the argument
12013 `Internal<Template>::template Bind'; We then want
12014 to assemble the type `Bind<Argument>' that can't
12015 be fully created right now, because
12016 `Internal<Template>' not being complete, the Bind
12017 template cannot be looked up in that context. So
12018 we need to "store" `Bind<Argument>' for later
12019 when the context of Bind becomes complete. Let's
12020 store that in a TYPENAME_TYPE. */
12021 return make_typename_type (TYPE_CONTEXT (arg),
12022 build_nt (TEMPLATE_ID_EXPR,
12023 TYPE_IDENTIFIER (arg),
12028 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
12029 are resolving nested-types in the signature of a
12030 member function templates. Otherwise ARG is a
12031 TEMPLATE_DECL and is the real template to be
12033 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
12034 arg = TYPE_NAME (arg);
12036 r = lookup_template_class (arg,
12038 DECL_CONTEXT (arg),
12039 /*entering_scope=*/0,
12041 return cp_build_qualified_type_real
12042 (r, cp_type_quals (t) | cp_type_quals (r), complain);
12045 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
12046 return convert_from_reference (unshare_expr (arg));
12050 /* This can happen during the attempted tsubst'ing in
12051 unify. This means that we don't yet have any information
12052 about the template parameter in question. */
12055 /* Early in template argument deduction substitution, we don't
12056 want to reduce the level of 'auto', or it will be confused
12057 with a normal template parm in subsequent deduction. */
12058 if (is_auto (t) && (complain & tf_partial))
12061 /* If we get here, we must have been looking at a parm for a
12062 more deeply nested template. Make a new version of this
12063 template parameter, but with a lower level. */
12066 case TEMPLATE_TYPE_PARM:
12067 case TEMPLATE_TEMPLATE_PARM:
12068 case BOUND_TEMPLATE_TEMPLATE_PARM:
12069 if (cp_type_quals (t))
12071 r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
12072 r = cp_build_qualified_type_real
12073 (r, cp_type_quals (t),
12074 complain | (code == TEMPLATE_TYPE_PARM
12075 ? tf_ignore_bad_quals : 0));
12080 TEMPLATE_TYPE_PARM_INDEX (r)
12081 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t),
12082 r, levels, args, complain);
12083 TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r);
12084 TYPE_MAIN_VARIANT (r) = r;
12085 TYPE_POINTER_TO (r) = NULL_TREE;
12086 TYPE_REFERENCE_TO (r) = NULL_TREE;
12088 if (TREE_CODE (r) == TEMPLATE_TEMPLATE_PARM)
12089 /* We have reduced the level of the template
12090 template parameter, but not the levels of its
12091 template parameters, so canonical_type_parameter
12092 will not be able to find the canonical template
12093 template parameter for this level. Thus, we
12094 require structural equality checking to compare
12095 TEMPLATE_TEMPLATE_PARMs. */
12096 SET_TYPE_STRUCTURAL_EQUALITY (r);
12097 else if (TYPE_STRUCTURAL_EQUALITY_P (t))
12098 SET_TYPE_STRUCTURAL_EQUALITY (r);
12100 TYPE_CANONICAL (r) = canonical_type_parameter (r);
12102 if (code == BOUND_TEMPLATE_TEMPLATE_PARM)
12104 tree argvec = tsubst (TYPE_TI_ARGS (t), args,
12105 complain, in_decl);
12106 if (argvec == error_mark_node)
12107 return error_mark_node;
12109 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r)
12110 = build_template_info (TYPE_TI_TEMPLATE (t), argvec);
12115 case TEMPLATE_PARM_INDEX:
12116 r = reduce_template_parm_level (t, type, levels, args, complain);
12120 gcc_unreachable ();
12128 tree purpose, value, chain;
12130 if (t == void_list_node)
12133 purpose = TREE_PURPOSE (t);
12136 purpose = tsubst (purpose, args, complain, in_decl);
12137 if (purpose == error_mark_node)
12138 return error_mark_node;
12140 value = TREE_VALUE (t);
12143 value = tsubst (value, args, complain, in_decl);
12144 if (value == error_mark_node)
12145 return error_mark_node;
12147 chain = TREE_CHAIN (t);
12148 if (chain && chain != void_type_node)
12150 chain = tsubst (chain, args, complain, in_decl);
12151 if (chain == error_mark_node)
12152 return error_mark_node;
12154 if (purpose == TREE_PURPOSE (t)
12155 && value == TREE_VALUE (t)
12156 && chain == TREE_CHAIN (t))
12158 return hash_tree_cons (purpose, value, chain);
12162 /* We should never be tsubsting a binfo. */
12163 gcc_unreachable ();
12166 /* A vector of template arguments. */
12167 gcc_assert (!type);
12168 return tsubst_template_args (t, args, complain, in_decl);
12171 case REFERENCE_TYPE:
12173 if (type == TREE_TYPE (t) && TREE_CODE (type) != METHOD_TYPE)
12178 Type deduction may fail for any of the following
12181 -- Attempting to create a pointer to reference type.
12182 -- Attempting to create a reference to a reference type or
12183 a reference to void.
12185 Core issue 106 says that creating a reference to a reference
12186 during instantiation is no longer a cause for failure. We
12187 only enforce this check in strict C++98 mode. */
12188 if ((TREE_CODE (type) == REFERENCE_TYPE
12189 && (((cxx_dialect == cxx98) && flag_iso) || code != REFERENCE_TYPE))
12190 || (code == REFERENCE_TYPE && VOID_TYPE_P (type)))
12192 static location_t last_loc;
12194 /* We keep track of the last time we issued this error
12195 message to avoid spewing a ton of messages during a
12196 single bad template instantiation. */
12197 if (complain & tf_error
12198 && last_loc != input_location)
12200 if (VOID_TYPE_P (type))
12201 error ("forming reference to void");
12202 else if (code == POINTER_TYPE)
12203 error ("forming pointer to reference type %qT", type);
12205 error ("forming reference to reference type %qT", type);
12206 last_loc = input_location;
12209 return error_mark_node;
12211 else if (TREE_CODE (type) == FUNCTION_TYPE
12212 && (type_memfn_quals (type) != TYPE_UNQUALIFIED
12213 || type_memfn_rqual (type) != REF_QUAL_NONE))
12215 if (complain & tf_error)
12217 if (code == POINTER_TYPE)
12218 error ("forming pointer to qualified function type %qT",
12221 error ("forming reference to qualified function type %qT",
12224 return error_mark_node;
12226 else if (code == POINTER_TYPE)
12228 r = build_pointer_type (type);
12229 if (TREE_CODE (type) == METHOD_TYPE)
12230 r = build_ptrmemfunc_type (r);
12232 else if (TREE_CODE (type) == REFERENCE_TYPE)
12233 /* In C++0x, during template argument substitution, when there is an
12234 attempt to create a reference to a reference type, reference
12235 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
12237 "If a template-argument for a template-parameter T names a type
12238 that is a reference to a type A, an attempt to create the type
12239 'lvalue reference to cv T' creates the type 'lvalue reference to
12240 A,' while an attempt to create the type type rvalue reference to
12241 cv T' creates the type T"
12243 r = cp_build_reference_type
12245 TYPE_REF_IS_RVALUE (t) && TYPE_REF_IS_RVALUE (type));
12247 r = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
12248 r = cp_build_qualified_type_real (r, cp_type_quals (t), complain);
12250 if (r != error_mark_node)
12251 /* Will this ever be needed for TYPE_..._TO values? */
12258 r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
12259 if (r == error_mark_node || !MAYBE_CLASS_TYPE_P (r))
12263 Type deduction may fail for any of the following
12266 -- Attempting to create "pointer to member of T" when T
12267 is not a class type. */
12268 if (complain & tf_error)
12269 error ("creating pointer to member of non-class type %qT", r);
12270 return error_mark_node;
12272 if (TREE_CODE (type) == REFERENCE_TYPE)
12274 if (complain & tf_error)
12275 error ("creating pointer to member reference type %qT", type);
12276 return error_mark_node;
12278 if (VOID_TYPE_P (type))
12280 if (complain & tf_error)
12281 error ("creating pointer to member of type void");
12282 return error_mark_node;
12284 gcc_assert (TREE_CODE (type) != METHOD_TYPE);
12285 if (TREE_CODE (type) == FUNCTION_TYPE)
12287 /* The type of the implicit object parameter gets its
12288 cv-qualifiers from the FUNCTION_TYPE. */
12291 = build_memfn_type (type, r, type_memfn_quals (type),
12292 type_memfn_rqual (type));
12293 memptr = build_ptrmemfunc_type (build_pointer_type (method_type));
12294 return cp_build_qualified_type_real (memptr, cp_type_quals (t),
12298 return cp_build_qualified_type_real (build_ptrmem_type (r, type),
12302 case FUNCTION_TYPE:
12307 fntype = tsubst_function_type (t, args, complain, in_decl);
12308 if (fntype == error_mark_node)
12309 return error_mark_node;
12311 /* Substitute the exception specification. */
12312 specs = tsubst_exception_specification (t, args, complain,
12313 in_decl, /*defer_ok*/true);
12314 if (specs == error_mark_node)
12315 return error_mark_node;
12317 fntype = build_exception_variant (fntype, specs);
12322 tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
12323 if (domain == error_mark_node)
12324 return error_mark_node;
12326 /* As an optimization, we avoid regenerating the array type if
12327 it will obviously be the same as T. */
12328 if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
12331 /* These checks should match the ones in create_array_type_for_decl.
12335 The deduction may fail for any of the following reasons:
12337 -- Attempting to create an array with an element type that
12338 is void, a function type, or a reference type, or [DR337]
12339 an abstract class type. */
12340 if (VOID_TYPE_P (type)
12341 || TREE_CODE (type) == FUNCTION_TYPE
12342 || (TREE_CODE (type) == ARRAY_TYPE
12343 && TYPE_DOMAIN (type) == NULL_TREE)
12344 || TREE_CODE (type) == REFERENCE_TYPE)
12346 if (complain & tf_error)
12347 error ("creating array of %qT", type);
12348 return error_mark_node;
12351 if (abstract_virtuals_error_sfinae (ACU_ARRAY, type, complain))
12352 return error_mark_node;
12354 r = build_cplus_array_type (type, domain);
12356 if (TYPE_USER_ALIGN (t))
12358 TYPE_ALIGN (r) = TYPE_ALIGN (t);
12359 TYPE_USER_ALIGN (r) = 1;
12365 case TYPENAME_TYPE:
12367 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
12368 in_decl, /*entering_scope=*/1);
12369 tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
12370 complain, in_decl);
12372 if (ctx == error_mark_node || f == error_mark_node)
12373 return error_mark_node;
12375 if (!MAYBE_CLASS_TYPE_P (ctx))
12377 if (complain & tf_error)
12378 error ("%qT is not a class, struct, or union type", ctx);
12379 return error_mark_node;
12381 else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
12383 /* Normally, make_typename_type does not require that the CTX
12384 have complete type in order to allow things like:
12386 template <class T> struct S { typename S<T>::X Y; };
12388 But, such constructs have already been resolved by this
12389 point, so here CTX really should have complete type, unless
12390 it's a partial instantiation. */
12391 ctx = complete_type (ctx);
12392 if (!COMPLETE_TYPE_P (ctx))
12394 if (complain & tf_error)
12395 cxx_incomplete_type_error (NULL_TREE, ctx);
12396 return error_mark_node;
12400 f = make_typename_type (ctx, f, typename_type,
12401 complain | tf_keep_type_decl);
12402 if (f == error_mark_node)
12404 if (TREE_CODE (f) == TYPE_DECL)
12406 complain |= tf_ignore_bad_quals;
12410 if (TREE_CODE (f) != TYPENAME_TYPE)
12412 if (TYPENAME_IS_ENUM_P (t) && TREE_CODE (f) != ENUMERAL_TYPE)
12414 if (complain & tf_error)
12415 error ("%qT resolves to %qT, which is not an enumeration type",
12418 return error_mark_node;
12420 else if (TYPENAME_IS_CLASS_P (t) && !CLASS_TYPE_P (f))
12422 if (complain & tf_error)
12423 error ("%qT resolves to %qT, which is is not a class type",
12426 return error_mark_node;
12430 return cp_build_qualified_type_real
12431 (f, cp_type_quals (f) | cp_type_quals (t), complain);
12434 case UNBOUND_CLASS_TEMPLATE:
12436 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
12437 in_decl, /*entering_scope=*/1);
12438 tree name = TYPE_IDENTIFIER (t);
12439 tree parm_list = DECL_TEMPLATE_PARMS (TYPE_NAME (t));
12441 if (ctx == error_mark_node || name == error_mark_node)
12442 return error_mark_node;
12445 parm_list = tsubst_template_parms (parm_list, args, complain);
12446 return make_unbound_class_template (ctx, name, parm_list, complain);
12453 ++cp_unevaluated_operand;
12454 ++c_inhibit_evaluation_warnings;
12456 type = tsubst_expr (TYPEOF_TYPE_EXPR (t), args,
12458 /*integral_constant_expression_p=*/false);
12460 --cp_unevaluated_operand;
12461 --c_inhibit_evaluation_warnings;
12463 type = finish_typeof (type);
12464 return cp_build_qualified_type_real (type,
12466 | cp_type_quals (type),
12470 case DECLTYPE_TYPE:
12474 ++cp_unevaluated_operand;
12475 ++c_inhibit_evaluation_warnings;
12477 type = tsubst_copy_and_build (DECLTYPE_TYPE_EXPR (t), args,
12478 complain|tf_decltype, in_decl,
12479 /*function_p*/false,
12480 /*integral_constant_expression*/false);
12482 --cp_unevaluated_operand;
12483 --c_inhibit_evaluation_warnings;
12485 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t))
12486 type = lambda_capture_field_type (type,
12487 DECLTYPE_FOR_INIT_CAPTURE (t));
12488 else if (DECLTYPE_FOR_LAMBDA_PROXY (t))
12489 type = lambda_proxy_type (type);
12492 bool id = DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t);
12493 if (id && TREE_CODE (DECLTYPE_TYPE_EXPR (t)) == BIT_NOT_EXPR
12495 /* In a template ~id could be either a complement expression
12496 or an unqualified-id naming a destructor; if instantiating
12497 it produces an expression, it's not an id-expression or
12500 type = finish_decltype_type (type, id, complain);
12502 return cp_build_qualified_type_real (type,
12504 | cp_type_quals (type),
12505 complain | tf_ignore_bad_quals);
12508 case UNDERLYING_TYPE:
12510 tree type = tsubst (UNDERLYING_TYPE_TYPE (t), args,
12511 complain, in_decl);
12512 return finish_underlying_type (type);
12515 case TYPE_ARGUMENT_PACK:
12516 case NONTYPE_ARGUMENT_PACK:
12518 tree r = TYPE_P (t) ? cxx_make_type (code) : make_node (code);
12520 tsubst_template_args (ARGUMENT_PACK_ARGS (t),
12524 SET_ARGUMENT_PACK_ARGS (r, packed_out);
12526 /* For template nontype argument packs, also substitute into
12528 if (code == NONTYPE_ARGUMENT_PACK)
12529 TREE_TYPE (r) = tsubst (TREE_TYPE (t), args, complain, in_decl);
12548 /* We should use one of the expression tsubsts for these codes. */
12549 gcc_unreachable ();
12552 sorry ("use of %qs in template", get_tree_code_name (code));
12553 return error_mark_node;
12557 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
12558 type of the expression on the left-hand side of the "." or "->"
12562 tsubst_baselink (tree baselink, tree object_type,
12563 tree args, tsubst_flags_t complain, tree in_decl)
12566 tree qualifying_scope;
12569 tree template_args = 0;
12570 bool template_id_p = false;
12571 bool qualified = BASELINK_QUALIFIED_P (baselink);
12573 /* A baselink indicates a function from a base class. Both the
12574 BASELINK_ACCESS_BINFO and the base class referenced may
12575 indicate bases of the template class, rather than the
12576 instantiated class. In addition, lookups that were not
12577 ambiguous before may be ambiguous now. Therefore, we perform
12578 the lookup again. */
12579 qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink));
12580 qualifying_scope = tsubst (qualifying_scope, args,
12581 complain, in_decl);
12582 fns = BASELINK_FUNCTIONS (baselink);
12583 optype = tsubst (BASELINK_OPTYPE (baselink), args, complain, in_decl);
12584 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
12586 template_id_p = true;
12587 template_args = TREE_OPERAND (fns, 1);
12588 fns = TREE_OPERAND (fns, 0);
12590 template_args = tsubst_template_args (template_args, args,
12591 complain, in_decl);
12593 name = DECL_NAME (get_first_fn (fns));
12594 if (IDENTIFIER_TYPENAME_P (name))
12595 name = mangle_conv_op_name_for_type (optype);
12596 baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1);
12598 return error_mark_node;
12600 /* If lookup found a single function, mark it as used at this
12601 point. (If it lookup found multiple functions the one selected
12602 later by overload resolution will be marked as used at that
12604 if (BASELINK_P (baselink))
12605 fns = BASELINK_FUNCTIONS (baselink);
12606 if (!template_id_p && !really_overloaded_fn (fns))
12607 mark_used (OVL_CURRENT (fns));
12609 /* Add back the template arguments, if present. */
12610 if (BASELINK_P (baselink) && template_id_p)
12611 BASELINK_FUNCTIONS (baselink)
12612 = build_nt (TEMPLATE_ID_EXPR,
12613 BASELINK_FUNCTIONS (baselink),
12615 /* Update the conversion operator type. */
12616 BASELINK_OPTYPE (baselink) = optype;
12619 object_type = current_class_type;
12622 baselink = adjust_result_of_qualified_name_lookup (baselink,
12628 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
12629 true if the qualified-id will be a postfix-expression in-and-of
12630 itself; false if more of the postfix-expression follows the
12631 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
12635 tsubst_qualified_id (tree qualified_id, tree args,
12636 tsubst_flags_t complain, tree in_decl,
12637 bool done, bool address_p)
12643 tree template_args;
12644 location_t loc = UNKNOWN_LOCATION;
12646 gcc_assert (TREE_CODE (qualified_id) == SCOPE_REF);
12648 /* Figure out what name to look up. */
12649 name = TREE_OPERAND (qualified_id, 1);
12650 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
12652 is_template = true;
12653 loc = EXPR_LOCATION (name);
12654 template_args = TREE_OPERAND (name, 1);
12656 template_args = tsubst_template_args (template_args, args,
12657 complain, in_decl);
12658 name = TREE_OPERAND (name, 0);
12662 is_template = false;
12663 template_args = NULL_TREE;
12666 /* Substitute into the qualifying scope. When there are no ARGS, we
12667 are just trying to simplify a non-dependent expression. In that
12668 case the qualifying scope may be dependent, and, in any case,
12669 substituting will not help. */
12670 scope = TREE_OPERAND (qualified_id, 0);
12673 scope = tsubst (scope, args, complain, in_decl);
12674 expr = tsubst_copy (name, args, complain, in_decl);
12679 if (dependent_scope_p (scope))
12682 expr = build_min_nt_loc (loc, TEMPLATE_ID_EXPR, expr, template_args);
12683 return build_qualified_name (NULL_TREE, scope, expr,
12684 QUALIFIED_NAME_IS_TEMPLATE (qualified_id));
12687 if (!BASELINK_P (name) && !DECL_P (expr))
12689 if (TREE_CODE (expr) == BIT_NOT_EXPR)
12691 /* A BIT_NOT_EXPR is used to represent a destructor. */
12692 if (!check_dtor_name (scope, TREE_OPERAND (expr, 0)))
12694 error ("qualifying type %qT does not match destructor name ~%qT",
12695 scope, TREE_OPERAND (expr, 0));
12696 expr = error_mark_node;
12699 expr = lookup_qualified_name (scope, complete_dtor_identifier,
12700 /*is_type_p=*/0, false);
12703 expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0, false);
12704 if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL
12705 ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL)
12707 if (complain & tf_error)
12709 error ("dependent-name %qE is parsed as a non-type, but "
12710 "instantiation yields a type", qualified_id);
12711 inform (input_location, "say %<typename %E%> if a type is meant", qualified_id);
12713 return error_mark_node;
12719 check_accessibility_of_qualified_id (expr, /*object_type=*/NULL_TREE,
12721 /* Remember that there was a reference to this entity. */
12725 if (expr == error_mark_node || TREE_CODE (expr) == TREE_LIST)
12727 if (complain & tf_error)
12728 qualified_name_lookup_error (scope,
12729 TREE_OPERAND (qualified_id, 1),
12730 expr, input_location);
12731 return error_mark_node;
12735 expr = lookup_template_function (expr, template_args);
12737 if (expr == error_mark_node && complain & tf_error)
12738 qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1),
12739 expr, input_location);
12740 else if (TYPE_P (scope))
12742 expr = (adjust_result_of_qualified_name_lookup
12743 (expr, scope, current_nonlambda_class_type ()));
12744 expr = (finish_qualified_id_expr
12745 (scope, expr, done, address_p && PTRMEM_OK_P (qualified_id),
12746 QUALIFIED_NAME_IS_TEMPLATE (qualified_id),
12747 /*template_arg_p=*/false, complain));
12750 /* Expressions do not generally have reference type. */
12751 if (TREE_CODE (expr) != SCOPE_REF
12752 /* However, if we're about to form a pointer-to-member, we just
12753 want the referenced member referenced. */
12754 && TREE_CODE (expr) != OFFSET_REF)
12755 expr = convert_from_reference (expr);
12760 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
12761 initializer, DECL is the substituted VAR_DECL. Other arguments are as
12765 tsubst_init (tree init, tree decl, tree args,
12766 tsubst_flags_t complain, tree in_decl)
12771 init = tsubst_expr (init, args, complain, in_decl, false);
12775 /* If we had an initializer but it
12776 instantiated to nothing,
12777 value-initialize the object. This will
12778 only occur when the initializer was a
12779 pack expansion where the parameter packs
12780 used in that expansion were of length
12782 init = build_value_init (TREE_TYPE (decl),
12784 if (TREE_CODE (init) == AGGR_INIT_EXPR)
12785 init = get_target_expr_sfinae (init, complain);
12791 /* Like tsubst, but deals with expressions. This function just replaces
12792 template parms; to finish processing the resultant expression, use
12793 tsubst_copy_and_build or tsubst_expr. */
12796 tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
12798 enum tree_code code;
12801 if (t == NULL_TREE || t == error_mark_node || args == NULL_TREE)
12804 code = TREE_CODE (t);
12809 r = retrieve_local_specialization (t);
12811 if (r == NULL_TREE)
12813 /* We get here for a use of 'this' in an NSDMI. */
12814 if (DECL_NAME (t) == this_identifier
12815 && current_function_decl
12816 && DECL_CONSTRUCTOR_P (current_function_decl))
12817 return current_class_ptr;
12819 /* This can happen for a parameter name used later in a function
12820 declaration (such as in a late-specified return type). Just
12821 make a dummy decl, since it's only used for its type. */
12822 gcc_assert (cp_unevaluated_operand != 0);
12823 r = tsubst_decl (t, args, complain);
12824 /* Give it the template pattern as its context; its true context
12825 hasn't been instantiated yet and this is good enough for
12827 DECL_CONTEXT (r) = DECL_CONTEXT (t);
12830 if (TREE_CODE (r) == ARGUMENT_PACK_SELECT)
12831 r = ARGUMENT_PACK_SELECT_ARG (r);
12840 if (DECL_TEMPLATE_PARM_P (t))
12841 return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
12842 /* There is no need to substitute into namespace-scope
12844 if (DECL_NAMESPACE_SCOPE_P (t))
12846 /* If ARGS is NULL, then T is known to be non-dependent. */
12847 if (args == NULL_TREE)
12848 return scalar_constant_value (t);
12850 /* Unfortunately, we cannot just call lookup_name here.
12853 template <int I> int f() {
12855 struct S { void g() { E e = a; } };
12858 When we instantiate f<7>::S::g(), say, lookup_name is not
12859 clever enough to find f<7>::a. */
12861 = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
12862 /*entering_scope=*/0);
12864 for (v = TYPE_VALUES (enum_type);
12866 v = TREE_CHAIN (v))
12867 if (TREE_PURPOSE (v) == DECL_NAME (t))
12868 return TREE_VALUE (v);
12870 /* We didn't find the name. That should never happen; if
12871 name-lookup found it during preliminary parsing, we
12872 should find it again here during instantiation. */
12873 gcc_unreachable ();
12878 if (PACK_EXPANSION_P (TREE_TYPE (t)))
12880 /* Check for a local specialization set up by
12881 tsubst_pack_expansion. */
12882 if (tree r = retrieve_local_specialization (t))
12884 if (TREE_CODE (r) == ARGUMENT_PACK_SELECT)
12885 r = ARGUMENT_PACK_SELECT_ARG (r);
12889 /* When retrieving a capture pack from a generic lambda, remove the
12890 lambda call op's own template argument list from ARGS. Only the
12891 template arguments active for the closure type should be used to
12892 retrieve the pack specialization. */
12893 if (LAMBDA_FUNCTION_P (current_function_decl)
12894 && (template_class_depth (DECL_CONTEXT (t))
12895 != TMPL_ARGS_DEPTH (args)))
12896 args = strip_innermost_template_args (args, 1);
12898 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
12899 tsubst_decl put in the hash table. */
12900 return retrieve_specialization (t, args, 0);
12903 if (DECL_CONTEXT (t))
12907 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
12908 /*entering_scope=*/1);
12909 if (ctx != DECL_CONTEXT (t))
12911 tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
12914 if (complain & tf_error)
12915 error ("using invalid field %qD", t);
12916 return error_mark_node;
12925 case FUNCTION_DECL:
12926 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
12927 r = tsubst (t, args, complain, in_decl);
12928 else if (local_variable_p (t))
12930 r = retrieve_local_specialization (t);
12931 if (r == NULL_TREE)
12933 /* First try name lookup to find the instantiation. */
12934 r = lookup_name (DECL_NAME (t));
12937 /* Make sure that the one we found is the one we want. */
12938 tree ctx = tsubst (DECL_CONTEXT (t), args,
12939 complain, in_decl);
12940 if (ctx != DECL_CONTEXT (r))
12948 /* This can happen for a variable used in a
12949 late-specified return type of a local lambda, or for a
12950 local static or constant. Building a new VAR_DECL
12951 should be OK in all those cases. */
12952 r = tsubst_decl (t, args, complain);
12953 if (decl_maybe_constant_var_p (r))
12955 /* We can't call cp_finish_decl, so handle the
12956 initializer by hand. */
12957 tree init = tsubst_init (DECL_INITIAL (t), r, args,
12958 complain, in_decl);
12959 if (!processing_template_decl)
12960 init = maybe_constant_init (init);
12961 if (processing_template_decl
12962 ? potential_constant_expression (init)
12963 : reduced_constant_expression_p (init))
12964 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
12965 = TREE_CONSTANT (r) = true;
12966 DECL_INITIAL (r) = init;
12968 gcc_assert (cp_unevaluated_operand || TREE_STATIC (r)
12969 || decl_constant_var_p (r)
12970 || errorcount || sorrycount);
12971 if (!processing_template_decl)
12973 if (TREE_STATIC (r))
12974 rest_of_decl_compilation (r, toplevel_bindings_p (),
12976 else if (decl_constant_var_p (r))
12977 /* A use of a local constant decays to its value.
12978 FIXME update for core DR 696. */
12979 r = scalar_constant_value (r);
12982 /* Remember this for subsequent uses. */
12983 if (local_specializations)
12984 register_local_specialization (r, t);
12992 case NAMESPACE_DECL:
12996 /* An OVERLOAD will always be a non-dependent overload set; an
12997 overload set from function scope will just be represented with an
12998 IDENTIFIER_NODE, and from class scope with a BASELINK. */
12999 gcc_assert (!uses_template_parms (t));
13003 return tsubst_baselink (t, current_nonlambda_class_type (),
13004 args, complain, in_decl);
13006 case TEMPLATE_DECL:
13007 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
13008 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
13009 args, complain, in_decl);
13010 else if (DECL_FUNCTION_TEMPLATE_P (t) && DECL_MEMBER_TEMPLATE_P (t))
13011 return tsubst (t, args, complain, in_decl);
13012 else if (DECL_CLASS_SCOPE_P (t)
13013 && uses_template_parms (DECL_CONTEXT (t)))
13015 /* Template template argument like the following example need
13018 template <template <class> class TT> struct C {};
13019 template <class T> struct D {
13020 template <class U> struct E {};
13025 We are processing the template argument `E' in #1 for
13026 the template instantiation #2. Originally, `E' is a
13027 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
13028 have to substitute this with one having context `D<int>'. */
13030 tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
13031 return lookup_field (context, DECL_NAME(t), 0, false);
13034 /* Ordinary template template argument. */
13038 case REINTERPRET_CAST_EXPR:
13039 case CONST_CAST_EXPR:
13040 case STATIC_CAST_EXPR:
13041 case DYNAMIC_CAST_EXPR:
13042 case IMPLICIT_CONV_EXPR:
13046 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
13047 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
13048 return build1 (code, type, op0);
13052 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
13055 tree expanded, op = TREE_OPERAND (t, 0);
13058 if (SIZEOF_EXPR_TYPE_P (t))
13059 op = TREE_TYPE (op);
13061 ++cp_unevaluated_operand;
13062 ++c_inhibit_evaluation_warnings;
13063 /* We only want to compute the number of arguments. */
13064 expanded = tsubst_pack_expansion (op, args, complain, in_decl);
13065 --cp_unevaluated_operand;
13066 --c_inhibit_evaluation_warnings;
13068 if (TREE_CODE (expanded) == TREE_VEC)
13069 len = TREE_VEC_LENGTH (expanded);
13071 if (expanded == error_mark_node)
13072 return error_mark_node;
13073 else if (PACK_EXPANSION_P (expanded)
13074 || (TREE_CODE (expanded) == TREE_VEC
13076 && PACK_EXPANSION_P (TREE_VEC_ELT (expanded, len-1))))
13078 if (TREE_CODE (expanded) == TREE_VEC)
13079 expanded = TREE_VEC_ELT (expanded, len - 1);
13081 if (TYPE_P (expanded))
13082 return cxx_sizeof_or_alignof_type (expanded, SIZEOF_EXPR,
13083 complain & tf_error);
13085 return cxx_sizeof_or_alignof_expr (expanded, SIZEOF_EXPR,
13086 complain & tf_error);
13089 return build_int_cst (size_type_node, len);
13091 if (SIZEOF_EXPR_TYPE_P (t))
13093 r = tsubst (TREE_TYPE (TREE_OPERAND (t, 0)),
13094 args, complain, in_decl);
13095 r = build1 (NOP_EXPR, r, error_mark_node);
13096 r = build1 (SIZEOF_EXPR,
13097 tsubst (TREE_TYPE (t), args, complain, in_decl), r);
13098 SIZEOF_EXPR_TYPE_P (r) = 1;
13105 case TRUTH_NOT_EXPR:
13108 case UNARY_PLUS_EXPR: /* Unary + */
13110 case AT_ENCODE_EXPR:
13114 case REALPART_EXPR:
13115 case IMAGPART_EXPR:
13118 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
13119 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
13120 return build1 (code, type, op0);
13123 case COMPONENT_REF:
13128 object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
13129 name = TREE_OPERAND (t, 1);
13130 if (TREE_CODE (name) == BIT_NOT_EXPR)
13132 name = tsubst_copy (TREE_OPERAND (name, 0), args,
13133 complain, in_decl);
13134 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
13136 else if (TREE_CODE (name) == SCOPE_REF
13137 && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
13139 tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
13140 complain, in_decl);
13141 name = TREE_OPERAND (name, 1);
13142 name = tsubst_copy (TREE_OPERAND (name, 0), args,
13143 complain, in_decl);
13144 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
13145 name = build_qualified_name (/*type=*/NULL_TREE,
13147 /*template_p=*/false);
13149 else if (BASELINK_P (name))
13150 name = tsubst_baselink (name,
13151 non_reference (TREE_TYPE (object)),
13155 name = tsubst_copy (name, args, complain, in_decl);
13156 return build_nt (COMPONENT_REF, object, name, NULL_TREE);
13162 case TRUNC_DIV_EXPR:
13163 case CEIL_DIV_EXPR:
13164 case FLOOR_DIV_EXPR:
13165 case ROUND_DIV_EXPR:
13166 case EXACT_DIV_EXPR:
13170 case TRUNC_MOD_EXPR:
13171 case FLOOR_MOD_EXPR:
13172 case TRUTH_ANDIF_EXPR:
13173 case TRUTH_ORIF_EXPR:
13174 case TRUTH_AND_EXPR:
13175 case TRUTH_OR_EXPR:
13188 case COMPOUND_EXPR:
13191 case PREDECREMENT_EXPR:
13192 case PREINCREMENT_EXPR:
13193 case POSTDECREMENT_EXPR:
13194 case POSTINCREMENT_EXPR:
13196 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
13197 tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
13198 return build_nt (code, op0, op1);
13203 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
13204 tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
13205 return build_qualified_name (/*type=*/NULL_TREE, op0, op1,
13206 QUALIFIED_NAME_IS_TEMPLATE (t));
13211 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
13212 tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
13213 return build_nt (ARRAY_REF, op0, op1, NULL_TREE, NULL_TREE);
13218 int n = VL_EXP_OPERAND_LENGTH (t);
13219 tree result = build_vl_exp (CALL_EXPR, n);
13221 for (i = 0; i < n; i++)
13222 TREE_OPERAND (t, i) = tsubst_copy (TREE_OPERAND (t, i), args,
13223 complain, in_decl);
13229 case PSEUDO_DTOR_EXPR:
13230 case VEC_PERM_EXPR:
13232 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
13233 tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
13234 tree op2 = tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl);
13235 r = build_nt (code, op0, op1, op2);
13236 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
13242 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
13243 tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
13244 tree op2 = tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl);
13245 r = build_nt (code, op0, op1, op2);
13246 NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
13252 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
13253 tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
13254 r = build_nt (code, op0, op1);
13255 DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
13256 DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
13260 case TEMPLATE_ID_EXPR:
13262 /* Substituted template arguments */
13263 tree fn = TREE_OPERAND (t, 0);
13264 tree targs = TREE_OPERAND (t, 1);
13266 fn = tsubst_copy (fn, args, complain, in_decl);
13268 targs = tsubst_template_args (targs, args, complain, in_decl);
13270 return lookup_template_function (fn, targs);
13275 tree purpose, value, chain;
13277 if (t == void_list_node)
13280 purpose = TREE_PURPOSE (t);
13282 purpose = tsubst_copy (purpose, args, complain, in_decl);
13283 value = TREE_VALUE (t);
13285 value = tsubst_copy (value, args, complain, in_decl);
13286 chain = TREE_CHAIN (t);
13287 if (chain && chain != void_type_node)
13288 chain = tsubst_copy (chain, args, complain, in_decl);
13289 if (purpose == TREE_PURPOSE (t)
13290 && value == TREE_VALUE (t)
13291 && chain == TREE_CHAIN (t))
13293 return tree_cons (purpose, value, chain);
13298 case ENUMERAL_TYPE:
13300 case TEMPLATE_TYPE_PARM:
13301 case TEMPLATE_TEMPLATE_PARM:
13302 case BOUND_TEMPLATE_TEMPLATE_PARM:
13303 case TEMPLATE_PARM_INDEX:
13305 case REFERENCE_TYPE:
13307 case FUNCTION_TYPE:
13310 case TYPENAME_TYPE:
13311 case UNBOUND_CLASS_TEMPLATE:
13313 case DECLTYPE_TYPE:
13315 return tsubst (t, args, complain, in_decl);
13319 /* Fall through. */
13320 case IDENTIFIER_NODE:
13321 if (IDENTIFIER_TYPENAME_P (t))
13323 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
13324 return mangle_conv_op_name_for_type (new_type);
13330 /* This is handled by tsubst_copy_and_build. */
13331 gcc_unreachable ();
13335 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
13336 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
13337 return build_x_va_arg (EXPR_LOCATION (t), op0, type);
13340 case CLEANUP_POINT_EXPR:
13341 /* We shouldn't have built any of these during initial template
13342 generation. Instead, they should be built during instantiation
13343 in response to the saved STMT_IS_FULL_EXPR_P setting. */
13344 gcc_unreachable ();
13348 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
13349 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
13350 tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
13351 r = build2 (code, type, op0, op1);
13352 PTRMEM_OK_P (r) = PTRMEM_OK_P (t);
13353 mark_used (TREE_OPERAND (r, 1));
13357 case EXPR_PACK_EXPANSION:
13358 error ("invalid use of pack expansion expression");
13359 return error_mark_node;
13361 case NONTYPE_ARGUMENT_PACK:
13362 error ("use %<...%> to expand argument pack");
13363 return error_mark_node;
13366 gcc_checking_assert (t == void_node && VOID_TYPE_P (TREE_TYPE (t)));
13374 /* Instantiate any typedefs in the type. */
13375 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
13376 r = fold_convert (type, t);
13377 gcc_assert (TREE_CODE (r) == code);
13382 /* These can sometimes show up in a partial instantiation, but never
13383 involve template parms. */
13384 gcc_assert (!uses_template_parms (t));
13388 /* We shouldn't get here, but keep going if !ENABLE_CHECKING. */
13389 gcc_checking_assert (false);
13394 /* Like tsubst_copy, but specifically for OpenMP clauses. */
13397 tsubst_omp_clauses (tree clauses, bool declare_simd,
13398 tree args, tsubst_flags_t complain, tree in_decl)
13400 tree new_clauses = NULL, nc, oc;
13402 for (oc = clauses; oc ; oc = OMP_CLAUSE_CHAIN (oc))
13404 nc = copy_node (oc);
13405 OMP_CLAUSE_CHAIN (nc) = new_clauses;
13408 switch (OMP_CLAUSE_CODE (nc))
13410 case OMP_CLAUSE_LASTPRIVATE:
13411 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc))
13413 OMP_CLAUSE_LASTPRIVATE_STMT (nc) = push_stmt_list ();
13414 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc), args, complain,
13415 in_decl, /*integral_constant_expression_p=*/false);
13416 OMP_CLAUSE_LASTPRIVATE_STMT (nc)
13417 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc));
13420 case OMP_CLAUSE_PRIVATE:
13421 case OMP_CLAUSE_SHARED:
13422 case OMP_CLAUSE_FIRSTPRIVATE:
13423 case OMP_CLAUSE_COPYIN:
13424 case OMP_CLAUSE_COPYPRIVATE:
13425 case OMP_CLAUSE_IF:
13426 case OMP_CLAUSE_NUM_THREADS:
13427 case OMP_CLAUSE_SCHEDULE:
13428 case OMP_CLAUSE_COLLAPSE:
13429 case OMP_CLAUSE_FINAL:
13430 case OMP_CLAUSE_DEPEND:
13431 case OMP_CLAUSE_FROM:
13432 case OMP_CLAUSE_TO:
13433 case OMP_CLAUSE_UNIFORM:
13434 case OMP_CLAUSE_MAP:
13435 case OMP_CLAUSE_DEVICE:
13436 case OMP_CLAUSE_DIST_SCHEDULE:
13437 case OMP_CLAUSE_NUM_TEAMS:
13438 case OMP_CLAUSE_THREAD_LIMIT:
13439 case OMP_CLAUSE_SAFELEN:
13440 case OMP_CLAUSE_SIMDLEN:
13441 OMP_CLAUSE_OPERAND (nc, 0)
13442 = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 0), args, complain,
13443 in_decl, /*integral_constant_expression_p=*/false);
13445 case OMP_CLAUSE_REDUCTION:
13446 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc))
13448 tree placeholder = OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc);
13449 if (TREE_CODE (placeholder) == SCOPE_REF)
13451 tree scope = tsubst (TREE_OPERAND (placeholder, 0), args,
13452 complain, in_decl);
13453 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc)
13454 = build_qualified_name (NULL_TREE, scope,
13455 TREE_OPERAND (placeholder, 1),
13459 gcc_assert (identifier_p (placeholder));
13461 OMP_CLAUSE_OPERAND (nc, 0)
13462 = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 0), args, complain,
13463 in_decl, /*integral_constant_expression_p=*/false);
13465 case OMP_CLAUSE_LINEAR:
13466 case OMP_CLAUSE_ALIGNED:
13467 OMP_CLAUSE_OPERAND (nc, 0)
13468 = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 0), args, complain,
13469 in_decl, /*integral_constant_expression_p=*/false);
13470 OMP_CLAUSE_OPERAND (nc, 1)
13471 = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 1), args, complain,
13472 in_decl, /*integral_constant_expression_p=*/false);
13475 case OMP_CLAUSE_NOWAIT:
13476 case OMP_CLAUSE_ORDERED:
13477 case OMP_CLAUSE_DEFAULT:
13478 case OMP_CLAUSE_UNTIED:
13479 case OMP_CLAUSE_MERGEABLE:
13480 case OMP_CLAUSE_INBRANCH:
13481 case OMP_CLAUSE_NOTINBRANCH:
13482 case OMP_CLAUSE_PROC_BIND:
13483 case OMP_CLAUSE_FOR:
13484 case OMP_CLAUSE_PARALLEL:
13485 case OMP_CLAUSE_SECTIONS:
13486 case OMP_CLAUSE_TASKGROUP:
13489 gcc_unreachable ();
13493 new_clauses = nreverse (new_clauses);
13495 new_clauses = finish_omp_clauses (new_clauses);
13496 return new_clauses;
13499 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
13502 tsubst_copy_asm_operands (tree t, tree args, tsubst_flags_t complain,
13505 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
13507 tree purpose, value, chain;
13512 if (TREE_CODE (t) != TREE_LIST)
13513 return tsubst_copy_and_build (t, args, complain, in_decl,
13514 /*function_p=*/false,
13515 /*integral_constant_expression_p=*/false);
13517 if (t == void_list_node)
13520 purpose = TREE_PURPOSE (t);
13522 purpose = RECUR (purpose);
13523 value = TREE_VALUE (t);
13526 if (TREE_CODE (value) != LABEL_DECL)
13527 value = RECUR (value);
13530 value = lookup_label (DECL_NAME (value));
13531 gcc_assert (TREE_CODE (value) == LABEL_DECL);
13532 TREE_USED (value) = 1;
13535 chain = TREE_CHAIN (t);
13536 if (chain && chain != void_type_node)
13537 chain = RECUR (chain);
13538 return tree_cons (purpose, value, chain);
13542 /* Substitute one OMP_FOR iterator. */
13545 tsubst_omp_for_iterator (tree t, int i, tree declv, tree initv,
13546 tree condv, tree incrv, tree *clauses,
13547 tree args, tsubst_flags_t complain, tree in_decl,
13548 bool integral_constant_expression_p)
13550 #define RECUR(NODE) \
13551 tsubst_expr ((NODE), args, complain, in_decl, \
13552 integral_constant_expression_p)
13553 tree decl, init, cond, incr;
13555 init = TREE_VEC_ELT (OMP_FOR_INIT (t), i);
13556 gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
13557 decl = TREE_OPERAND (init, 0);
13558 init = TREE_OPERAND (init, 1);
13559 tree decl_expr = NULL_TREE;
13560 if (init && TREE_CODE (init) == DECL_EXPR)
13562 /* We need to jump through some hoops to handle declarations in the
13563 for-init-statement, since we might need to handle auto deduction,
13564 but we need to keep control of initialization. */
13566 init = DECL_INITIAL (DECL_EXPR_DECL (init));
13567 decl = tsubst_decl (decl, args, complain);
13570 decl = RECUR (decl);
13571 init = RECUR (init);
13573 tree auto_node = type_uses_auto (TREE_TYPE (decl));
13574 if (auto_node && init)
13576 = do_auto_deduction (TREE_TYPE (decl), init, auto_node);
13578 gcc_assert (!type_dependent_expression_p (decl));
13580 if (!CLASS_TYPE_P (TREE_TYPE (decl)))
13584 /* Declare the variable, but don't let that initialize it. */
13585 tree init_sav = DECL_INITIAL (DECL_EXPR_DECL (decl_expr));
13586 DECL_INITIAL (DECL_EXPR_DECL (decl_expr)) = NULL_TREE;
13588 DECL_INITIAL (DECL_EXPR_DECL (decl_expr)) = init_sav;
13591 cond = RECUR (TREE_VEC_ELT (OMP_FOR_COND (t), i));
13592 incr = TREE_VEC_ELT (OMP_FOR_INCR (t), i);
13593 if (TREE_CODE (incr) == MODIFY_EXPR)
13595 tree lhs = RECUR (TREE_OPERAND (incr, 0));
13596 tree rhs = RECUR (TREE_OPERAND (incr, 1));
13597 incr = build_x_modify_expr (EXPR_LOCATION (incr), lhs,
13598 NOP_EXPR, rhs, complain);
13601 incr = RECUR (incr);
13602 TREE_VEC_ELT (declv, i) = decl;
13603 TREE_VEC_ELT (initv, i) = init;
13604 TREE_VEC_ELT (condv, i) = cond;
13605 TREE_VEC_ELT (incrv, i) = incr;
13611 /* Declare and initialize the variable. */
13618 for (c = *clauses; c ; c = OMP_CLAUSE_CHAIN (c))
13620 if ((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_PRIVATE
13621 || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE)
13622 && OMP_CLAUSE_DECL (c) == decl)
13624 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
13625 && OMP_CLAUSE_DECL (c) == decl)
13626 error ("iteration variable %qD should not be firstprivate", decl);
13627 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
13628 && OMP_CLAUSE_DECL (c) == decl)
13629 error ("iteration variable %qD should not be reduction", decl);
13633 c = build_omp_clause (input_location, OMP_CLAUSE_PRIVATE);
13634 OMP_CLAUSE_DECL (c) = decl;
13635 c = finish_omp_clauses (c);
13638 OMP_CLAUSE_CHAIN (c) = *clauses;
13643 cond = TREE_VEC_ELT (OMP_FOR_COND (t), i);
13644 if (COMPARISON_CLASS_P (cond))
13646 tree op0 = RECUR (TREE_OPERAND (cond, 0));
13647 tree op1 = RECUR (TREE_OPERAND (cond, 1));
13648 cond = build2 (TREE_CODE (cond), boolean_type_node, op0, op1);
13651 cond = RECUR (cond);
13652 incr = TREE_VEC_ELT (OMP_FOR_INCR (t), i);
13653 switch (TREE_CODE (incr))
13655 case PREINCREMENT_EXPR:
13656 case PREDECREMENT_EXPR:
13657 case POSTINCREMENT_EXPR:
13658 case POSTDECREMENT_EXPR:
13659 incr = build2 (TREE_CODE (incr), TREE_TYPE (decl),
13660 RECUR (TREE_OPERAND (incr, 0)), NULL_TREE);
13663 if (TREE_CODE (TREE_OPERAND (incr, 1)) == PLUS_EXPR
13664 || TREE_CODE (TREE_OPERAND (incr, 1)) == MINUS_EXPR)
13666 tree rhs = TREE_OPERAND (incr, 1);
13667 tree lhs = RECUR (TREE_OPERAND (incr, 0));
13668 tree rhs0 = RECUR (TREE_OPERAND (rhs, 0));
13669 tree rhs1 = RECUR (TREE_OPERAND (rhs, 1));
13670 incr = build2 (MODIFY_EXPR, TREE_TYPE (decl), lhs,
13671 build2 (TREE_CODE (rhs), TREE_TYPE (decl),
13675 incr = RECUR (incr);
13678 if (TREE_CODE (TREE_OPERAND (incr, 1)) == PLUS_EXPR
13679 || TREE_CODE (TREE_OPERAND (incr, 1)) == MINUS_EXPR)
13681 tree lhs = RECUR (TREE_OPERAND (incr, 0));
13682 incr = build2 (MODIFY_EXPR, TREE_TYPE (decl), lhs,
13683 build2 (TREE_CODE (TREE_OPERAND (incr, 1)),
13684 TREE_TYPE (decl), lhs,
13685 RECUR (TREE_OPERAND (incr, 2))));
13687 else if (TREE_CODE (TREE_OPERAND (incr, 1)) == NOP_EXPR
13688 && (TREE_CODE (TREE_OPERAND (incr, 2)) == PLUS_EXPR
13689 || (TREE_CODE (TREE_OPERAND (incr, 2)) == MINUS_EXPR)))
13691 tree rhs = TREE_OPERAND (incr, 2);
13692 tree lhs = RECUR (TREE_OPERAND (incr, 0));
13693 tree rhs0 = RECUR (TREE_OPERAND (rhs, 0));
13694 tree rhs1 = RECUR (TREE_OPERAND (rhs, 1));
13695 incr = build2 (MODIFY_EXPR, TREE_TYPE (decl), lhs,
13696 build2 (TREE_CODE (rhs), TREE_TYPE (decl),
13700 incr = RECUR (incr);
13703 incr = RECUR (incr);
13707 TREE_VEC_ELT (declv, i) = decl;
13708 TREE_VEC_ELT (initv, i) = init;
13709 TREE_VEC_ELT (condv, i) = cond;
13710 TREE_VEC_ELT (incrv, i) = incr;
13714 /* Like tsubst_copy for expressions, etc. but also does semantic
13718 tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl,
13719 bool integral_constant_expression_p)
13721 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
13722 #define RECUR(NODE) \
13723 tsubst_expr ((NODE), args, complain, in_decl, \
13724 integral_constant_expression_p)
13730 if (t == NULL_TREE || t == error_mark_node)
13733 loc = input_location;
13734 if (EXPR_HAS_LOCATION (t))
13735 input_location = EXPR_LOCATION (t);
13736 if (STATEMENT_CODE_P (TREE_CODE (t)))
13737 current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
13739 switch (TREE_CODE (t))
13741 case STATEMENT_LIST:
13743 tree_stmt_iterator i;
13744 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
13745 RECUR (tsi_stmt (i));
13749 case CTOR_INITIALIZER:
13750 finish_mem_initializers (tsubst_initializer_list
13751 (TREE_OPERAND (t, 0), args));
13755 finish_return_stmt (RECUR (TREE_OPERAND (t, 0)));
13759 tmp = RECUR (EXPR_STMT_EXPR (t));
13760 if (EXPR_STMT_STMT_EXPR_RESULT (t))
13761 finish_stmt_expr_expr (tmp, cur_stmt_expr);
13763 finish_expr_stmt (tmp);
13767 do_using_directive (USING_STMT_NAMESPACE (t));
13772 tree decl, pattern_decl;
13775 pattern_decl = decl = DECL_EXPR_DECL (t);
13776 if (TREE_CODE (decl) == LABEL_DECL)
13777 finish_label_decl (DECL_NAME (decl));
13778 else if (TREE_CODE (decl) == USING_DECL)
13780 tree scope = USING_DECL_SCOPE (decl);
13781 tree name = DECL_NAME (decl);
13784 scope = tsubst (scope, args, complain, in_decl);
13785 decl = lookup_qualified_name (scope, name,
13786 /*is_type_p=*/false,
13787 /*complain=*/false);
13788 if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
13789 qualified_name_lookup_error (scope, name, decl, input_location);
13791 do_local_using_decl (decl, scope, name);
13793 else if (DECL_PACK_P (decl))
13795 /* Don't build up decls for a variadic capture proxy, we'll
13796 instantiate the elements directly as needed. */
13801 init = DECL_INITIAL (decl);
13802 decl = tsubst (decl, args, complain, in_decl);
13803 if (decl != error_mark_node)
13805 /* By marking the declaration as instantiated, we avoid
13806 trying to instantiate it. Since instantiate_decl can't
13807 handle local variables, and since we've already done
13808 all that needs to be done, that's the right thing to
13811 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
13813 && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
13814 /* Anonymous aggregates are a special case. */
13815 finish_anon_union (decl);
13816 else if (is_capture_proxy (DECL_EXPR_DECL (t)))
13818 DECL_CONTEXT (decl) = current_function_decl;
13819 if (DECL_NAME (decl) == this_identifier)
13821 tree lam = DECL_CONTEXT (current_function_decl);
13822 lam = CLASSTYPE_LAMBDA_EXPR (lam);
13823 LAMBDA_EXPR_THIS_CAPTURE (lam) = decl;
13825 insert_capture_proxy (decl);
13827 else if (DECL_IMPLICIT_TYPEDEF_P (t))
13828 /* We already did a pushtag. */;
13829 else if (TREE_CODE (decl) == FUNCTION_DECL
13830 && DECL_OMP_DECLARE_REDUCTION_P (decl)
13831 && DECL_FUNCTION_SCOPE_P (pattern_decl))
13833 DECL_CONTEXT (decl) = NULL_TREE;
13835 DECL_CONTEXT (decl) = current_function_decl;
13836 cp_check_omp_declare_reduction (decl);
13840 int const_init = false;
13841 maybe_push_decl (decl);
13843 && DECL_PRETTY_FUNCTION_P (decl))
13845 /* For __PRETTY_FUNCTION__ we have to adjust the
13847 const char *const name
13848 = cxx_printable_name (current_function_decl, 2);
13849 init = cp_fname_init (name, &TREE_TYPE (decl));
13852 init = tsubst_init (init, decl, args, complain, in_decl);
13855 const_init = (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
13857 cp_finish_decl (decl, init, const_init, NULL_TREE, 0);
13866 stmt = begin_for_stmt (NULL_TREE, NULL_TREE);
13867 RECUR (FOR_INIT_STMT (t));
13868 finish_for_init_stmt (stmt);
13869 tmp = RECUR (FOR_COND (t));
13870 finish_for_cond (tmp, stmt, false);
13871 tmp = RECUR (FOR_EXPR (t));
13872 finish_for_expr (tmp, stmt);
13873 RECUR (FOR_BODY (t));
13874 finish_for_stmt (stmt);
13877 case RANGE_FOR_STMT:
13880 stmt = begin_for_stmt (NULL_TREE, NULL_TREE);
13881 decl = RANGE_FOR_DECL (t);
13882 decl = tsubst (decl, args, complain, in_decl);
13883 maybe_push_decl (decl);
13884 expr = RECUR (RANGE_FOR_EXPR (t));
13885 stmt = cp_convert_range_for (stmt, decl, expr, RANGE_FOR_IVDEP (t));
13886 RECUR (RANGE_FOR_BODY (t));
13887 finish_for_stmt (stmt);
13892 stmt = begin_while_stmt ();
13893 tmp = RECUR (WHILE_COND (t));
13894 finish_while_stmt_cond (tmp, stmt, false);
13895 RECUR (WHILE_BODY (t));
13896 finish_while_stmt (stmt);
13900 stmt = begin_do_stmt ();
13901 RECUR (DO_BODY (t));
13902 finish_do_body (stmt);
13903 tmp = RECUR (DO_COND (t));
13904 finish_do_stmt (tmp, stmt, false);
13908 stmt = begin_if_stmt ();
13909 tmp = RECUR (IF_COND (t));
13910 finish_if_stmt_cond (tmp, stmt);
13911 RECUR (THEN_CLAUSE (t));
13912 finish_then_clause (stmt);
13914 if (ELSE_CLAUSE (t))
13916 begin_else_clause (stmt);
13917 RECUR (ELSE_CLAUSE (t));
13918 finish_else_clause (stmt);
13921 finish_if_stmt (stmt);
13925 if (BIND_EXPR_BODY_BLOCK (t))
13926 stmt = begin_function_body ();
13928 stmt = begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t)
13929 ? BCS_TRY_BLOCK : 0);
13931 RECUR (BIND_EXPR_BODY (t));
13933 if (BIND_EXPR_BODY_BLOCK (t))
13934 finish_function_body (stmt);
13936 finish_compound_stmt (stmt);
13940 finish_break_stmt ();
13943 case CONTINUE_STMT:
13944 finish_continue_stmt ();
13948 stmt = begin_switch_stmt ();
13949 tmp = RECUR (SWITCH_STMT_COND (t));
13950 finish_switch_cond (tmp, stmt);
13951 RECUR (SWITCH_STMT_BODY (t));
13952 finish_switch_stmt (stmt);
13955 case CASE_LABEL_EXPR:
13957 tree low = RECUR (CASE_LOW (t));
13958 tree high = RECUR (CASE_HIGH (t));
13959 finish_case_label (EXPR_LOCATION (t), low, high);
13965 tree decl = LABEL_EXPR_LABEL (t);
13968 label = finish_label_stmt (DECL_NAME (decl));
13969 if (DECL_ATTRIBUTES (decl) != NULL_TREE)
13970 cplus_decl_attributes (&label, DECL_ATTRIBUTES (decl), 0);
13975 tmp = GOTO_DESTINATION (t);
13976 if (TREE_CODE (tmp) != LABEL_DECL)
13977 /* Computed goto's must be tsubst'd into. On the other hand,
13978 non-computed gotos must not be; the identifier in question
13979 will have no binding. */
13982 tmp = DECL_NAME (tmp);
13983 finish_goto_stmt (tmp);
13988 tree string = RECUR (ASM_STRING (t));
13989 tree outputs = tsubst_copy_asm_operands (ASM_OUTPUTS (t), args,
13990 complain, in_decl);
13991 tree inputs = tsubst_copy_asm_operands (ASM_INPUTS (t), args,
13992 complain, in_decl);
13993 tree clobbers = tsubst_copy_asm_operands (ASM_CLOBBERS (t), args,
13994 complain, in_decl);
13995 tree labels = tsubst_copy_asm_operands (ASM_LABELS (t), args,
13996 complain, in_decl);
13997 tmp = finish_asm_stmt (ASM_VOLATILE_P (t), string, outputs, inputs,
13999 tree asm_expr = tmp;
14000 if (TREE_CODE (asm_expr) == CLEANUP_POINT_EXPR)
14001 asm_expr = TREE_OPERAND (asm_expr, 0);
14002 ASM_INPUT_P (asm_expr) = ASM_INPUT_P (t);
14009 stmt = begin_try_block ();
14010 RECUR (TRY_STMTS (t));
14011 finish_cleanup_try_block (stmt);
14012 finish_cleanup (RECUR (TRY_HANDLERS (t)), stmt);
14016 tree compound_stmt = NULL_TREE;
14018 if (FN_TRY_BLOCK_P (t))
14019 stmt = begin_function_try_block (&compound_stmt);
14021 stmt = begin_try_block ();
14023 RECUR (TRY_STMTS (t));
14025 if (FN_TRY_BLOCK_P (t))
14026 finish_function_try_block (stmt);
14028 finish_try_block (stmt);
14030 RECUR (TRY_HANDLERS (t));
14031 if (FN_TRY_BLOCK_P (t))
14032 finish_function_handler_sequence (stmt, compound_stmt);
14034 finish_handler_sequence (stmt);
14040 tree decl = HANDLER_PARMS (t);
14044 decl = tsubst (decl, args, complain, in_decl);
14045 /* Prevent instantiate_decl from trying to instantiate
14046 this variable. We've already done all that needs to be
14048 if (decl != error_mark_node)
14049 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
14051 stmt = begin_handler ();
14052 finish_handler_parms (decl, stmt);
14053 RECUR (HANDLER_BODY (t));
14054 finish_handler (stmt);
14059 tmp = tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
14060 if (CLASS_TYPE_P (tmp))
14062 /* Local classes are not independent templates; they are
14063 instantiated along with their containing function. And this
14064 way we don't have to deal with pushing out of one local class
14065 to instantiate a member of another local class. */
14067 /* Closures are handled by the LAMBDA_EXPR. */
14068 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t)));
14069 complete_type (tmp);
14070 for (fn = TYPE_METHODS (tmp); fn; fn = DECL_CHAIN (fn))
14071 if (!DECL_ARTIFICIAL (fn))
14072 instantiate_decl (fn, /*defer_ok*/0, /*expl_inst_class*/false);
14076 case STATIC_ASSERT:
14080 ++c_inhibit_evaluation_warnings;
14082 tsubst_expr (STATIC_ASSERT_CONDITION (t),
14085 /*integral_constant_expression_p=*/true);
14086 --c_inhibit_evaluation_warnings;
14088 finish_static_assert (condition,
14089 STATIC_ASSERT_MESSAGE (t),
14090 STATIC_ASSERT_SOURCE_LOCATION (t),
14091 /*member_p=*/false);
14096 tmp = tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t), false,
14097 args, complain, in_decl);
14098 stmt = begin_omp_parallel ();
14099 RECUR (OMP_PARALLEL_BODY (t));
14100 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp, stmt))
14101 = OMP_PARALLEL_COMBINED (t);
14105 tmp = tsubst_omp_clauses (OMP_TASK_CLAUSES (t), false,
14106 args, complain, in_decl);
14107 stmt = begin_omp_task ();
14108 RECUR (OMP_TASK_BODY (t));
14109 finish_omp_task (tmp, stmt);
14116 case OMP_DISTRIBUTE:
14118 tree clauses, body, pre_body;
14119 tree declv = NULL_TREE, initv = NULL_TREE, condv = NULL_TREE;
14120 tree incrv = NULL_TREE;
14123 clauses = tsubst_omp_clauses (OMP_FOR_CLAUSES (t), false,
14124 args, complain, in_decl);
14125 if (OMP_FOR_INIT (t) != NULL_TREE)
14127 declv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
14128 initv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
14129 condv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
14130 incrv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
14133 stmt = begin_omp_structured_block ();
14135 pre_body = push_stmt_list ();
14136 RECUR (OMP_FOR_PRE_BODY (t));
14137 pre_body = pop_stmt_list (pre_body);
14139 if (OMP_FOR_INIT (t) != NULL_TREE)
14140 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (t)); i++)
14141 tsubst_omp_for_iterator (t, i, declv, initv, condv, incrv,
14142 &clauses, args, complain, in_decl,
14143 integral_constant_expression_p);
14145 body = push_stmt_list ();
14146 RECUR (OMP_FOR_BODY (t));
14147 body = pop_stmt_list (body);
14149 if (OMP_FOR_INIT (t) != NULL_TREE)
14150 t = finish_omp_for (EXPR_LOCATION (t), TREE_CODE (t), declv, initv,
14151 condv, incrv, body, pre_body, clauses);
14154 t = make_node (TREE_CODE (t));
14155 TREE_TYPE (t) = void_type_node;
14156 OMP_FOR_BODY (t) = body;
14157 OMP_FOR_PRE_BODY (t) = pre_body;
14158 OMP_FOR_CLAUSES (t) = clauses;
14159 SET_EXPR_LOCATION (t, EXPR_LOCATION (t));
14163 add_stmt (finish_omp_structured_block (stmt));
14170 tmp = tsubst_omp_clauses (OMP_CLAUSES (t), false,
14171 args, complain, in_decl);
14172 stmt = push_stmt_list ();
14173 RECUR (OMP_BODY (t));
14174 stmt = pop_stmt_list (stmt);
14177 OMP_BODY (t) = stmt;
14178 OMP_CLAUSES (t) = tmp;
14182 case OMP_TARGET_DATA:
14184 tmp = tsubst_omp_clauses (OMP_CLAUSES (t), false,
14185 args, complain, in_decl);
14186 keep_next_level (true);
14187 stmt = begin_omp_structured_block ();
14189 RECUR (OMP_BODY (t));
14190 stmt = finish_omp_structured_block (stmt);
14193 OMP_BODY (t) = stmt;
14194 OMP_CLAUSES (t) = tmp;
14198 case OMP_TARGET_UPDATE:
14199 tmp = tsubst_omp_clauses (OMP_TARGET_UPDATE_CLAUSES (t), false,
14200 args, complain, in_decl);
14202 OMP_CLAUSES (t) = tmp;
14209 case OMP_TASKGROUP:
14211 stmt = push_stmt_list ();
14212 RECUR (OMP_BODY (t));
14213 stmt = pop_stmt_list (stmt);
14216 OMP_BODY (t) = stmt;
14221 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t));
14222 if (TREE_CODE (TREE_OPERAND (t, 1)) != MODIFY_EXPR)
14224 tree op1 = TREE_OPERAND (t, 1);
14225 tree rhs1 = NULL_TREE;
14227 if (TREE_CODE (op1) == COMPOUND_EXPR)
14229 rhs1 = RECUR (TREE_OPERAND (op1, 0));
14230 op1 = TREE_OPERAND (op1, 1);
14232 lhs = RECUR (TREE_OPERAND (op1, 0));
14233 rhs = RECUR (TREE_OPERAND (op1, 1));
14234 finish_omp_atomic (OMP_ATOMIC, TREE_CODE (op1), lhs, rhs,
14235 NULL_TREE, NULL_TREE, rhs1,
14236 OMP_ATOMIC_SEQ_CST (t));
14240 tree op1 = TREE_OPERAND (t, 1);
14241 tree v = NULL_TREE, lhs, rhs = NULL_TREE, lhs1 = NULL_TREE;
14242 tree rhs1 = NULL_TREE;
14243 enum tree_code code = TREE_CODE (TREE_OPERAND (op1, 1));
14244 enum tree_code opcode = NOP_EXPR;
14245 if (code == OMP_ATOMIC_READ)
14247 v = RECUR (TREE_OPERAND (op1, 0));
14248 lhs = RECUR (TREE_OPERAND (TREE_OPERAND (op1, 1), 0));
14250 else if (code == OMP_ATOMIC_CAPTURE_OLD
14251 || code == OMP_ATOMIC_CAPTURE_NEW)
14253 tree op11 = TREE_OPERAND (TREE_OPERAND (op1, 1), 1);
14254 v = RECUR (TREE_OPERAND (op1, 0));
14255 lhs1 = RECUR (TREE_OPERAND (TREE_OPERAND (op1, 1), 0));
14256 if (TREE_CODE (op11) == COMPOUND_EXPR)
14258 rhs1 = RECUR (TREE_OPERAND (op11, 0));
14259 op11 = TREE_OPERAND (op11, 1);
14261 lhs = RECUR (TREE_OPERAND (op11, 0));
14262 rhs = RECUR (TREE_OPERAND (op11, 1));
14263 opcode = TREE_CODE (op11);
14264 if (opcode == MODIFY_EXPR)
14270 lhs = RECUR (TREE_OPERAND (op1, 0));
14271 rhs = RECUR (TREE_OPERAND (op1, 1));
14273 finish_omp_atomic (code, opcode, lhs, rhs, v, lhs1, rhs1,
14274 OMP_ATOMIC_SEQ_CST (t));
14278 case TRANSACTION_EXPR:
14281 flags |= (TRANSACTION_EXPR_OUTER (t) ? TM_STMT_ATTR_OUTER : 0);
14282 flags |= (TRANSACTION_EXPR_RELAXED (t) ? TM_STMT_ATTR_RELAXED : 0);
14284 if (TRANSACTION_EXPR_IS_STMT (t))
14286 tree body = TRANSACTION_EXPR_BODY (t);
14287 tree noex = NULL_TREE;
14288 if (TREE_CODE (body) == MUST_NOT_THROW_EXPR)
14290 noex = MUST_NOT_THROW_COND (body);
14291 if (noex == NULL_TREE)
14292 noex = boolean_true_node;
14293 body = TREE_OPERAND (body, 0);
14295 stmt = begin_transaction_stmt (input_location, NULL, flags);
14297 finish_transaction_stmt (stmt, NULL, flags, RECUR (noex));
14301 stmt = build_transaction_expr (EXPR_LOCATION (t),
14302 RECUR (TRANSACTION_EXPR_BODY (t)),
14309 case MUST_NOT_THROW_EXPR:
14311 tree op0 = RECUR (TREE_OPERAND (t, 0));
14312 tree cond = RECUR (MUST_NOT_THROW_COND (t));
14313 RETURN (build_must_not_throw_expr (op0, cond));
14316 case EXPR_PACK_EXPANSION:
14317 error ("invalid use of pack expansion expression");
14318 RETURN (error_mark_node);
14320 case NONTYPE_ARGUMENT_PACK:
14321 error ("use %<...%> to expand argument pack");
14322 RETURN (error_mark_node);
14324 case CILK_SPAWN_STMT:
14325 cfun->calls_cilk_spawn = 1;
14326 RETURN (build_cilk_spawn (EXPR_LOCATION (t), RECUR (CILK_SPAWN_FN (t))));
14328 case CILK_SYNC_STMT:
14329 RETURN (build_cilk_sync ());
14331 case COMPOUND_EXPR:
14332 tmp = RECUR (TREE_OPERAND (t, 0));
14333 if (tmp == NULL_TREE)
14334 /* If the first operand was a statement, we're done with it. */
14335 RETURN (RECUR (TREE_OPERAND (t, 1)));
14336 RETURN (build_x_compound_expr (EXPR_LOCATION (t), tmp,
14337 RECUR (TREE_OPERAND (t, 1)),
14340 case ANNOTATE_EXPR:
14341 tmp = RECUR (TREE_OPERAND (t, 0));
14342 RETURN (build2_loc (EXPR_LOCATION (t), ANNOTATE_EXPR,
14343 TREE_TYPE (tmp), tmp, RECUR (TREE_OPERAND (t, 1))));
14346 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t)));
14348 RETURN (tsubst_copy_and_build (t, args, complain, in_decl,
14349 /*function_p=*/false,
14350 integral_constant_expression_p));
14353 RETURN (NULL_TREE);
14355 input_location = loc;
14361 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
14362 function. For description of the body see comment above
14363 cp_parser_omp_declare_reduction_exprs. */
14366 tsubst_omp_udr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
14368 if (t == NULL_TREE || t == error_mark_node)
14371 gcc_assert (TREE_CODE (t) == STATEMENT_LIST);
14373 tree_stmt_iterator tsi;
14376 memset (stmts, 0, sizeof stmts);
14377 for (i = 0, tsi = tsi_start (t);
14378 i < 7 && !tsi_end_p (tsi);
14379 i++, tsi_next (&tsi))
14380 stmts[i] = tsi_stmt (tsi);
14381 gcc_assert (tsi_end_p (tsi));
14385 gcc_assert (TREE_CODE (stmts[0]) == DECL_EXPR
14386 && TREE_CODE (stmts[1]) == DECL_EXPR);
14387 tree omp_out = tsubst (DECL_EXPR_DECL (stmts[0]),
14388 args, complain, in_decl);
14389 tree omp_in = tsubst (DECL_EXPR_DECL (stmts[1]),
14390 args, complain, in_decl);
14391 DECL_CONTEXT (omp_out) = current_function_decl;
14392 DECL_CONTEXT (omp_in) = current_function_decl;
14393 keep_next_level (true);
14394 tree block = begin_omp_structured_block ();
14395 tsubst_expr (stmts[2], args, complain, in_decl, false);
14396 block = finish_omp_structured_block (block);
14397 block = maybe_cleanup_point_expr_void (block);
14398 add_decl_expr (omp_out);
14399 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts[0])))
14400 TREE_NO_WARNING (omp_out) = 1;
14401 add_decl_expr (omp_in);
14402 finish_expr_stmt (block);
14406 gcc_assert (TREE_CODE (stmts[3]) == DECL_EXPR
14407 && TREE_CODE (stmts[4]) == DECL_EXPR);
14408 tree omp_priv = tsubst (DECL_EXPR_DECL (stmts[3]),
14409 args, complain, in_decl);
14410 tree omp_orig = tsubst (DECL_EXPR_DECL (stmts[4]),
14411 args, complain, in_decl);
14412 DECL_CONTEXT (omp_priv) = current_function_decl;
14413 DECL_CONTEXT (omp_orig) = current_function_decl;
14414 keep_next_level (true);
14415 tree block = begin_omp_structured_block ();
14416 tsubst_expr (stmts[5], args, complain, in_decl, false);
14417 block = finish_omp_structured_block (block);
14418 block = maybe_cleanup_point_expr_void (block);
14419 cp_walk_tree (&block, cp_remove_omp_priv_cleanup_stmt, omp_priv, NULL);
14420 add_decl_expr (omp_priv);
14421 add_decl_expr (omp_orig);
14422 finish_expr_stmt (block);
14424 add_decl_expr (omp_orig);
14428 /* T is a postfix-expression that is not being used in a function
14429 call. Return the substituted version of T. */
14432 tsubst_non_call_postfix_expression (tree t, tree args,
14433 tsubst_flags_t complain,
14436 if (TREE_CODE (t) == SCOPE_REF)
14437 t = tsubst_qualified_id (t, args, complain, in_decl,
14438 /*done=*/false, /*address_p=*/false);
14440 t = tsubst_copy_and_build (t, args, complain, in_decl,
14441 /*function_p=*/false,
14442 /*integral_constant_expression_p=*/false);
14447 /* Like tsubst but deals with expressions and performs semantic
14448 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
14451 tsubst_copy_and_build (tree t,
14453 tsubst_flags_t complain,
14456 bool integral_constant_expression_p)
14458 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
14459 #define RECUR(NODE) \
14460 tsubst_copy_and_build (NODE, args, complain, in_decl, \
14461 /*function_p=*/false, \
14462 integral_constant_expression_p)
14467 if (t == NULL_TREE || t == error_mark_node)
14470 loc = input_location;
14471 if (EXPR_HAS_LOCATION (t))
14472 input_location = EXPR_LOCATION (t);
14474 /* N3276 decltype magic only applies to calls at the top level or on the
14475 right side of a comma. */
14476 tsubst_flags_t decltype_flag = (complain & tf_decltype);
14477 complain &= ~tf_decltype;
14479 switch (TREE_CODE (t))
14483 /* Fall through. */
14484 case IDENTIFIER_NODE:
14488 bool non_integral_constant_expression_p;
14489 const char *error_msg;
14491 if (IDENTIFIER_TYPENAME_P (t))
14493 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
14494 t = mangle_conv_op_name_for_type (new_type);
14497 /* Look up the name. */
14498 decl = lookup_name (t);
14500 /* By convention, expressions use ERROR_MARK_NODE to indicate
14501 failure, not NULL_TREE. */
14502 if (decl == NULL_TREE)
14503 decl = error_mark_node;
14505 decl = finish_id_expression (t, decl, NULL_TREE,
14507 integral_constant_expression_p,
14508 /*allow_non_integral_constant_expression_p=*/(cxx_dialect >= cxx11),
14509 &non_integral_constant_expression_p,
14510 /*template_p=*/false,
14512 /*address_p=*/false,
14513 /*template_arg_p=*/false,
14518 if (!function_p && identifier_p (decl))
14520 if (complain & tf_error)
14521 unqualified_name_lookup_error (decl);
14522 decl = error_mark_node;
14527 case TEMPLATE_ID_EXPR:
14530 tree templ = RECUR (TREE_OPERAND (t, 0));
14531 tree targs = TREE_OPERAND (t, 1);
14534 targs = tsubst_template_args (targs, args, complain, in_decl);
14536 if (TREE_CODE (templ) == COMPONENT_REF)
14538 object = TREE_OPERAND (templ, 0);
14539 templ = TREE_OPERAND (templ, 1);
14542 object = NULL_TREE;
14543 templ = lookup_template_function (templ, targs);
14546 RETURN (build3 (COMPONENT_REF, TREE_TYPE (templ),
14547 object, templ, NULL_TREE));
14549 RETURN (baselink_for_fns (templ));
14554 tree r = RECUR (TREE_OPERAND (t, 0));
14556 if (REFERENCE_REF_P (t))
14558 /* A type conversion to reference type will be enclosed in
14559 such an indirect ref, but the substitution of the cast
14560 will have also added such an indirect ref. */
14561 if (TREE_CODE (TREE_TYPE (r)) == REFERENCE_TYPE)
14562 r = convert_from_reference (r);
14565 r = build_x_indirect_ref (input_location, r, RO_UNARY_STAR,
14566 complain|decltype_flag);
14572 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
14573 tree op0 = RECUR (TREE_OPERAND (t, 0));
14574 RETURN (build_nop (type, op0));
14577 case IMPLICIT_CONV_EXPR:
14579 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
14580 tree expr = RECUR (TREE_OPERAND (t, 0));
14581 int flags = LOOKUP_IMPLICIT;
14582 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t))
14583 flags = LOOKUP_NORMAL;
14584 RETURN (perform_implicit_conversion_flags (type, expr, complain,
14590 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
14591 tree op0 = RECUR (TREE_OPERAND (t, 0));
14592 RETURN (build1 (CONVERT_EXPR, type, op0));
14596 case REINTERPRET_CAST_EXPR:
14597 case CONST_CAST_EXPR:
14598 case DYNAMIC_CAST_EXPR:
14599 case STATIC_CAST_EXPR:
14602 tree op, r = NULL_TREE;
14604 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
14605 if (integral_constant_expression_p
14606 && !cast_valid_in_integral_constant_expression_p (type))
14608 if (complain & tf_error)
14609 error ("a cast to a type other than an integral or "
14610 "enumeration type cannot appear in a constant-expression");
14611 RETURN (error_mark_node);
14614 op = RECUR (TREE_OPERAND (t, 0));
14616 warning_sentinel s(warn_useless_cast);
14617 switch (TREE_CODE (t))
14620 r = build_functional_cast (type, op, complain);
14622 case REINTERPRET_CAST_EXPR:
14623 r = build_reinterpret_cast (type, op, complain);
14625 case CONST_CAST_EXPR:
14626 r = build_const_cast (type, op, complain);
14628 case DYNAMIC_CAST_EXPR:
14629 r = build_dynamic_cast (type, op, complain);
14631 case STATIC_CAST_EXPR:
14632 r = build_static_cast (type, op, complain);
14635 gcc_unreachable ();
14641 case POSTDECREMENT_EXPR:
14642 case POSTINCREMENT_EXPR:
14643 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
14644 args, complain, in_decl);
14645 RETURN (build_x_unary_op (input_location, TREE_CODE (t), op1,
14646 complain|decltype_flag));
14648 case PREDECREMENT_EXPR:
14649 case PREINCREMENT_EXPR:
14653 case TRUTH_NOT_EXPR:
14654 case UNARY_PLUS_EXPR: /* Unary + */
14655 case REALPART_EXPR:
14656 case IMAGPART_EXPR:
14657 RETURN (build_x_unary_op (input_location, TREE_CODE (t),
14658 RECUR (TREE_OPERAND (t, 0)),
14659 complain|decltype_flag));
14661 case FIX_TRUNC_EXPR:
14662 RETURN (cp_build_unary_op (FIX_TRUNC_EXPR, RECUR (TREE_OPERAND (t, 0)),
14666 op1 = TREE_OPERAND (t, 0);
14667 if (TREE_CODE (op1) == LABEL_DECL)
14668 RETURN (finish_label_address_expr (DECL_NAME (op1),
14669 EXPR_LOCATION (op1)));
14670 if (TREE_CODE (op1) == SCOPE_REF)
14671 op1 = tsubst_qualified_id (op1, args, complain, in_decl,
14672 /*done=*/true, /*address_p=*/true);
14674 op1 = tsubst_non_call_postfix_expression (op1, args, complain,
14676 RETURN (build_x_unary_op (input_location, ADDR_EXPR, op1,
14677 complain|decltype_flag));
14682 case TRUNC_DIV_EXPR:
14683 case CEIL_DIV_EXPR:
14684 case FLOOR_DIV_EXPR:
14685 case ROUND_DIV_EXPR:
14686 case EXACT_DIV_EXPR:
14690 case TRUNC_MOD_EXPR:
14691 case FLOOR_MOD_EXPR:
14692 case TRUTH_ANDIF_EXPR:
14693 case TRUTH_ORIF_EXPR:
14694 case TRUTH_AND_EXPR:
14695 case TRUTH_OR_EXPR:
14711 warning_sentinel s1(warn_type_limits);
14712 warning_sentinel s2(warn_div_by_zero);
14713 tree op0 = RECUR (TREE_OPERAND (t, 0));
14714 tree op1 = RECUR (TREE_OPERAND (t, 1));
14715 tree r = build_x_binary_op
14716 (input_location, TREE_CODE (t),
14718 (TREE_NO_WARNING (TREE_OPERAND (t, 0))
14720 : TREE_CODE (TREE_OPERAND (t, 0))),
14722 (TREE_NO_WARNING (TREE_OPERAND (t, 1))
14724 : TREE_CODE (TREE_OPERAND (t, 1))),
14726 complain|decltype_flag);
14727 if (EXPR_P (r) && TREE_NO_WARNING (t))
14728 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
14733 case POINTER_PLUS_EXPR:
14735 tree op0 = RECUR (TREE_OPERAND (t, 0));
14736 tree op1 = RECUR (TREE_OPERAND (t, 1));
14737 return fold_build_pointer_plus (op0, op1);
14741 RETURN (tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
14742 /*address_p=*/false));
14744 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
14745 args, complain, in_decl);
14746 RETURN (build_x_array_ref (EXPR_LOCATION (t), op1,
14747 RECUR (TREE_OPERAND (t, 1)),
14748 complain|decltype_flag));
14750 case ARRAY_NOTATION_REF:
14752 tree start_index, length, stride;
14753 op1 = tsubst_non_call_postfix_expression (ARRAY_NOTATION_ARRAY (t),
14754 args, complain, in_decl);
14755 start_index = RECUR (ARRAY_NOTATION_START (t));
14756 length = RECUR (ARRAY_NOTATION_LENGTH (t));
14757 stride = RECUR (ARRAY_NOTATION_STRIDE (t));
14758 RETURN (build_array_notation_ref (EXPR_LOCATION (t), op1, start_index,
14759 length, stride, TREE_TYPE (op1)));
14762 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
14763 RETURN (tsubst_copy (t, args, complain, in_decl));
14770 op1 = TREE_OPERAND (t, 0);
14771 if (TREE_CODE (t) == SIZEOF_EXPR && SIZEOF_EXPR_TYPE_P (t))
14772 op1 = TREE_TYPE (op1);
14775 /* When there are no ARGS, we are trying to evaluate a
14776 non-dependent expression from the parser. Trying to do
14777 the substitutions may not work. */
14779 op1 = TREE_TYPE (op1);
14783 ++cp_unevaluated_operand;
14784 ++c_inhibit_evaluation_warnings;
14786 op1 = tsubst (op1, args, complain, in_decl);
14788 op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
14789 /*function_p=*/false,
14790 /*integral_constant_expression_p=*/
14792 --cp_unevaluated_operand;
14793 --c_inhibit_evaluation_warnings;
14796 r = cxx_sizeof_or_alignof_type (op1, TREE_CODE (t),
14797 complain & tf_error);
14799 r = cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t),
14800 complain & tf_error);
14801 if (TREE_CODE (t) == SIZEOF_EXPR && r != error_mark_node)
14803 if (TREE_CODE (r) != SIZEOF_EXPR || TYPE_P (op1))
14805 if (!processing_template_decl && TYPE_P (op1))
14807 r = build_min (SIZEOF_EXPR, size_type_node,
14808 build1 (NOP_EXPR, op1, error_mark_node));
14809 SIZEOF_EXPR_TYPE_P (r) = 1;
14812 r = build_min (SIZEOF_EXPR, size_type_node, op1);
14813 TREE_SIDE_EFFECTS (r) = 0;
14814 TREE_READONLY (r) = 1;
14816 SET_EXPR_LOCATION (r, EXPR_LOCATION (t));
14821 case AT_ENCODE_EXPR:
14823 op1 = TREE_OPERAND (t, 0);
14824 ++cp_unevaluated_operand;
14825 ++c_inhibit_evaluation_warnings;
14826 op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
14827 /*function_p=*/false,
14828 /*integral_constant_expression_p=*/false);
14829 --cp_unevaluated_operand;
14830 --c_inhibit_evaluation_warnings;
14831 RETURN (objc_build_encode_expr (op1));
14834 case NOEXCEPT_EXPR:
14835 op1 = TREE_OPERAND (t, 0);
14836 ++cp_unevaluated_operand;
14837 ++c_inhibit_evaluation_warnings;
14838 ++cp_noexcept_operand;
14839 op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
14840 /*function_p=*/false,
14841 /*integral_constant_expression_p=*/false);
14842 --cp_unevaluated_operand;
14843 --c_inhibit_evaluation_warnings;
14844 --cp_noexcept_operand;
14845 RETURN (finish_noexcept_expr (op1, complain));
14849 warning_sentinel s(warn_div_by_zero);
14850 tree lhs = RECUR (TREE_OPERAND (t, 0));
14851 tree rhs = RECUR (TREE_OPERAND (t, 2));
14852 tree r = build_x_modify_expr
14853 (EXPR_LOCATION (t), lhs, TREE_CODE (TREE_OPERAND (t, 1)), rhs,
14854 complain|decltype_flag);
14855 /* TREE_NO_WARNING must be set if either the expression was
14856 parenthesized or it uses an operator such as >>= rather
14857 than plain assignment. In the former case, it was already
14858 set and must be copied. In the latter case,
14859 build_x_modify_expr sets it and it must not be reset
14861 if (TREE_NO_WARNING (t))
14862 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
14868 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
14869 args, complain, in_decl);
14870 /* Remember that there was a reference to this entity. */
14873 RETURN (build_x_arrow (input_location, op1, complain));
14877 tree placement = RECUR (TREE_OPERAND (t, 0));
14878 tree init = RECUR (TREE_OPERAND (t, 3));
14879 vec<tree, va_gc> *placement_vec;
14880 vec<tree, va_gc> *init_vec;
14883 if (placement == NULL_TREE)
14884 placement_vec = NULL;
14887 placement_vec = make_tree_vector ();
14888 for (; placement != NULL_TREE; placement = TREE_CHAIN (placement))
14889 vec_safe_push (placement_vec, TREE_VALUE (placement));
14892 /* If there was an initializer in the original tree, but it
14893 instantiated to an empty list, then we should pass a
14894 non-NULL empty vector to tell build_new that it was an
14895 empty initializer() rather than no initializer. This can
14896 only happen when the initializer is a pack expansion whose
14897 parameter packs are of length zero. */
14898 if (init == NULL_TREE && TREE_OPERAND (t, 3) == NULL_TREE)
14902 init_vec = make_tree_vector ();
14903 if (init == void_node)
14904 gcc_assert (init_vec != NULL);
14907 for (; init != NULL_TREE; init = TREE_CHAIN (init))
14908 vec_safe_push (init_vec, TREE_VALUE (init));
14912 tree op1 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
14913 tree op2 = RECUR (TREE_OPERAND (t, 2));
14914 ret = build_new (&placement_vec, op1, op2, &init_vec,
14915 NEW_EXPR_USE_GLOBAL (t),
14918 if (placement_vec != NULL)
14919 release_tree_vector (placement_vec);
14920 if (init_vec != NULL)
14921 release_tree_vector (init_vec);
14928 tree op0 = RECUR (TREE_OPERAND (t, 0));
14929 tree op1 = RECUR (TREE_OPERAND (t, 1));
14930 RETURN (delete_sanity (op0, op1,
14931 DELETE_EXPR_USE_VEC (t),
14932 DELETE_EXPR_USE_GLOBAL (t),
14936 case COMPOUND_EXPR:
14938 tree op0 = tsubst_copy_and_build (TREE_OPERAND (t, 0), args,
14939 complain & ~tf_decltype, in_decl,
14940 /*function_p=*/false,
14941 integral_constant_expression_p);
14942 RETURN (build_x_compound_expr (EXPR_LOCATION (t),
14944 RECUR (TREE_OPERAND (t, 1)),
14945 complain|decltype_flag));
14951 vec<tree, va_gc> *call_args;
14952 unsigned int nargs, i;
14957 function = CALL_EXPR_FN (t);
14958 /* When we parsed the expression, we determined whether or
14959 not Koenig lookup should be performed. */
14960 koenig_p = KOENIG_LOOKUP_P (t);
14961 if (TREE_CODE (function) == SCOPE_REF)
14963 qualified_p = true;
14964 function = tsubst_qualified_id (function, args, complain, in_decl,
14966 /*address_p=*/false);
14968 else if (koenig_p && identifier_p (function))
14970 /* Do nothing; calling tsubst_copy_and_build on an identifier
14971 would incorrectly perform unqualified lookup again.
14973 Note that we can also have an IDENTIFIER_NODE if the earlier
14974 unqualified lookup found a member function; in that case
14975 koenig_p will be false and we do want to do the lookup
14976 again to find the instantiated member function.
14978 FIXME but doing that causes c++/15272, so we need to stop
14979 using IDENTIFIER_NODE in that situation. */
14980 qualified_p = false;
14984 if (TREE_CODE (function) == COMPONENT_REF)
14986 tree op = TREE_OPERAND (function, 1);
14988 qualified_p = (TREE_CODE (op) == SCOPE_REF
14989 || (BASELINK_P (op)
14990 && BASELINK_QUALIFIED_P (op)));
14993 qualified_p = false;
14995 if (TREE_CODE (function) == ADDR_EXPR
14996 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
14997 /* Avoid error about taking the address of a constructor. */
14998 function = TREE_OPERAND (function, 0);
15000 function = tsubst_copy_and_build (function, args, complain,
15003 integral_constant_expression_p);
15005 if (BASELINK_P (function))
15006 qualified_p = true;
15009 nargs = call_expr_nargs (t);
15010 call_args = make_tree_vector ();
15011 for (i = 0; i < nargs; ++i)
15013 tree arg = CALL_EXPR_ARG (t, i);
15015 if (!PACK_EXPANSION_P (arg))
15016 vec_safe_push (call_args, RECUR (CALL_EXPR_ARG (t, i)));
15019 /* Expand the pack expansion and push each entry onto
15021 arg = tsubst_pack_expansion (arg, args, complain, in_decl);
15022 if (TREE_CODE (arg) == TREE_VEC)
15024 unsigned int len, j;
15026 len = TREE_VEC_LENGTH (arg);
15027 for (j = 0; j < len; ++j)
15029 tree value = TREE_VEC_ELT (arg, j);
15030 if (value != NULL_TREE)
15031 value = convert_from_reference (value);
15032 vec_safe_push (call_args, value);
15037 /* A partial substitution. Add one entry. */
15038 vec_safe_push (call_args, arg);
15043 /* We do not perform argument-dependent lookup if normal
15044 lookup finds a non-function, in accordance with the
15045 expected resolution of DR 218. */
15047 && ((is_overloaded_fn (function)
15048 /* If lookup found a member function, the Koenig lookup is
15049 not appropriate, even if an unqualified-name was used
15050 to denote the function. */
15051 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function)))
15052 || identifier_p (function))
15053 /* Only do this when substitution turns a dependent call
15054 into a non-dependent call. */
15055 && type_dependent_expression_p_push (t)
15056 && !any_type_dependent_arguments_p (call_args))
15057 function = perform_koenig_lookup (function, call_args, tf_none);
15059 if (identifier_p (function)
15060 && !any_type_dependent_arguments_p (call_args))
15062 if (koenig_p && (complain & tf_warning_or_error))
15064 /* For backwards compatibility and good diagnostics, try
15065 the unqualified lookup again if we aren't in SFINAE
15067 tree unq = (tsubst_copy_and_build
15068 (function, args, complain, in_decl, true,
15069 integral_constant_expression_p));
15070 if (unq == error_mark_node)
15071 RETURN (error_mark_node);
15073 if (unq != function)
15076 if (INDIRECT_REF_P (fn))
15077 fn = TREE_OPERAND (fn, 0);
15078 if (TREE_CODE (fn) == COMPONENT_REF)
15079 fn = TREE_OPERAND (fn, 1);
15080 if (is_overloaded_fn (fn))
15081 fn = get_first_fn (fn);
15082 if (permerror (EXPR_LOC_OR_LOC (t, input_location),
15083 "%qD was not declared in this scope, "
15084 "and no declarations were found by "
15085 "argument-dependent lookup at the point "
15086 "of instantiation", function))
15089 /* Can't say anything more. */;
15090 else if (DECL_CLASS_SCOPE_P (fn))
15092 location_t loc = EXPR_LOC_OR_LOC (t,
15095 "declarations in dependent base %qT are "
15096 "not found by unqualified lookup",
15097 DECL_CLASS_CONTEXT (fn));
15098 if (current_class_ptr)
15100 "use %<this->%D%> instead", function);
15103 "use %<%T::%D%> instead",
15104 current_class_name, function);
15107 inform (0, "%q+D declared here, later in the "
15108 "translation unit", fn);
15113 if (identifier_p (function))
15115 if (complain & tf_error)
15116 unqualified_name_lookup_error (function);
15117 release_tree_vector (call_args);
15118 RETURN (error_mark_node);
15122 /* Remember that there was a reference to this entity. */
15123 if (DECL_P (function))
15124 mark_used (function, complain);
15126 /* Put back tf_decltype for the actual call. */
15127 complain |= decltype_flag;
15129 if (TREE_CODE (function) == OFFSET_REF)
15130 ret = build_offset_ref_call_from_tree (function, &call_args,
15132 else if (TREE_CODE (function) == COMPONENT_REF)
15134 tree instance = TREE_OPERAND (function, 0);
15135 tree fn = TREE_OPERAND (function, 1);
15137 if (processing_template_decl
15138 && (type_dependent_expression_p (instance)
15139 || (!BASELINK_P (fn)
15140 && TREE_CODE (fn) != FIELD_DECL)
15141 || type_dependent_expression_p (fn)
15142 || any_type_dependent_arguments_p (call_args)))
15143 ret = build_nt_call_vec (function, call_args);
15144 else if (!BASELINK_P (fn))
15145 ret = finish_call_expr (function, &call_args,
15146 /*disallow_virtual=*/false,
15147 /*koenig_p=*/false,
15150 ret = (build_new_method_call
15152 &call_args, NULL_TREE,
15153 qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL,
15158 ret = finish_call_expr (function, &call_args,
15159 /*disallow_virtual=*/qualified_p,
15163 release_tree_vector (call_args);
15170 tree cond = RECUR (TREE_OPERAND (t, 0));
15171 tree folded_cond = fold_non_dependent_expr (cond);
15174 if (TREE_CODE (folded_cond) == INTEGER_CST)
15176 if (integer_zerop (folded_cond))
15178 ++c_inhibit_evaluation_warnings;
15179 exp1 = RECUR (TREE_OPERAND (t, 1));
15180 --c_inhibit_evaluation_warnings;
15181 exp2 = RECUR (TREE_OPERAND (t, 2));
15185 exp1 = RECUR (TREE_OPERAND (t, 1));
15186 ++c_inhibit_evaluation_warnings;
15187 exp2 = RECUR (TREE_OPERAND (t, 2));
15188 --c_inhibit_evaluation_warnings;
15190 cond = folded_cond;
15194 exp1 = RECUR (TREE_OPERAND (t, 1));
15195 exp2 = RECUR (TREE_OPERAND (t, 2));
15198 RETURN (build_x_conditional_expr (EXPR_LOCATION (t),
15199 cond, exp1, exp2, complain));
15202 case PSEUDO_DTOR_EXPR:
15204 tree op0 = RECUR (TREE_OPERAND (t, 0));
15205 tree op1 = RECUR (TREE_OPERAND (t, 1));
15206 tree op2 = tsubst (TREE_OPERAND (t, 2), args, complain, in_decl);
15207 RETURN (finish_pseudo_destructor_expr (op0, op1, op2,
15213 tree purpose, value, chain;
15215 if (t == void_list_node)
15218 if ((TREE_PURPOSE (t) && PACK_EXPANSION_P (TREE_PURPOSE (t)))
15219 || (TREE_VALUE (t) && PACK_EXPANSION_P (TREE_VALUE (t))))
15221 /* We have pack expansions, so expand those and
15222 create a new list out of it. */
15223 tree purposevec = NULL_TREE;
15224 tree valuevec = NULL_TREE;
15228 /* Expand the argument expressions. */
15229 if (TREE_PURPOSE (t))
15230 purposevec = tsubst_pack_expansion (TREE_PURPOSE (t), args,
15231 complain, in_decl);
15232 if (TREE_VALUE (t))
15233 valuevec = tsubst_pack_expansion (TREE_VALUE (t), args,
15234 complain, in_decl);
15236 /* Build the rest of the list. */
15237 chain = TREE_CHAIN (t);
15238 if (chain && chain != void_type_node)
15239 chain = RECUR (chain);
15241 /* Determine the number of arguments. */
15242 if (purposevec && TREE_CODE (purposevec) == TREE_VEC)
15244 len = TREE_VEC_LENGTH (purposevec);
15245 gcc_assert (!valuevec || len == TREE_VEC_LENGTH (valuevec));
15247 else if (TREE_CODE (valuevec) == TREE_VEC)
15248 len = TREE_VEC_LENGTH (valuevec);
15251 /* Since we only performed a partial substitution into
15252 the argument pack, we only RETURN (a single list
15254 if (purposevec == TREE_PURPOSE (t)
15255 && valuevec == TREE_VALUE (t)
15256 && chain == TREE_CHAIN (t))
15259 RETURN (tree_cons (purposevec, valuevec, chain));
15262 /* Convert the argument vectors into a TREE_LIST */
15266 /* Grab the Ith values. */
15268 purpose = purposevec ? TREE_VEC_ELT (purposevec, i)
15271 = valuevec ? convert_from_reference (TREE_VEC_ELT (valuevec, i))
15274 /* Build the list (backwards). */
15275 chain = tree_cons (purpose, value, chain);
15281 purpose = TREE_PURPOSE (t);
15283 purpose = RECUR (purpose);
15284 value = TREE_VALUE (t);
15286 value = RECUR (value);
15287 chain = TREE_CHAIN (t);
15288 if (chain && chain != void_type_node)
15289 chain = RECUR (chain);
15290 if (purpose == TREE_PURPOSE (t)
15291 && value == TREE_VALUE (t)
15292 && chain == TREE_CHAIN (t))
15294 RETURN (tree_cons (purpose, value, chain));
15297 case COMPONENT_REF:
15304 object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
15305 args, complain, in_decl);
15306 /* Remember that there was a reference to this entity. */
15307 if (DECL_P (object))
15308 mark_used (object);
15309 object_type = TREE_TYPE (object);
15311 member = TREE_OPERAND (t, 1);
15312 if (BASELINK_P (member))
15313 member = tsubst_baselink (member,
15314 non_reference (TREE_TYPE (object)),
15315 args, complain, in_decl);
15317 member = tsubst_copy (member, args, complain, in_decl);
15318 if (member == error_mark_node)
15319 RETURN (error_mark_node);
15321 if (type_dependent_expression_p (object))
15322 /* We can't do much here. */;
15323 else if (!CLASS_TYPE_P (object_type))
15325 if (scalarish_type_p (object_type))
15327 tree s = NULL_TREE;
15328 tree dtor = member;
15330 if (TREE_CODE (dtor) == SCOPE_REF)
15332 s = TREE_OPERAND (dtor, 0);
15333 dtor = TREE_OPERAND (dtor, 1);
15335 if (TREE_CODE (dtor) == BIT_NOT_EXPR)
15337 dtor = TREE_OPERAND (dtor, 0);
15339 RETURN (finish_pseudo_destructor_expr
15340 (object, s, dtor, input_location));
15344 else if (TREE_CODE (member) == SCOPE_REF
15345 && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
15347 /* Lookup the template functions now that we know what the
15349 tree scope = TREE_OPERAND (member, 0);
15350 tree tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
15351 tree args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
15352 member = lookup_qualified_name (scope, tmpl,
15353 /*is_type_p=*/false,
15354 /*complain=*/false);
15355 if (BASELINK_P (member))
15357 BASELINK_FUNCTIONS (member)
15358 = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
15360 member = (adjust_result_of_qualified_name_lookup
15361 (member, BINFO_TYPE (BASELINK_BINFO (member)),
15366 qualified_name_lookup_error (scope, tmpl, member,
15368 RETURN (error_mark_node);
15371 else if (TREE_CODE (member) == SCOPE_REF
15372 && !CLASS_TYPE_P (TREE_OPERAND (member, 0))
15373 && TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL)
15375 if (complain & tf_error)
15377 if (TYPE_P (TREE_OPERAND (member, 0)))
15378 error ("%qT is not a class or namespace",
15379 TREE_OPERAND (member, 0));
15381 error ("%qD is not a class or namespace",
15382 TREE_OPERAND (member, 0));
15384 RETURN (error_mark_node);
15386 else if (TREE_CODE (member) == FIELD_DECL)
15388 r = finish_non_static_data_member (member, object, NULL_TREE);
15389 if (TREE_CODE (r) == COMPONENT_REF)
15390 REF_PARENTHESIZED_P (r) = REF_PARENTHESIZED_P (t);
15394 r = finish_class_member_access_expr (object, member,
15395 /*template_p=*/false,
15397 if (TREE_CODE (r) == COMPONENT_REF)
15398 REF_PARENTHESIZED_P (r) = REF_PARENTHESIZED_P (t);
15403 RETURN (build_throw
15404 (RECUR (TREE_OPERAND (t, 0))));
15408 vec<constructor_elt, va_gc> *n;
15409 constructor_elt *ce;
15410 unsigned HOST_WIDE_INT idx;
15411 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
15412 bool process_index_p;
15414 bool need_copy_p = false;
15417 if (type == error_mark_node)
15418 RETURN (error_mark_node);
15420 /* digest_init will do the wrong thing if we let it. */
15421 if (type && TYPE_PTRMEMFUNC_P (type))
15424 /* We do not want to process the index of aggregate
15425 initializers as they are identifier nodes which will be
15426 looked up by digest_init. */
15427 process_index_p = !(type && MAYBE_CLASS_TYPE_P (type));
15429 n = vec_safe_copy (CONSTRUCTOR_ELTS (t));
15430 newlen = vec_safe_length (n);
15431 FOR_EACH_VEC_SAFE_ELT (n, idx, ce)
15433 if (ce->index && process_index_p
15434 /* An identifier index is looked up in the type
15435 being initialized, not the current scope. */
15436 && TREE_CODE (ce->index) != IDENTIFIER_NODE)
15437 ce->index = RECUR (ce->index);
15439 if (PACK_EXPANSION_P (ce->value))
15441 /* Substitute into the pack expansion. */
15442 ce->value = tsubst_pack_expansion (ce->value, args, complain,
15445 if (ce->value == error_mark_node
15446 || PACK_EXPANSION_P (ce->value))
15448 else if (TREE_VEC_LENGTH (ce->value) == 1)
15449 /* Just move the argument into place. */
15450 ce->value = TREE_VEC_ELT (ce->value, 0);
15453 /* Update the length of the final CONSTRUCTOR
15454 arguments vector, and note that we will need to
15456 newlen = newlen + TREE_VEC_LENGTH (ce->value) - 1;
15457 need_copy_p = true;
15461 ce->value = RECUR (ce->value);
15466 vec<constructor_elt, va_gc> *old_n = n;
15468 vec_alloc (n, newlen);
15469 FOR_EACH_VEC_ELT (*old_n, idx, ce)
15471 if (TREE_CODE (ce->value) == TREE_VEC)
15473 int i, len = TREE_VEC_LENGTH (ce->value);
15474 for (i = 0; i < len; ++i)
15475 CONSTRUCTOR_APPEND_ELT (n, 0,
15476 TREE_VEC_ELT (ce->value, i));
15479 CONSTRUCTOR_APPEND_ELT (n, 0, ce->value);
15483 r = build_constructor (init_list_type_node, n);
15484 CONSTRUCTOR_IS_DIRECT_INIT (r) = CONSTRUCTOR_IS_DIRECT_INIT (t);
15486 if (TREE_HAS_CONSTRUCTOR (t))
15487 RETURN (finish_compound_literal (type, r, complain));
15489 TREE_TYPE (r) = type;
15495 tree operand_0 = TREE_OPERAND (t, 0);
15496 if (TYPE_P (operand_0))
15498 operand_0 = tsubst (operand_0, args, complain, in_decl);
15499 RETURN (get_typeid (operand_0, complain));
15503 operand_0 = RECUR (operand_0);
15504 RETURN (build_typeid (operand_0, complain));
15511 else if (DECL_PACK_P (t))
15513 /* We don't build decls for an instantiation of a
15514 variadic capture proxy, we instantiate the elements
15516 gcc_assert (DECL_HAS_VALUE_EXPR_P (t));
15517 return RECUR (DECL_VALUE_EXPR (t));
15523 tree r = tsubst_copy (t, args, complain, in_decl);
15524 /* ??? We're doing a subset of finish_id_expression here. */
15526 && !processing_template_decl
15527 && !cp_unevaluated_operand
15528 && (TREE_STATIC (r) || DECL_EXTERNAL (r))
15529 && DECL_THREAD_LOCAL_P (r))
15531 if (tree wrap = get_tls_wrapper_fn (r))
15532 /* Replace an evaluated use of the thread_local variable with
15533 a call to its wrapper. */
15534 r = build_cxx_call (wrap, 0, NULL, tf_warning_or_error);
15536 else if (outer_automatic_var_p (r))
15537 r = process_outer_var_ref (r, complain);
15539 if (TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
15540 /* If the original type was a reference, we'll be wrapped in
15541 the appropriate INDIRECT_REF. */
15542 r = convert_from_reference (r);
15548 tree op0 = RECUR (TREE_OPERAND (t, 0));
15549 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
15550 RETURN (build_x_va_arg (EXPR_LOCATION (t), op0, type));
15553 case OFFSETOF_EXPR:
15554 RETURN (finish_offsetof (RECUR (TREE_OPERAND (t, 0)),
15555 EXPR_LOCATION (t)));
15559 tree type1 = tsubst (TRAIT_EXPR_TYPE1 (t), args,
15560 complain, in_decl);
15562 tree type2 = TRAIT_EXPR_TYPE2 (t);
15563 if (type2 && TREE_CODE (type2) == TREE_LIST)
15564 type2 = RECUR (type2);
15566 type2 = tsubst (type2, args, complain, in_decl);
15568 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t), type1, type2));
15573 tree old_stmt_expr = cur_stmt_expr;
15574 tree stmt_expr = begin_stmt_expr ();
15576 cur_stmt_expr = stmt_expr;
15577 tsubst_expr (STMT_EXPR_STMT (t), args, complain, in_decl,
15578 integral_constant_expression_p);
15579 stmt_expr = finish_stmt_expr (stmt_expr, false);
15580 cur_stmt_expr = old_stmt_expr;
15582 /* If the resulting list of expression statement is empty,
15583 fold it further into void_node. */
15584 if (empty_expr_stmt_p (stmt_expr))
15585 stmt_expr = void_node;
15587 RETURN (stmt_expr);
15592 tree r = build_lambda_expr ();
15594 tree type = tsubst (LAMBDA_EXPR_CLOSURE (t), args, complain, NULL_TREE);
15595 LAMBDA_EXPR_CLOSURE (r) = type;
15596 CLASSTYPE_LAMBDA_EXPR (type) = r;
15598 LAMBDA_EXPR_LOCATION (r)
15599 = LAMBDA_EXPR_LOCATION (t);
15600 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r)
15601 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t);
15602 LAMBDA_EXPR_MUTABLE_P (r) = LAMBDA_EXPR_MUTABLE_P (t);
15603 LAMBDA_EXPR_DISCRIMINATOR (r)
15604 = (LAMBDA_EXPR_DISCRIMINATOR (t));
15605 /* For a function scope, we want to use tsubst so that we don't
15606 complain about referring to an auto function before its return
15607 type has been deduced. Otherwise, we want to use tsubst_copy so
15608 that we look up the existing field/parameter/variable rather
15609 than build a new one. */
15610 tree scope = LAMBDA_EXPR_EXTRA_SCOPE (t);
15611 if (scope && TREE_CODE (scope) == FUNCTION_DECL)
15612 scope = tsubst (scope, args, complain, in_decl);
15613 else if (scope && TREE_CODE (scope) == PARM_DECL)
15615 /* Look up the parameter we want directly, as tsubst_copy
15616 doesn't do what we need. */
15617 tree fn = tsubst (DECL_CONTEXT (scope), args, complain, in_decl);
15618 tree parm = FUNCTION_FIRST_USER_PARM (fn);
15619 while (DECL_PARM_INDEX (parm) != DECL_PARM_INDEX (scope))
15620 parm = DECL_CHAIN (parm);
15622 /* FIXME Work around the parm not having DECL_CONTEXT set. */
15623 if (DECL_CONTEXT (scope) == NULL_TREE)
15624 DECL_CONTEXT (scope) = fn;
15627 scope = RECUR (scope);
15628 LAMBDA_EXPR_EXTRA_SCOPE (r) = scope;
15629 LAMBDA_EXPR_RETURN_TYPE (r)
15630 = tsubst (LAMBDA_EXPR_RETURN_TYPE (t), args, complain, in_decl);
15632 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t) == NULL_TREE
15633 && LAMBDA_EXPR_PENDING_PROXIES (t) == NULL);
15635 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
15636 determine_visibility (TYPE_NAME (type));
15637 /* Now that we know visibility, instantiate the type so we have a
15638 declaration of the op() for later calls to lambda_function. */
15639 complete_type (type);
15641 LAMBDA_EXPR_THIS_CAPTURE (r) = NULL_TREE;
15643 RETURN (build_lambda_object (r));
15647 /* We can get here for a constant initializer of non-dependent type.
15648 FIXME stop folding in cp_parser_initializer_clause. */
15650 tree r = get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t)),
15655 case TRANSACTION_EXPR:
15656 RETURN (tsubst_expr(t, args, complain, in_decl,
15657 integral_constant_expression_p));
15660 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t, 0))));
15662 case VEC_PERM_EXPR:
15664 tree op0 = RECUR (TREE_OPERAND (t, 0));
15665 tree op1 = RECUR (TREE_OPERAND (t, 1));
15666 tree op2 = RECUR (TREE_OPERAND (t, 2));
15667 RETURN (build_x_vec_perm_expr (input_location, op0, op1, op2,
15672 /* Handle Objective-C++ constructs, if appropriate. */
15675 = objcp_tsubst_copy_and_build (t, args, complain,
15676 in_decl, /*function_p=*/false);
15680 RETURN (tsubst_copy (t, args, complain, in_decl));
15686 input_location = loc;
15690 /* Verify that the instantiated ARGS are valid. For type arguments,
15691 make sure that the type's linkage is ok. For non-type arguments,
15692 make sure they are constants if they are integral or enumerations.
15693 Emit an error under control of COMPLAIN, and return TRUE on error. */
15696 check_instantiated_arg (tree tmpl, tree t, tsubst_flags_t complain)
15698 if (dependent_template_arg_p (t))
15700 if (ARGUMENT_PACK_P (t))
15702 tree vec = ARGUMENT_PACK_ARGS (t);
15703 int len = TREE_VEC_LENGTH (vec);
15704 bool result = false;
15707 for (i = 0; i < len; ++i)
15708 if (check_instantiated_arg (tmpl, TREE_VEC_ELT (vec, i), complain))
15712 else if (TYPE_P (t))
15714 /* [basic.link]: A name with no linkage (notably, the name
15715 of a class or enumeration declared in a local scope)
15716 shall not be used to declare an entity with linkage.
15717 This implies that names with no linkage cannot be used as
15720 DR 757 relaxes this restriction for C++0x. */
15721 tree nt = (cxx_dialect > cxx98 ? NULL_TREE
15722 : no_linkage_check (t, /*relaxed_p=*/false));
15726 /* DR 488 makes use of a type with no linkage cause
15727 type deduction to fail. */
15728 if (complain & tf_error)
15730 if (TYPE_ANONYMOUS_P (nt))
15731 error ("%qT is/uses anonymous type", t);
15733 error ("template argument for %qD uses local type %qT",
15738 /* In order to avoid all sorts of complications, we do not
15739 allow variably-modified types as template arguments. */
15740 else if (variably_modified_type_p (t, NULL_TREE))
15742 if (complain & tf_error)
15743 error ("%qT is a variably modified type", t);
15747 /* Class template and alias template arguments should be OK. */
15748 else if (DECL_TYPE_TEMPLATE_P (t))
15750 /* A non-type argument of integral or enumerated type must be a
15752 else if (TREE_TYPE (t)
15753 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t))
15754 && !REFERENCE_REF_P (t)
15755 && !TREE_CONSTANT (t))
15757 if (complain & tf_error)
15758 error ("integral expression %qE is not constant", t);
15765 check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain)
15767 int ix, len = DECL_NTPARMS (tmpl);
15768 bool result = false;
15770 for (ix = 0; ix != len; ix++)
15772 if (check_instantiated_arg (tmpl, TREE_VEC_ELT (args, ix), complain))
15775 if (result && (complain & tf_error))
15776 error (" trying to instantiate %qD", tmpl);
15780 /* We're out of SFINAE context now, so generate diagnostics for the access
15781 errors we saw earlier when instantiating D from TMPL and ARGS. */
15784 recheck_decl_substitution (tree d, tree tmpl, tree args)
15786 tree pattern = DECL_TEMPLATE_RESULT (tmpl);
15787 tree type = TREE_TYPE (pattern);
15788 location_t loc = input_location;
15790 push_access_scope (d);
15791 push_deferring_access_checks (dk_no_deferred);
15792 input_location = DECL_SOURCE_LOCATION (pattern);
15793 tsubst (type, args, tf_warning_or_error, d);
15794 input_location = loc;
15795 pop_deferring_access_checks ();
15796 pop_access_scope (d);
15799 /* Instantiate the indicated variable, function, or alias template TMPL with
15800 the template arguments in TARG_PTR. */
15803 instantiate_template_1 (tree tmpl, tree orig_args, tsubst_flags_t complain)
15805 tree targ_ptr = orig_args;
15809 bool access_ok = true;
15811 if (tmpl == error_mark_node)
15812 return error_mark_node;
15814 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
15816 /* If this function is a clone, handle it specially. */
15817 if (DECL_CLONED_FUNCTION_P (tmpl))
15822 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
15823 DECL_CLONED_FUNCTION. */
15824 spec = instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl),
15825 targ_ptr, complain);
15826 if (spec == error_mark_node)
15827 return error_mark_node;
15829 /* Look for the clone. */
15830 FOR_EACH_CLONE (clone, spec)
15831 if (DECL_NAME (clone) == DECL_NAME (tmpl))
15833 /* We should always have found the clone by now. */
15834 gcc_unreachable ();
15838 if (targ_ptr == error_mark_node)
15839 return error_mark_node;
15841 /* Check to see if we already have this specialization. */
15842 gen_tmpl = most_general_template (tmpl);
15843 if (tmpl != gen_tmpl)
15844 /* The TMPL is a partial instantiation. To get a full set of
15845 arguments we must add the arguments used to perform the
15846 partial instantiation. */
15847 targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl),
15850 /* It would be nice to avoid hashing here and then again in tsubst_decl,
15851 but it doesn't seem to be on the hot path. */
15852 spec = retrieve_specialization (gen_tmpl, targ_ptr, 0);
15854 gcc_assert (tmpl == gen_tmpl
15855 || ((fndecl = retrieve_specialization (tmpl, orig_args, 0))
15857 || fndecl == NULL_TREE);
15859 if (spec != NULL_TREE)
15861 if (FNDECL_HAS_ACCESS_ERRORS (spec))
15863 if (complain & tf_error)
15864 recheck_decl_substitution (spec, gen_tmpl, targ_ptr);
15865 return error_mark_node;
15870 if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr),
15872 return error_mark_node;
15874 /* We are building a FUNCTION_DECL, during which the access of its
15875 parameters and return types have to be checked. However this
15876 FUNCTION_DECL which is the desired context for access checking
15877 is not built yet. We solve this chicken-and-egg problem by
15878 deferring all checks until we have the FUNCTION_DECL. */
15879 push_deferring_access_checks (dk_deferred);
15881 /* Instantiation of the function happens in the context of the function
15882 template, not the context of the overload resolution we're doing. */
15883 push_to_top_level ();
15884 /* If there are dependent arguments, e.g. because we're doing partial
15885 ordering, make sure processing_template_decl stays set. */
15886 if (uses_template_parms (targ_ptr))
15887 ++processing_template_decl;
15888 if (DECL_CLASS_SCOPE_P (gen_tmpl))
15890 tree ctx = tsubst_aggr_type (DECL_CONTEXT (gen_tmpl), targ_ptr,
15891 complain, gen_tmpl, true);
15892 push_nested_class (ctx);
15895 tree pattern = DECL_TEMPLATE_RESULT (gen_tmpl);
15897 if (VAR_P (pattern))
15899 /* We need to determine if we're using a partial or explicit
15900 specialization now, because the type of the variable could be
15902 tree tid = lookup_template_variable (gen_tmpl, targ_ptr);
15903 tree elt = most_specialized_partial_spec (tid, complain);
15904 if (elt == error_mark_node)
15905 pattern = error_mark_node;
15908 tmpl = TREE_VALUE (elt);
15909 pattern = DECL_TEMPLATE_RESULT (tmpl);
15910 targ_ptr = TREE_PURPOSE (elt);
15914 /* Substitute template parameters to obtain the specialization. */
15915 fndecl = tsubst (pattern, targ_ptr, complain, gen_tmpl);
15916 if (DECL_CLASS_SCOPE_P (gen_tmpl))
15917 pop_nested_class ();
15918 pop_from_top_level ();
15920 if (fndecl == error_mark_node)
15922 pop_deferring_access_checks ();
15923 return error_mark_node;
15926 /* The DECL_TI_TEMPLATE should always be the immediate parent
15927 template, not the most general template. */
15928 DECL_TI_TEMPLATE (fndecl) = tmpl;
15930 /* Now we know the specialization, compute access previously
15932 push_access_scope (fndecl);
15933 if (!perform_deferred_access_checks (complain))
15935 pop_access_scope (fndecl);
15936 pop_deferring_access_checks ();
15938 /* If we've just instantiated the main entry point for a function,
15939 instantiate all the alternate entry points as well. We do this
15940 by cloning the instantiation of the main entry point, not by
15941 instantiating the template clones. */
15942 if (DECL_CHAIN (gen_tmpl) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl)))
15943 clone_function_decl (fndecl, /*update_method_vec_p=*/0);
15947 if (!(complain & tf_error))
15949 /* Remember to reinstantiate when we're out of SFINAE so the user
15950 can see the errors. */
15951 FNDECL_HAS_ACCESS_ERRORS (fndecl) = true;
15953 return error_mark_node;
15958 /* Wrapper for instantiate_template_1. */
15961 instantiate_template (tree tmpl, tree orig_args, tsubst_flags_t complain)
15964 timevar_push (TV_TEMPLATE_INST);
15965 ret = instantiate_template_1 (tmpl, orig_args, complain);
15966 timevar_pop (TV_TEMPLATE_INST);
15970 /* Instantiate the alias template TMPL with ARGS. Also push a template
15971 instantiation level, which instantiate_template doesn't do because
15972 functions and variables have sufficient context established by the
15976 instantiate_alias_template (tree tmpl, tree args, tsubst_flags_t complain)
15978 struct pending_template *old_last_pend = last_pending_template;
15979 struct tinst_level *old_error_tinst = last_error_tinst_level;
15980 if (tmpl == error_mark_node || args == error_mark_node)
15981 return error_mark_node;
15982 tree tinst = build_tree_list (tmpl, args);
15983 if (!push_tinst_level (tinst))
15986 return error_mark_node;
15990 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl),
15991 args, tmpl, complain,
15992 /*require_all_args=*/true,
15993 /*use_default_args=*/true);
15995 tree r = instantiate_template (tmpl, args, complain);
15996 pop_tinst_level ();
15997 /* We can't free this if a pending_template entry or last_error_tinst_level
15998 is pointing at it. */
15999 if (last_pending_template == old_last_pend
16000 && last_error_tinst_level == old_error_tinst)
16006 /* PARM is a template parameter pack for FN. Returns true iff
16007 PARM is used in a deducible way in the argument list of FN. */
16010 pack_deducible_p (tree parm, tree fn)
16012 tree t = FUNCTION_FIRST_USER_PARMTYPE (fn);
16013 for (; t; t = TREE_CHAIN (t))
16015 tree type = TREE_VALUE (t);
16017 if (!PACK_EXPANSION_P (type))
16019 for (packs = PACK_EXPANSION_PARAMETER_PACKS (type);
16020 packs; packs = TREE_CHAIN (packs))
16021 if (template_args_equal (TREE_VALUE (packs), parm))
16023 /* The template parameter pack is used in a function parameter
16024 pack. If this is the end of the parameter list, the
16025 template parameter pack is deducible. */
16026 if (TREE_CHAIN (t) == void_list_node)
16029 /* Otherwise, not. Well, it could be deduced from
16030 a non-pack parameter, but doing so would end up with
16031 a deduction mismatch, so don't bother. */
16035 /* The template parameter pack isn't used in any function parameter
16036 packs, but it might be used deeper, e.g. tuple<Args...>. */
16040 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
16041 NARGS elements of the arguments that are being used when calling
16042 it. TARGS is a vector into which the deduced template arguments
16045 Returns either a FUNCTION_DECL for the matching specialization of FN or
16046 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
16047 true, diagnostics will be printed to explain why it failed.
16049 If FN is a conversion operator, or we are trying to produce a specific
16050 specialization, RETURN_TYPE is the return type desired.
16052 The EXPLICIT_TARGS are explicit template arguments provided via a
16055 The parameter STRICT is one of:
16058 We are deducing arguments for a function call, as in
16059 [temp.deduct.call].
16062 We are deducing arguments for a conversion function, as in
16063 [temp.deduct.conv].
16066 We are deducing arguments when doing an explicit instantiation
16067 as in [temp.explicit], when determining an explicit specialization
16068 as in [temp.expl.spec], or when taking the address of a function
16069 template, as in [temp.deduct.funcaddr]. */
16072 fn_type_unification (tree fn,
16073 tree explicit_targs,
16076 unsigned int nargs,
16078 unification_kind_t strict,
16085 tree decl = NULL_TREE;
16086 tsubst_flags_t complain = (explain_p ? tf_warning_or_error : tf_none);
16088 static int deduction_depth;
16089 struct pending_template *old_last_pend = last_pending_template;
16090 struct tinst_level *old_error_tinst = last_error_tinst_level;
16091 tree tparms = DECL_INNERMOST_TEMPLATE_PARMS (fn);
16093 tree r = error_mark_node;
16096 complain |= tf_decltype;
16098 /* In C++0x, it's possible to have a function template whose type depends
16099 on itself recursively. This is most obvious with decltype, but can also
16100 occur with enumeration scope (c++/48969). So we need to catch infinite
16101 recursion and reject the substitution at deduction time; this function
16102 will return error_mark_node for any repeated substitution.
16104 This also catches excessive recursion such as when f<N> depends on
16105 f<N-1> across all integers, and returns error_mark_node for all the
16106 substitutions back up to the initial one.
16108 This is, of course, not reentrant. */
16109 if (excessive_deduction_depth)
16110 return error_mark_node;
16111 tinst = build_tree_list (fn, NULL_TREE);
16114 gcc_assert (TREE_CODE (fn) == TEMPLATE_DECL);
16116 fntype = TREE_TYPE (fn);
16117 if (explicit_targs)
16121 The specified template arguments must match the template
16122 parameters in kind (i.e., type, nontype, template), and there
16123 must not be more arguments than there are parameters;
16124 otherwise type deduction fails.
16126 Nontype arguments must match the types of the corresponding
16127 nontype template parameters, or must be convertible to the
16128 types of the corresponding nontype parameters as specified in
16129 _temp.arg.nontype_, otherwise type deduction fails.
16131 All references in the function type of the function template
16132 to the corresponding template parameters are replaced by the
16133 specified template argument values. If a substitution in a
16134 template parameter or in the function type of the function
16135 template results in an invalid type, type deduction fails. */
16136 int i, len = TREE_VEC_LENGTH (tparms);
16137 location_t loc = input_location;
16138 bool incomplete = false;
16140 /* Adjust any explicit template arguments before entering the
16141 substitution context. */
16143 = (coerce_template_parms (tparms, explicit_targs, NULL_TREE,
16145 /*require_all_args=*/false,
16146 /*use_default_args=*/false));
16147 if (explicit_targs == error_mark_node)
16150 /* Substitute the explicit args into the function type. This is
16151 necessary so that, for instance, explicitly declared function
16152 arguments can match null pointed constants. If we were given
16153 an incomplete set of explicit args, we must not do semantic
16154 processing during substitution as we could create partial
16156 for (i = 0; i < len; i++)
16158 tree parm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
16159 bool parameter_pack = false;
16160 tree targ = TREE_VEC_ELT (explicit_targs, i);
16162 /* Dig out the actual parm. */
16163 if (TREE_CODE (parm) == TYPE_DECL
16164 || TREE_CODE (parm) == TEMPLATE_DECL)
16166 parm = TREE_TYPE (parm);
16167 parameter_pack = TEMPLATE_TYPE_PARAMETER_PACK (parm);
16169 else if (TREE_CODE (parm) == PARM_DECL)
16171 parm = DECL_INITIAL (parm);
16172 parameter_pack = TEMPLATE_PARM_PARAMETER_PACK (parm);
16175 if (!parameter_pack && targ == NULL_TREE)
16176 /* No explicit argument for this template parameter. */
16179 if (parameter_pack && pack_deducible_p (parm, fn))
16181 /* Mark the argument pack as "incomplete". We could
16182 still deduce more arguments during unification.
16183 We remove this mark in type_unification_real. */
16186 ARGUMENT_PACK_INCOMPLETE_P(targ) = 1;
16187 ARGUMENT_PACK_EXPLICIT_ARGS (targ)
16188 = ARGUMENT_PACK_ARGS (targ);
16191 /* We have some incomplete argument packs. */
16196 TREE_VALUE (tinst) = explicit_targs;
16197 if (!push_tinst_level (tinst))
16199 excessive_deduction_depth = true;
16202 processing_template_decl += incomplete;
16203 input_location = DECL_SOURCE_LOCATION (fn);
16204 /* Ignore any access checks; we'll see them again in
16205 instantiate_template and they might have the wrong
16206 access path at this point. */
16207 push_deferring_access_checks (dk_deferred);
16208 fntype = tsubst (TREE_TYPE (fn), explicit_targs,
16209 complain | tf_partial, NULL_TREE);
16210 pop_deferring_access_checks ();
16211 input_location = loc;
16212 processing_template_decl -= incomplete;
16213 pop_tinst_level ();
16215 if (fntype == error_mark_node)
16218 /* Place the explicitly specified arguments in TARGS. */
16219 for (i = NUM_TMPL_ARGS (explicit_targs); i--;)
16220 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (explicit_targs, i);
16223 /* Never do unification on the 'this' parameter. */
16224 parms = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (fntype));
16230 parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms);
16231 new_args = XALLOCAVEC (tree, nargs + 1);
16232 new_args[0] = return_type;
16233 memcpy (new_args + 1, args, nargs * sizeof (tree));
16238 /* We allow incomplete unification without an error message here
16239 because the standard doesn't seem to explicitly prohibit it. Our
16240 callers must be ready to deal with unification failures in any
16243 TREE_VALUE (tinst) = targs;
16244 /* If we aren't explaining yet, push tinst context so we can see where
16245 any errors (e.g. from class instantiations triggered by instantiation
16246 of default template arguments) come from. If we are explaining, this
16247 context is redundant. */
16248 if (!explain_p && !push_tinst_level (tinst))
16250 excessive_deduction_depth = true;
16254 /* type_unification_real will pass back any access checks from default
16255 template argument substitution. */
16256 vec<deferred_access_check, va_gc> *checks;
16259 ok = !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
16260 targs, parms, args, nargs, /*subr=*/0,
16261 strict, flags, &checks, explain_p);
16263 pop_tinst_level ();
16267 /* Now that we have bindings for all of the template arguments,
16268 ensure that the arguments deduced for the template template
16269 parameters have compatible template parameter lists. We cannot
16270 check this property before we have deduced all template
16271 arguments, because the template parameter types of a template
16272 template parameter might depend on prior template parameters
16273 deduced after the template template parameter. The following
16274 ill-formed example illustrates this issue:
16276 template<typename T, template<T> class C> void f(C<5>, T);
16278 template<int N> struct X {};
16281 f(X<5>(), 5l); // error: template argument deduction fails
16284 The template parameter list of 'C' depends on the template type
16285 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
16286 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
16287 time that we deduce 'C'. */
16288 if (!template_template_parm_bindings_ok_p
16289 (DECL_INNERMOST_TEMPLATE_PARMS (fn), targs))
16291 unify_inconsistent_template_template_parameters (explain_p);
16295 /* All is well so far. Now, check:
16299 When all template arguments have been deduced, all uses of
16300 template parameters in nondeduced contexts are replaced with
16301 the corresponding deduced argument values. If the
16302 substitution results in an invalid type, as described above,
16303 type deduction fails. */
16304 TREE_VALUE (tinst) = targs;
16305 if (!push_tinst_level (tinst))
16307 excessive_deduction_depth = true;
16311 /* Also collect access checks from the instantiation. */
16312 reopen_deferring_access_checks (checks);
16314 decl = instantiate_template (fn, targs, complain);
16316 checks = get_deferred_access_checks ();
16317 pop_deferring_access_checks ();
16319 pop_tinst_level ();
16321 if (decl == error_mark_node)
16324 /* Now perform any access checks encountered during substitution. */
16325 push_access_scope (decl);
16326 ok = perform_access_checks (checks, complain);
16327 pop_access_scope (decl);
16331 /* If we're looking for an exact match, check that what we got
16332 is indeed an exact match. It might not be if some template
16333 parameters are used in non-deduced contexts. But don't check
16334 for an exact match if we have dependent template arguments;
16335 in that case we're doing partial ordering, and we already know
16336 that we have two candidates that will provide the actual type. */
16337 if (strict == DEDUCE_EXACT && !any_dependent_template_arguments_p (targs))
16339 tree substed = TREE_TYPE (decl);
16343 = skip_artificial_parms_for (decl, TYPE_ARG_TYPES (substed));
16345 sarg = tree_cons (NULL_TREE, TREE_TYPE (substed), sarg);
16346 for (i = 0; i < nargs && sarg; ++i, sarg = TREE_CHAIN (sarg))
16347 if (!same_type_p (args[i], TREE_VALUE (sarg)))
16349 unify_type_mismatch (explain_p, args[i],
16350 TREE_VALUE (sarg));
16359 if (excessive_deduction_depth)
16361 if (deduction_depth == 0)
16362 /* Reset once we're all the way out. */
16363 excessive_deduction_depth = false;
16366 /* We can't free this if a pending_template entry or last_error_tinst_level
16367 is pointing at it. */
16368 if (last_pending_template == old_last_pend
16369 && last_error_tinst_level == old_error_tinst)
16375 /* Adjust types before performing type deduction, as described in
16376 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
16377 sections are symmetric. PARM is the type of a function parameter
16378 or the return type of the conversion function. ARG is the type of
16379 the argument passed to the call, or the type of the value
16380 initialized with the result of the conversion function.
16381 ARG_EXPR is the original argument expression, which may be null. */
16384 maybe_adjust_types_for_deduction (unification_kind_t strict,
16398 /* Swap PARM and ARG throughout the remainder of this
16399 function; the handling is precisely symmetric since PARM
16400 will initialize ARG rather than vice versa. */
16408 /* Core issue #873: Do the DR606 thing (see below) for these cases,
16409 too, but here handle it by stripping the reference from PARM
16410 rather than by adding it to ARG. */
16411 if (TREE_CODE (*parm) == REFERENCE_TYPE
16412 && TYPE_REF_IS_RVALUE (*parm)
16413 && TREE_CODE (TREE_TYPE (*parm)) == TEMPLATE_TYPE_PARM
16414 && cp_type_quals (TREE_TYPE (*parm)) == TYPE_UNQUALIFIED
16415 && TREE_CODE (*arg) == REFERENCE_TYPE
16416 && !TYPE_REF_IS_RVALUE (*arg))
16417 *parm = TREE_TYPE (*parm);
16418 /* Nothing else to do in this case. */
16422 gcc_unreachable ();
16425 if (TREE_CODE (*parm) != REFERENCE_TYPE)
16427 /* [temp.deduct.call]
16429 If P is not a reference type:
16431 --If A is an array type, the pointer type produced by the
16432 array-to-pointer standard conversion (_conv.array_) is
16433 used in place of A for type deduction; otherwise,
16435 --If A is a function type, the pointer type produced by
16436 the function-to-pointer standard conversion
16437 (_conv.func_) is used in place of A for type deduction;
16440 --If A is a cv-qualified type, the top level
16441 cv-qualifiers of A's type are ignored for type
16443 if (TREE_CODE (*arg) == ARRAY_TYPE)
16444 *arg = build_pointer_type (TREE_TYPE (*arg));
16445 else if (TREE_CODE (*arg) == FUNCTION_TYPE)
16446 *arg = build_pointer_type (*arg);
16448 *arg = TYPE_MAIN_VARIANT (*arg);
16451 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
16452 of the form T&&, where T is a template parameter, and the argument
16453 is an lvalue, T is deduced as A& */
16454 if (TREE_CODE (*parm) == REFERENCE_TYPE
16455 && TYPE_REF_IS_RVALUE (*parm)
16456 && TREE_CODE (TREE_TYPE (*parm)) == TEMPLATE_TYPE_PARM
16457 && cp_type_quals (TREE_TYPE (*parm)) == TYPE_UNQUALIFIED
16458 && (arg_expr ? real_lvalue_p (arg_expr)
16459 /* try_one_overload doesn't provide an arg_expr, but
16460 functions are always lvalues. */
16461 : TREE_CODE (*arg) == FUNCTION_TYPE))
16462 *arg = build_reference_type (*arg);
16464 /* [temp.deduct.call]
16466 If P is a cv-qualified type, the top level cv-qualifiers
16467 of P's type are ignored for type deduction. If P is a
16468 reference type, the type referred to by P is used for
16470 *parm = TYPE_MAIN_VARIANT (*parm);
16471 if (TREE_CODE (*parm) == REFERENCE_TYPE)
16473 *parm = TREE_TYPE (*parm);
16474 result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
16477 /* DR 322. For conversion deduction, remove a reference type on parm
16478 too (which has been swapped into ARG). */
16479 if (strict == DEDUCE_CONV && TREE_CODE (*arg) == REFERENCE_TYPE)
16480 *arg = TREE_TYPE (*arg);
16485 /* Subroutine of unify_one_argument. PARM is a function parameter of a
16486 template which does contain any deducible template parameters; check if
16487 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
16488 unify_one_argument. */
16491 check_non_deducible_conversion (tree parm, tree arg, int strict,
16492 int flags, bool explain_p)
16497 type = TREE_TYPE (arg);
16501 if (same_type_p (parm, type))
16502 return unify_success (explain_p);
16504 if (strict == DEDUCE_CONV)
16506 if (can_convert_arg (type, parm, NULL_TREE, flags,
16507 explain_p ? tf_warning_or_error : tf_none))
16508 return unify_success (explain_p);
16510 else if (strict != DEDUCE_EXACT)
16512 if (can_convert_arg (parm, type,
16513 TYPE_P (arg) ? NULL_TREE : arg,
16514 flags, explain_p ? tf_warning_or_error : tf_none))
16515 return unify_success (explain_p);
16518 if (strict == DEDUCE_EXACT)
16519 return unify_type_mismatch (explain_p, parm, arg);
16521 return unify_arg_conversion (explain_p, parm, type, arg);
16524 static bool uses_deducible_template_parms (tree type);
16526 /* Returns true iff the expression EXPR is one from which a template
16527 argument can be deduced. In other words, if it's an undecorated
16528 use of a template non-type parameter. */
16531 deducible_expression (tree expr)
16533 return (TREE_CODE (expr) == TEMPLATE_PARM_INDEX);
16536 /* Returns true iff the array domain DOMAIN uses a template parameter in a
16537 deducible way; that is, if it has a max value of <PARM> - 1. */
16540 deducible_array_bound (tree domain)
16542 if (domain == NULL_TREE)
16545 tree max = TYPE_MAX_VALUE (domain);
16546 if (TREE_CODE (max) != MINUS_EXPR)
16549 return deducible_expression (TREE_OPERAND (max, 0));
16552 /* Returns true iff the template arguments ARGS use a template parameter
16553 in a deducible way. */
16556 deducible_template_args (tree args)
16558 for (int i = 0; i < TREE_VEC_LENGTH (args); ++i)
16561 tree elt = TREE_VEC_ELT (args, i);
16562 if (ARGUMENT_PACK_P (elt))
16563 deducible = deducible_template_args (ARGUMENT_PACK_ARGS (elt));
16566 if (PACK_EXPANSION_P (elt))
16567 elt = PACK_EXPANSION_PATTERN (elt);
16568 if (TREE_CODE (elt) == TEMPLATE_TEMPLATE_PARM)
16570 else if (TYPE_P (elt))
16571 deducible = uses_deducible_template_parms (elt);
16573 deducible = deducible_expression (elt);
16581 /* Returns true iff TYPE contains any deducible references to template
16582 parameters, as per 14.8.2.5. */
16585 uses_deducible_template_parms (tree type)
16587 if (PACK_EXPANSION_P (type))
16588 type = PACK_EXPANSION_PATTERN (type);
16595 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
16596 || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
16602 if (POINTER_TYPE_P (type))
16603 return uses_deducible_template_parms (TREE_TYPE (type));
16605 /* T[integer-constant ]
16607 if (TREE_CODE (type) == ARRAY_TYPE)
16608 return (uses_deducible_template_parms (TREE_TYPE (type))
16609 || deducible_array_bound (TYPE_DOMAIN (type)));
16621 if (TYPE_PTRMEM_P (type))
16622 return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type))
16623 || (uses_deducible_template_parms
16624 (TYPE_PTRMEM_POINTED_TO_TYPE (type))));
16626 /* template-name <T> (where template-name refers to a class template)
16627 template-name <i> (where template-name refers to a class template) */
16628 if (CLASS_TYPE_P (type)
16629 && CLASSTYPE_TEMPLATE_INFO (type)
16630 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
16631 return deducible_template_args (INNERMOST_TEMPLATE_ARGS
16632 (CLASSTYPE_TI_ARGS (type)));
16637 if (TREE_CODE (type) == FUNCTION_TYPE
16638 || TREE_CODE (type) == METHOD_TYPE)
16640 if (uses_deducible_template_parms (TREE_TYPE (type)))
16642 tree parm = TYPE_ARG_TYPES (type);
16643 if (TREE_CODE (type) == METHOD_TYPE)
16644 parm = TREE_CHAIN (parm);
16645 for (; parm; parm = TREE_CHAIN (parm))
16646 if (uses_deducible_template_parms (TREE_VALUE (parm)))
16653 /* Subroutine of type_unification_real and unify_pack_expansion to
16654 handle unification of a single P/A pair. Parameters are as
16655 for those functions. */
16658 unify_one_argument (tree tparms, tree targs, tree parm, tree arg,
16659 int subr, unification_kind_t strict, int flags,
16662 tree arg_expr = NULL_TREE;
16665 if (arg == error_mark_node || parm == error_mark_node)
16666 return unify_invalid (explain_p);
16667 if (arg == unknown_type_node)
16668 /* We can't deduce anything from this, but we might get all the
16669 template args from other function args. */
16670 return unify_success (explain_p);
16672 /* Implicit conversions (Clause 4) will be performed on a function
16673 argument to convert it to the type of the corresponding function
16674 parameter if the parameter type contains no template-parameters that
16675 participate in template argument deduction. */
16676 if (TYPE_P (parm) && !uses_template_parms (parm))
16677 /* For function parameters that contain no template-parameters at all,
16678 we have historically checked for convertibility in order to shortcut
16679 consideration of this candidate. */
16680 return check_non_deducible_conversion (parm, arg, strict, flags,
16682 else if (strict == DEDUCE_CALL
16683 && TYPE_P (parm) && !uses_deducible_template_parms (parm))
16684 /* For function parameters with only non-deducible template parameters,
16686 return unify_success (explain_p);
16691 arg_strict = (UNIFY_ALLOW_OUTER_LEVEL
16692 | UNIFY_ALLOW_MORE_CV_QUAL
16693 | UNIFY_ALLOW_DERIVED);
16697 arg_strict = UNIFY_ALLOW_LESS_CV_QUAL;
16701 arg_strict = UNIFY_ALLOW_NONE;
16705 gcc_unreachable ();
16708 /* We only do these transformations if this is the top-level
16709 parameter_type_list in a call or declaration matching; in other
16710 situations (nested function declarators, template argument lists) we
16711 won't be comparing a type to an expression, and we don't do any type
16717 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
16718 if (type_unknown_p (arg))
16720 /* [temp.deduct.type] A template-argument can be
16721 deduced from a pointer to function or pointer
16722 to member function argument if the set of
16723 overloaded functions does not contain function
16724 templates and at most one of a set of
16725 overloaded functions provides a unique
16728 if (resolve_overloaded_unification
16729 (tparms, targs, parm, arg, strict,
16730 arg_strict, explain_p))
16731 return unify_success (explain_p);
16732 return unify_overload_resolution_failure (explain_p, arg);
16736 arg = unlowered_expr_type (arg);
16737 if (arg == error_mark_node)
16738 return unify_invalid (explain_p);
16742 maybe_adjust_types_for_deduction (strict, &parm, &arg, arg_expr);
16745 if ((TYPE_P (parm) || TREE_CODE (parm) == TEMPLATE_DECL)
16746 != (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL))
16747 return unify_template_argument_mismatch (explain_p, parm, arg);
16749 /* For deduction from an init-list we need the actual list. */
16750 if (arg_expr && BRACE_ENCLOSED_INITIALIZER_P (arg_expr))
16752 return unify (tparms, targs, parm, arg, arg_strict, explain_p);
16755 /* Most parms like fn_type_unification.
16757 If SUBR is 1, we're being called recursively (to unify the
16758 arguments of a function or method parameter of a function
16761 CHECKS is a pointer to a vector of access checks encountered while
16762 substituting default template arguments. */
16765 type_unification_real (tree tparms,
16769 unsigned int xnargs,
16771 unification_kind_t strict,
16773 vec<deferred_access_check, va_gc> **checks,
16778 int ntparms = TREE_VEC_LENGTH (tparms);
16779 int saw_undeduced = 0;
16782 unsigned int nargs;
16785 gcc_assert (TREE_CODE (tparms) == TREE_VEC);
16786 gcc_assert (xparms == NULL_TREE || TREE_CODE (xparms) == TREE_LIST);
16787 gcc_assert (ntparms > 0);
16789 /* Reset the number of non-defaulted template arguments contained
16791 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs) = NULL_TREE;
16799 while (parms && parms != void_list_node
16802 parm = TREE_VALUE (parms);
16804 if (TREE_CODE (parm) == TYPE_PACK_EXPANSION
16805 && (!TREE_CHAIN (parms) || TREE_CHAIN (parms) == void_list_node))
16806 /* For a function parameter pack that occurs at the end of the
16807 parameter-declaration-list, the type A of each remaining
16808 argument of the call is compared with the type P of the
16809 declarator-id of the function parameter pack. */
16812 parms = TREE_CHAIN (parms);
16814 if (TREE_CODE (parm) == TYPE_PACK_EXPANSION)
16815 /* For a function parameter pack that does not occur at the
16816 end of the parameter-declaration-list, the type of the
16817 parameter pack is a non-deduced context. */
16823 if (unify_one_argument (tparms, targs, parm, arg, subr, strict,
16829 && parms != void_list_node
16830 && TREE_CODE (TREE_VALUE (parms)) == TYPE_PACK_EXPANSION)
16832 /* Unify the remaining arguments with the pack expansion type. */
16834 tree parmvec = make_tree_vec (1);
16836 /* Allocate a TREE_VEC and copy in all of the arguments */
16837 argvec = make_tree_vec (nargs - ia);
16838 for (i = 0; ia < nargs; ++ia, ++i)
16839 TREE_VEC_ELT (argvec, i) = args[ia];
16841 /* Copy the parameter into parmvec. */
16842 TREE_VEC_ELT (parmvec, 0) = TREE_VALUE (parms);
16843 if (unify_pack_expansion (tparms, targs, parmvec, argvec, strict,
16844 /*subr=*/subr, explain_p))
16847 /* Advance to the end of the list of parameters. */
16848 parms = TREE_CHAIN (parms);
16851 /* Fail if we've reached the end of the parm list, and more args
16852 are present, and the parm list isn't variadic. */
16853 if (ia < nargs && parms == void_list_node)
16854 return unify_too_many_arguments (explain_p, nargs, ia);
16855 /* Fail if parms are left and they don't have default values and
16856 they aren't all deduced as empty packs (c++/57397). This is
16857 consistent with sufficient_parms_p. */
16858 if (parms && parms != void_list_node
16859 && TREE_PURPOSE (parms) == NULL_TREE)
16861 unsigned int count = nargs;
16866 type_pack_p = TREE_CODE (TREE_VALUE (p)) == TYPE_PACK_EXPANSION;
16869 p = TREE_CHAIN (p);
16871 while (p && p != void_list_node);
16872 if (count != nargs)
16873 return unify_too_few_arguments (explain_p, ia, count,
16879 tsubst_flags_t complain = (explain_p
16880 ? tf_warning_or_error
16883 for (i = 0; i < ntparms; i++)
16885 tree targ = TREE_VEC_ELT (targs, i);
16886 tree tparm = TREE_VEC_ELT (tparms, i);
16888 /* Clear the "incomplete" flags on all argument packs now so that
16889 substituting them into later default arguments works. */
16890 if (targ && ARGUMENT_PACK_P (targ))
16892 ARGUMENT_PACK_INCOMPLETE_P (targ) = 0;
16893 ARGUMENT_PACK_EXPLICIT_ARGS (targ) = NULL_TREE;
16896 if (targ || tparm == error_mark_node)
16898 tparm = TREE_VALUE (tparm);
16900 /* If this is an undeduced nontype parameter that depends on
16901 a type parameter, try another pass; its type may have been
16902 deduced from a later argument than the one from which
16903 this parameter can be deduced. */
16904 if (TREE_CODE (tparm) == PARM_DECL
16905 && uses_template_parms (TREE_TYPE (tparm))
16906 && !saw_undeduced++)
16909 /* Core issue #226 (C++0x) [temp.deduct]:
16911 If a template argument has not been deduced, its
16912 default template argument, if any, is used.
16914 When we are in C++98 mode, TREE_PURPOSE will either
16915 be NULL_TREE or ERROR_MARK_NODE, so we do not need
16916 to explicitly check cxx_dialect here. */
16917 if (TREE_PURPOSE (TREE_VEC_ELT (tparms, i)))
16919 tree parm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
16920 tree arg = TREE_PURPOSE (TREE_VEC_ELT (tparms, i));
16921 reopen_deferring_access_checks (*checks);
16922 location_t save_loc = input_location;
16924 input_location = DECL_SOURCE_LOCATION (parm);
16925 arg = tsubst_template_arg (arg, targs, complain, NULL_TREE);
16926 arg = convert_template_argument (parm, arg, targs, complain,
16928 input_location = save_loc;
16929 *checks = get_deferred_access_checks ();
16930 pop_deferring_access_checks ();
16931 if (arg == error_mark_node)
16935 TREE_VEC_ELT (targs, i) = arg;
16936 /* The position of the first default template argument,
16937 is also the number of non-defaulted arguments in TARGS.
16939 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs))
16940 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs, i);
16945 /* If the type parameter is a parameter pack, then it will
16946 be deduced to an empty parameter pack. */
16947 if (template_parameter_pack_p (tparm))
16951 if (TREE_CODE (tparm) == TEMPLATE_PARM_INDEX)
16953 arg = make_node (NONTYPE_ARGUMENT_PACK);
16954 TREE_TYPE (arg) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm));
16955 TREE_CONSTANT (arg) = 1;
16958 arg = cxx_make_type (TYPE_ARGUMENT_PACK);
16960 SET_ARGUMENT_PACK_ARGS (arg, make_tree_vec (0));
16962 TREE_VEC_ELT (targs, i) = arg;
16966 return unify_parameter_deduction_failure (explain_p, tparm);
16969 #ifdef ENABLE_CHECKING
16970 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs))
16971 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs, TREE_VEC_LENGTH (targs));
16974 return unify_success (explain_p);
16977 /* Subroutine of type_unification_real. Args are like the variables
16978 at the call site. ARG is an overloaded function (or template-id);
16979 we try deducing template args from each of the overloads, and if
16980 only one succeeds, we go with that. Modifies TARGS and returns
16981 true on success. */
16984 resolve_overloaded_unification (tree tparms,
16988 unification_kind_t strict,
16992 tree tempargs = copy_node (targs);
16994 tree goodfn = NULL_TREE;
16997 if (TREE_CODE (arg) == ADDR_EXPR)
16999 arg = TREE_OPERAND (arg, 0);
17005 if (TREE_CODE (arg) == COMPONENT_REF)
17006 /* Handle `&x' where `x' is some static or non-static member
17008 arg = TREE_OPERAND (arg, 1);
17010 if (TREE_CODE (arg) == OFFSET_REF)
17011 arg = TREE_OPERAND (arg, 1);
17013 /* Strip baselink information. */
17014 if (BASELINK_P (arg))
17015 arg = BASELINK_FUNCTIONS (arg);
17017 if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
17019 /* If we got some explicit template args, we need to plug them into
17020 the affected templates before we try to unify, in case the
17021 explicit args will completely resolve the templates in question. */
17024 tree expl_subargs = TREE_OPERAND (arg, 1);
17025 arg = TREE_OPERAND (arg, 0);
17027 for (; arg; arg = OVL_NEXT (arg))
17029 tree fn = OVL_CURRENT (arg);
17030 tree subargs, elem;
17032 if (TREE_CODE (fn) != TEMPLATE_DECL)
17035 subargs = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn),
17036 expl_subargs, NULL_TREE, tf_none,
17037 /*require_all_args=*/true,
17038 /*use_default_args=*/true);
17039 if (subargs != error_mark_node
17040 && !any_dependent_template_arguments_p (subargs))
17042 elem = TREE_TYPE (instantiate_template (fn, subargs, tf_none));
17043 if (try_one_overload (tparms, targs, tempargs, parm,
17044 elem, strict, sub_strict, addr_p, explain_p)
17045 && (!goodfn || !same_type_p (goodfn, elem)))
17054 /* If no templates (or more than one) are fully resolved by the
17055 explicit arguments, this template-id is a non-deduced context; it
17056 could still be OK if we deduce all template arguments for the
17057 enclosing call through other arguments. */
17061 else if (TREE_CODE (arg) != OVERLOAD
17062 && TREE_CODE (arg) != FUNCTION_DECL)
17063 /* If ARG is, for example, "(0, &f)" then its type will be unknown
17064 -- but the deduction does not succeed because the expression is
17065 not just the function on its own. */
17068 for (; arg; arg = OVL_NEXT (arg))
17069 if (try_one_overload (tparms, targs, tempargs, parm,
17070 TREE_TYPE (OVL_CURRENT (arg)),
17071 strict, sub_strict, addr_p, explain_p)
17072 && (!goodfn || !decls_match (goodfn, OVL_CURRENT (arg))))
17074 goodfn = OVL_CURRENT (arg);
17078 /* [temp.deduct.type] A template-argument can be deduced from a pointer
17079 to function or pointer to member function argument if the set of
17080 overloaded functions does not contain function templates and at most
17081 one of a set of overloaded functions provides a unique match.
17083 So if we found multiple possibilities, we return success but don't
17084 deduce anything. */
17088 int i = TREE_VEC_LENGTH (targs);
17090 if (TREE_VEC_ELT (tempargs, i))
17092 tree old = TREE_VEC_ELT (targs, i);
17093 tree new_ = TREE_VEC_ELT (tempargs, i);
17094 if (new_ && old && ARGUMENT_PACK_P (old)
17095 && ARGUMENT_PACK_EXPLICIT_ARGS (old))
17096 /* Don't forget explicit template arguments in a pack. */
17097 ARGUMENT_PACK_EXPLICIT_ARGS (new_)
17098 = ARGUMENT_PACK_EXPLICIT_ARGS (old);
17099 TREE_VEC_ELT (targs, i) = new_;
17108 /* Core DR 115: In contexts where deduction is done and fails, or in
17109 contexts where deduction is not done, if a template argument list is
17110 specified and it, along with any default template arguments, identifies
17111 a single function template specialization, then the template-id is an
17112 lvalue for the function template specialization. */
17115 resolve_nondeduced_context (tree orig_expr)
17117 tree expr, offset, baselink;
17120 if (!type_unknown_p (orig_expr))
17125 offset = NULL_TREE;
17126 baselink = NULL_TREE;
17128 if (TREE_CODE (expr) == ADDR_EXPR)
17130 expr = TREE_OPERAND (expr, 0);
17133 if (TREE_CODE (expr) == OFFSET_REF)
17136 expr = TREE_OPERAND (expr, 1);
17138 if (BASELINK_P (expr))
17141 expr = BASELINK_FUNCTIONS (expr);
17144 if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
17147 tree goodfn = NULL_TREE;
17149 /* If we got some explicit template args, we need to plug them into
17150 the affected templates before we try to unify, in case the
17151 explicit args will completely resolve the templates in question. */
17153 tree expl_subargs = TREE_OPERAND (expr, 1);
17154 tree arg = TREE_OPERAND (expr, 0);
17155 tree badfn = NULL_TREE;
17156 tree badargs = NULL_TREE;
17158 for (; arg; arg = OVL_NEXT (arg))
17160 tree fn = OVL_CURRENT (arg);
17161 tree subargs, elem;
17163 if (TREE_CODE (fn) != TEMPLATE_DECL)
17166 subargs = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn),
17167 expl_subargs, NULL_TREE, tf_none,
17168 /*require_all_args=*/true,
17169 /*use_default_args=*/true);
17170 if (subargs != error_mark_node
17171 && !any_dependent_template_arguments_p (subargs))
17173 elem = instantiate_template (fn, subargs, tf_none);
17174 if (elem == error_mark_node)
17179 else if (elem && (!goodfn || !decls_match (goodfn, elem)))
17188 mark_used (goodfn);
17191 expr = build_baselink (BASELINK_BINFO (baselink),
17192 BASELINK_ACCESS_BINFO (baselink),
17193 expr, BASELINK_OPTYPE (baselink));
17197 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset, 0)));
17198 expr = build_offset_ref (base, expr, addr, tf_warning_or_error);
17201 expr = cp_build_addr_expr (expr, tf_warning_or_error);
17204 else if (good == 0 && badargs)
17205 /* There were no good options and at least one bad one, so let the
17206 user know what the problem is. */
17207 instantiate_template (badfn, badargs, tf_warning_or_error);
17212 /* Subroutine of resolve_overloaded_unification; does deduction for a single
17213 overload. Fills TARGS with any deduced arguments, or error_mark_node if
17214 different overloads deduce different arguments for a given parm.
17215 ADDR_P is true if the expression for which deduction is being
17216 performed was of the form "& fn" rather than simply "fn".
17218 Returns 1 on success. */
17221 try_one_overload (tree tparms,
17226 unification_kind_t strict,
17235 if (arg == error_mark_node)
17238 /* [temp.deduct.type] A template-argument can be deduced from a pointer
17239 to function or pointer to member function argument if the set of
17240 overloaded functions does not contain function templates and at most
17241 one of a set of overloaded functions provides a unique match.
17243 So if this is a template, just return success. */
17245 if (uses_template_parms (arg))
17248 if (TREE_CODE (arg) == METHOD_TYPE)
17249 arg = build_ptrmemfunc_type (build_pointer_type (arg));
17251 arg = build_pointer_type (arg);
17253 sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg, NULL);
17255 /* We don't copy orig_targs for this because if we have already deduced
17256 some template args from previous args, unify would complain when we
17257 try to deduce a template parameter for the same argument, even though
17258 there isn't really a conflict. */
17259 nargs = TREE_VEC_LENGTH (targs);
17260 tempargs = make_tree_vec (nargs);
17262 if (unify (tparms, tempargs, parm, arg, sub_strict, explain_p))
17265 /* First make sure we didn't deduce anything that conflicts with
17266 explicitly specified args. */
17267 for (i = nargs; i--; )
17269 tree elt = TREE_VEC_ELT (tempargs, i);
17270 tree oldelt = TREE_VEC_ELT (orig_targs, i);
17274 else if (uses_template_parms (elt))
17275 /* Since we're unifying against ourselves, we will fill in
17276 template args used in the function parm list with our own
17277 template parms. Discard them. */
17278 TREE_VEC_ELT (tempargs, i) = NULL_TREE;
17279 else if (oldelt && !template_args_equal (oldelt, elt))
17283 for (i = nargs; i--; )
17285 tree elt = TREE_VEC_ELT (tempargs, i);
17288 TREE_VEC_ELT (targs, i) = elt;
17294 /* PARM is a template class (perhaps with unbound template
17295 parameters). ARG is a fully instantiated type. If ARG can be
17296 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
17297 TARGS are as for unify. */
17300 try_class_unification (tree tparms, tree targs, tree parm, tree arg,
17303 tree copy_of_targs;
17305 if (!CLASSTYPE_TEMPLATE_INFO (arg)
17306 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg))
17307 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm))))
17310 /* We need to make a new template argument vector for the call to
17311 unify. If we used TARGS, we'd clutter it up with the result of
17312 the attempted unification, even if this class didn't work out.
17313 We also don't want to commit ourselves to all the unifications
17314 we've already done, since unification is supposed to be done on
17315 an argument-by-argument basis. In other words, consider the
17316 following pathological case:
17318 template <int I, int J, int K>
17321 template <int I, int J>
17322 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
17324 template <int I, int J, int K>
17325 void f(S<I, J, K>, S<I, I, I>);
17334 Now, by the time we consider the unification involving `s2', we
17335 already know that we must have `f<0, 0, 0>'. But, even though
17336 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
17337 because there are two ways to unify base classes of S<0, 1, 2>
17338 with S<I, I, I>. If we kept the already deduced knowledge, we
17339 would reject the possibility I=1. */
17340 copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs));
17342 /* If unification failed, we're done. */
17343 if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm),
17344 CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE, explain_p))
17350 /* Given a template type PARM and a class type ARG, find the unique
17351 base type in ARG that is an instance of PARM. We do not examine
17352 ARG itself; only its base-classes. If there is not exactly one
17353 appropriate base class, return NULL_TREE. PARM may be the type of
17354 a partial specialization, as well as a plain template type. Used
17357 static enum template_base_result
17358 get_template_base (tree tparms, tree targs, tree parm, tree arg,
17359 bool explain_p, tree *result)
17361 tree rval = NULL_TREE;
17364 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg)));
17366 binfo = TYPE_BINFO (complete_type (arg));
17369 /* The type could not be completed. */
17370 *result = NULL_TREE;
17371 return tbr_incomplete_type;
17374 /* Walk in inheritance graph order. The search order is not
17375 important, and this avoids multiple walks of virtual bases. */
17376 for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo))
17378 tree r = try_class_unification (tparms, targs, parm,
17379 BINFO_TYPE (binfo), explain_p);
17383 /* If there is more than one satisfactory baseclass, then:
17387 If they yield more than one possible deduced A, the type
17391 if (rval && !same_type_p (r, rval))
17393 *result = NULL_TREE;
17394 return tbr_ambiguous_baseclass;
17402 return tbr_success;
17405 /* Returns the level of DECL, which declares a template parameter. */
17408 template_decl_level (tree decl)
17410 switch (TREE_CODE (decl))
17413 case TEMPLATE_DECL:
17414 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl));
17417 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
17420 gcc_unreachable ();
17425 /* Decide whether ARG can be unified with PARM, considering only the
17426 cv-qualifiers of each type, given STRICT as documented for unify.
17427 Returns nonzero iff the unification is OK on that basis. */
17430 check_cv_quals_for_unify (int strict, tree arg, tree parm)
17432 int arg_quals = cp_type_quals (arg);
17433 int parm_quals = cp_type_quals (parm);
17435 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
17436 && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
17438 /* Although a CVR qualifier is ignored when being applied to a
17439 substituted template parameter ([8.3.2]/1 for example), that
17440 does not allow us to unify "const T" with "int&" because both
17441 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
17442 It is ok when we're allowing additional CV qualifiers
17443 at the outer level [14.8.2.1]/3,1st bullet. */
17444 if ((TREE_CODE (arg) == REFERENCE_TYPE
17445 || TREE_CODE (arg) == FUNCTION_TYPE
17446 || TREE_CODE (arg) == METHOD_TYPE)
17447 && (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)))
17450 if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
17451 && (parm_quals & TYPE_QUAL_RESTRICT))
17455 if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
17456 && (arg_quals & parm_quals) != parm_quals)
17459 if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL))
17460 && (parm_quals & arg_quals) != arg_quals)
17466 /* Determines the LEVEL and INDEX for the template parameter PARM. */
17468 template_parm_level_and_index (tree parm, int* level, int* index)
17470 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
17471 || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
17472 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
17474 *index = TEMPLATE_TYPE_IDX (parm);
17475 *level = TEMPLATE_TYPE_LEVEL (parm);
17479 *index = TEMPLATE_PARM_IDX (parm);
17480 *level = TEMPLATE_PARM_LEVEL (parm);
17484 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
17486 if (unify (TP, TA, P, A, S, EP)) \
17490 /* Unifies the remaining arguments in PACKED_ARGS with the pack
17491 expansion at the end of PACKED_PARMS. Returns 0 if the type
17492 deduction succeeds, 1 otherwise. STRICT is the same as in
17493 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
17494 call argument list. We'll need to adjust the arguments to make them
17495 types. SUBR tells us if this is from a recursive call to
17496 type_unification_real, or for comparing two template argument
17500 unify_pack_expansion (tree tparms, tree targs, tree packed_parms,
17501 tree packed_args, unification_kind_t strict,
17502 bool subr, bool explain_p)
17505 = TREE_VEC_ELT (packed_parms, TREE_VEC_LENGTH (packed_parms) - 1);
17506 tree pattern = PACK_EXPANSION_PATTERN (parm);
17507 tree pack, packs = NULL_TREE;
17508 int i, start = TREE_VEC_LENGTH (packed_parms) - 1;
17510 packed_args = expand_template_argument_pack (packed_args);
17512 int len = TREE_VEC_LENGTH (packed_args);
17514 /* Determine the parameter packs we will be deducing from the
17515 pattern, and record their current deductions. */
17516 for (pack = PACK_EXPANSION_PARAMETER_PACKS (parm);
17517 pack; pack = TREE_CHAIN (pack))
17519 tree parm_pack = TREE_VALUE (pack);
17522 /* Determine the index and level of this parameter pack. */
17523 template_parm_level_and_index (parm_pack, &level, &idx);
17525 /* Keep track of the parameter packs and their corresponding
17527 packs = tree_cons (parm_pack, TMPL_ARG (targs, level, idx), packs);
17528 TREE_TYPE (packs) = make_tree_vec (len - start);
17531 /* Loop through all of the arguments that have not yet been
17532 unified and unify each with the pattern. */
17533 for (i = start; i < len; i++)
17536 bool any_explicit = false;
17537 tree arg = TREE_VEC_ELT (packed_args, i);
17539 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
17540 or the element of its argument pack at the current index if
17541 this argument was explicitly specified. */
17542 for (pack = packs; pack; pack = TREE_CHAIN (pack))
17546 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
17549 if (TREE_VALUE (pack)
17550 && (pargs = ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack)))
17551 && (i - start < TREE_VEC_LENGTH (pargs)))
17553 any_explicit = true;
17554 arg = TREE_VEC_ELT (pargs, i - start);
17556 TMPL_ARG (targs, level, idx) = arg;
17559 /* If we had explicit template arguments, substitute them into the
17560 pattern before deduction. */
17563 /* Some arguments might still be unspecified or dependent. */
17565 ++processing_template_decl;
17566 dependent = any_dependent_template_arguments_p (targs);
17568 --processing_template_decl;
17569 parm = tsubst (pattern, targs,
17570 explain_p ? tf_warning_or_error : tf_none,
17573 --processing_template_decl;
17574 if (parm == error_mark_node)
17580 /* Unify the pattern with the current argument. */
17581 if (unify_one_argument (tparms, targs, parm, arg, subr, strict,
17582 LOOKUP_IMPLICIT, explain_p))
17585 /* For each parameter pack, collect the deduced value. */
17586 for (pack = packs; pack; pack = TREE_CHAIN (pack))
17589 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
17591 TREE_VEC_ELT (TREE_TYPE (pack), i - start) =
17592 TMPL_ARG (targs, level, idx);
17596 /* Verify that the results of unification with the parameter packs
17597 produce results consistent with what we've seen before, and make
17598 the deduced argument packs available. */
17599 for (pack = packs; pack; pack = TREE_CHAIN (pack))
17601 tree old_pack = TREE_VALUE (pack);
17602 tree new_args = TREE_TYPE (pack);
17603 int i, len = TREE_VEC_LENGTH (new_args);
17605 bool nondeduced_p = false;
17607 /* By default keep the original deduced argument pack.
17608 If necessary, more specific code is going to update the
17609 resulting deduced argument later down in this function. */
17610 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
17611 TMPL_ARG (targs, level, idx) = old_pack;
17613 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
17614 actually deduce anything. */
17615 for (i = 0; i < len && !nondeduced_p; ++i)
17616 if (TREE_VEC_ELT (new_args, i) == NULL_TREE)
17617 nondeduced_p = true;
17621 if (old_pack && ARGUMENT_PACK_INCOMPLETE_P (old_pack))
17623 /* If we had fewer function args than explicit template args,
17624 just use the explicits. */
17625 tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
17626 int explicit_len = TREE_VEC_LENGTH (explicit_args);
17627 if (len < explicit_len)
17628 new_args = explicit_args;
17634 /* Build the deduced *_ARGUMENT_PACK. */
17635 if (TREE_CODE (TREE_PURPOSE (pack)) == TEMPLATE_PARM_INDEX)
17637 result = make_node (NONTYPE_ARGUMENT_PACK);
17638 TREE_TYPE (result) =
17639 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack)));
17640 TREE_CONSTANT (result) = 1;
17643 result = cxx_make_type (TYPE_ARGUMENT_PACK);
17645 SET_ARGUMENT_PACK_ARGS (result, new_args);
17647 /* Note the deduced argument packs for this parameter
17649 TMPL_ARG (targs, level, idx) = result;
17651 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack)
17652 && (ARGUMENT_PACK_ARGS (old_pack)
17653 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack)))
17655 /* We only had the explicitly-provided arguments before, but
17656 now we have a complete set of arguments. */
17657 tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
17659 SET_ARGUMENT_PACK_ARGS (old_pack, new_args);
17660 ARGUMENT_PACK_INCOMPLETE_P (old_pack) = 1;
17661 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack) = explicit_args;
17665 tree bad_old_arg = NULL_TREE, bad_new_arg = NULL_TREE;
17666 tree old_args = ARGUMENT_PACK_ARGS (old_pack);
17668 if (!comp_template_args_with_info (old_args, new_args,
17669 &bad_old_arg, &bad_new_arg))
17670 /* Inconsistent unification of this parameter pack. */
17671 return unify_parameter_pack_inconsistent (explain_p,
17677 return unify_success (explain_p);
17680 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
17681 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
17682 parameters and return value are as for unify. */
17685 unify_array_domain (tree tparms, tree targs,
17686 tree parm_dom, tree arg_dom,
17694 /* Our representation of array types uses "N - 1" as the
17695 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
17696 not an integer constant. We cannot unify arbitrarily
17697 complex expressions, so we eliminate the MINUS_EXPRs
17699 parm_max = TYPE_MAX_VALUE (parm_dom);
17700 parm_cst = TREE_CODE (parm_max) == INTEGER_CST;
17703 gcc_assert (TREE_CODE (parm_max) == MINUS_EXPR);
17704 parm_max = TREE_OPERAND (parm_max, 0);
17706 arg_max = TYPE_MAX_VALUE (arg_dom);
17707 arg_cst = TREE_CODE (arg_max) == INTEGER_CST;
17710 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
17711 trying to unify the type of a variable with the type
17712 of a template parameter. For example:
17714 template <unsigned int N>
17715 void f (char (&) [N]);
17722 Here, the type of the ARG will be "int [g(i)]", and
17723 may be a SAVE_EXPR, etc. */
17724 if (TREE_CODE (arg_max) != MINUS_EXPR)
17725 return unify_vla_arg (explain_p, arg_dom);
17726 arg_max = TREE_OPERAND (arg_max, 0);
17729 /* If only one of the bounds used a MINUS_EXPR, compensate
17730 by adding one to the other bound. */
17731 if (parm_cst && !arg_cst)
17732 parm_max = fold_build2_loc (input_location, PLUS_EXPR,
17736 else if (arg_cst && !parm_cst)
17737 arg_max = fold_build2_loc (input_location, PLUS_EXPR,
17742 return unify (tparms, targs, parm_max, arg_max,
17743 UNIFY_ALLOW_INTEGER, explain_p);
17746 /* Deduce the value of template parameters. TPARMS is the (innermost)
17747 set of template parameters to a template. TARGS is the bindings
17748 for those template parameters, as determined thus far; TARGS may
17749 include template arguments for outer levels of template parameters
17750 as well. PARM is a parameter to a template function, or a
17751 subcomponent of that parameter; ARG is the corresponding argument.
17752 This function attempts to match PARM with ARG in a manner
17753 consistent with the existing assignments in TARGS. If more values
17754 are deduced, then TARGS is updated.
17756 Returns 0 if the type deduction succeeds, 1 otherwise. The
17757 parameter STRICT is a bitwise or of the following flags:
17760 Require an exact match between PARM and ARG.
17761 UNIFY_ALLOW_MORE_CV_QUAL:
17762 Allow the deduced ARG to be more cv-qualified (by qualification
17763 conversion) than ARG.
17764 UNIFY_ALLOW_LESS_CV_QUAL:
17765 Allow the deduced ARG to be less cv-qualified than ARG.
17766 UNIFY_ALLOW_DERIVED:
17767 Allow the deduced ARG to be a template base class of ARG,
17768 or a pointer to a template base class of the type pointed to by
17770 UNIFY_ALLOW_INTEGER:
17771 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
17772 case for more information.
17773 UNIFY_ALLOW_OUTER_LEVEL:
17774 This is the outermost level of a deduction. Used to determine validity
17775 of qualification conversions. A valid qualification conversion must
17776 have const qualified pointers leading up to the inner type which
17777 requires additional CV quals, except at the outer level, where const
17778 is not required [conv.qual]. It would be normal to set this flag in
17779 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
17780 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
17781 This is the outermost level of a deduction, and PARM can be more CV
17782 qualified at this point.
17783 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
17784 This is the outermost level of a deduction, and PARM can be less CV
17785 qualified at this point. */
17788 unify (tree tparms, tree targs, tree parm, tree arg, int strict,
17794 int strict_in = strict;
17796 /* I don't think this will do the right thing with respect to types.
17797 But the only case I've seen it in so far has been array bounds, where
17798 signedness is the only information lost, and I think that will be
17800 while (TREE_CODE (parm) == NOP_EXPR)
17801 parm = TREE_OPERAND (parm, 0);
17803 if (arg == error_mark_node)
17804 return unify_invalid (explain_p);
17805 if (arg == unknown_type_node
17806 || arg == init_list_type_node)
17807 /* We can't deduce anything from this, but we might get all the
17808 template args from other function args. */
17809 return unify_success (explain_p);
17811 /* If PARM uses template parameters, then we can't bail out here,
17812 even if ARG == PARM, since we won't record unifications for the
17813 template parameters. We might need them if we're trying to
17814 figure out which of two things is more specialized. */
17815 if (arg == parm && !uses_template_parms (parm))
17816 return unify_success (explain_p);
17818 /* Handle init lists early, so the rest of the function can assume
17819 we're dealing with a type. */
17820 if (BRACE_ENCLOSED_INITIALIZER_P (arg))
17824 tree orig_parm = parm;
17826 /* Replace T with std::initializer_list<T> for deduction. */
17827 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
17828 && flag_deduce_init_list)
17829 parm = listify (parm);
17831 if (!is_std_init_list (parm)
17832 && TREE_CODE (parm) != ARRAY_TYPE)
17833 /* We can only deduce from an initializer list argument if the
17834 parameter is std::initializer_list or an array; otherwise this
17835 is a non-deduced context. */
17836 return unify_success (explain_p);
17838 if (TREE_CODE (parm) == ARRAY_TYPE)
17839 elttype = TREE_TYPE (parm);
17842 elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm), 0);
17843 /* Deduction is defined in terms of a single type, so just punt
17844 on the (bizarre) std::initializer_list<T...>. */
17845 if (PACK_EXPANSION_P (elttype))
17846 return unify_success (explain_p);
17849 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg), i, elt)
17851 int elt_strict = strict;
17853 if (elt == error_mark_node)
17854 return unify_invalid (explain_p);
17856 if (!BRACE_ENCLOSED_INITIALIZER_P (elt))
17858 tree type = TREE_TYPE (elt);
17859 if (type == error_mark_node)
17860 return unify_invalid (explain_p);
17861 /* It should only be possible to get here for a call. */
17862 gcc_assert (elt_strict & UNIFY_ALLOW_OUTER_LEVEL);
17863 elt_strict |= maybe_adjust_types_for_deduction
17864 (DEDUCE_CALL, &elttype, &type, elt);
17868 RECUR_AND_CHECK_FAILURE (tparms, targs, elttype, elt, elt_strict,
17872 if (TREE_CODE (parm) == ARRAY_TYPE
17873 && deducible_array_bound (TYPE_DOMAIN (parm)))
17875 /* Also deduce from the length of the initializer list. */
17876 tree max = size_int (CONSTRUCTOR_NELTS (arg));
17877 tree idx = compute_array_index_type (NULL_TREE, max, tf_none);
17878 if (idx == error_mark_node)
17879 return unify_invalid (explain_p);
17880 return unify_array_domain (tparms, targs, TYPE_DOMAIN (parm),
17884 /* If the std::initializer_list<T> deduction worked, replace the
17885 deduced A with std::initializer_list<A>. */
17886 if (orig_parm != parm)
17888 idx = TEMPLATE_TYPE_IDX (orig_parm);
17889 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
17890 targ = listify (targ);
17891 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = targ;
17893 return unify_success (explain_p);
17896 /* Immediately reject some pairs that won't unify because of
17897 cv-qualification mismatches. */
17898 if (TREE_CODE (arg) == TREE_CODE (parm)
17900 /* It is the elements of the array which hold the cv quals of an array
17901 type, and the elements might be template type parms. We'll check
17902 when we recurse. */
17903 && TREE_CODE (arg) != ARRAY_TYPE
17904 /* We check the cv-qualifiers when unifying with template type
17905 parameters below. We want to allow ARG `const T' to unify with
17906 PARM `T' for example, when computing which of two templates
17907 is more specialized, for example. */
17908 && TREE_CODE (arg) != TEMPLATE_TYPE_PARM
17909 && !check_cv_quals_for_unify (strict_in, arg, parm))
17910 return unify_cv_qual_mismatch (explain_p, parm, arg);
17912 if (!(strict & UNIFY_ALLOW_OUTER_LEVEL)
17913 && TYPE_P (parm) && !CP_TYPE_CONST_P (parm))
17914 strict &= ~UNIFY_ALLOW_MORE_CV_QUAL;
17915 strict &= ~UNIFY_ALLOW_OUTER_LEVEL;
17916 strict &= ~UNIFY_ALLOW_DERIVED;
17917 strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
17918 strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL;
17920 switch (TREE_CODE (parm))
17922 case TYPENAME_TYPE:
17924 case UNBOUND_CLASS_TEMPLATE:
17925 /* In a type which contains a nested-name-specifier, template
17926 argument values cannot be deduced for template parameters used
17927 within the nested-name-specifier. */
17928 return unify_success (explain_p);
17930 case TEMPLATE_TYPE_PARM:
17931 case TEMPLATE_TEMPLATE_PARM:
17932 case BOUND_TEMPLATE_TEMPLATE_PARM:
17933 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
17934 if (error_operand_p (tparm))
17935 return unify_invalid (explain_p);
17937 if (TEMPLATE_TYPE_LEVEL (parm)
17938 != template_decl_level (tparm))
17939 /* The PARM is not one we're trying to unify. Just check
17940 to see if it matches ARG. */
17942 if (TREE_CODE (arg) == TREE_CODE (parm)
17943 && (is_auto (parm) ? is_auto (arg)
17944 : same_type_p (parm, arg)))
17945 return unify_success (explain_p);
17947 return unify_type_mismatch (explain_p, parm, arg);
17949 idx = TEMPLATE_TYPE_IDX (parm);
17950 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
17951 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx));
17952 if (error_operand_p (tparm))
17953 return unify_invalid (explain_p);
17955 /* Check for mixed types and values. */
17956 if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
17957 && TREE_CODE (tparm) != TYPE_DECL)
17958 || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
17959 && TREE_CODE (tparm) != TEMPLATE_DECL))
17960 gcc_unreachable ();
17962 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
17964 /* ARG must be constructed from a template class or a template
17965 template parameter. */
17966 if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM
17967 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg))
17968 return unify_template_deduction_failure (explain_p, parm, arg);
17970 tree parmvec = TYPE_TI_ARGS (parm);
17971 /* An alias template name is never deduced. */
17972 if (TYPE_ALIAS_P (arg))
17973 arg = strip_typedefs (arg);
17974 tree argvec = INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg));
17975 tree full_argvec = add_to_template_args (targs, argvec);
17977 = DECL_INNERMOST_TEMPLATE_PARMS
17978 (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm));
17980 int parm_variadic_p = 0;
17982 /* The resolution to DR150 makes clear that default
17983 arguments for an N-argument may not be used to bind T
17984 to a template template parameter with fewer than N
17985 parameters. It is not safe to permit the binding of
17986 default arguments as an extension, as that may change
17987 the meaning of a conforming program. Consider:
17989 struct Dense { static const unsigned int dim = 1; };
17991 template <template <typename> class View,
17993 void operator+(float, View<Block> const&);
17995 template <typename Block,
17996 unsigned int Dim = Block::dim>
17997 struct Lvalue_proxy { operator float() const; };
18001 Lvalue_proxy<Dense> p;
18006 Here, if Lvalue_proxy is permitted to bind to View, then
18007 the global operator+ will be used; if they are not, the
18008 Lvalue_proxy will be converted to float. */
18009 if (coerce_template_parms (parm_parms,
18011 TYPE_TI_TEMPLATE (parm),
18013 ? tf_warning_or_error
18015 /*require_all_args=*/true,
18016 /*use_default_args=*/false)
18017 == error_mark_node)
18020 /* Deduce arguments T, i from TT<T> or TT<i>.
18021 We check each element of PARMVEC and ARGVEC individually
18022 rather than the whole TREE_VEC since they can have
18023 different number of elements. */
18025 parmvec = expand_template_argument_pack (parmvec);
18026 argvec = expand_template_argument_pack (argvec);
18028 len = TREE_VEC_LENGTH (parmvec);
18030 /* Check if the parameters end in a pack, making them
18033 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec, len - 1)))
18034 parm_variadic_p = 1;
18036 for (i = 0; i < len - parm_variadic_p; ++i)
18037 /* If the template argument list of P contains a pack
18038 expansion that is not the last template argument, the
18039 entire template argument list is a non-deduced
18041 if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec, i)))
18042 return unify_success (explain_p);
18044 if (TREE_VEC_LENGTH (argvec) < len - parm_variadic_p)
18045 return unify_too_few_arguments (explain_p,
18046 TREE_VEC_LENGTH (argvec), len);
18048 for (i = 0; i < len - parm_variadic_p; ++i)
18050 RECUR_AND_CHECK_FAILURE (tparms, targs,
18051 TREE_VEC_ELT (parmvec, i),
18052 TREE_VEC_ELT (argvec, i),
18053 UNIFY_ALLOW_NONE, explain_p);
18056 if (parm_variadic_p
18057 && unify_pack_expansion (tparms, targs,
18060 /*subr=*/true, explain_p))
18063 arg = TYPE_TI_TEMPLATE (arg);
18065 /* Fall through to deduce template name. */
18068 if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
18069 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
18071 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
18073 /* Simple cases: Value already set, does match or doesn't. */
18074 if (targ != NULL_TREE && template_args_equal (targ, arg))
18075 return unify_success (explain_p);
18077 return unify_inconsistency (explain_p, parm, targ, arg);
18081 /* If PARM is `const T' and ARG is only `int', we don't have
18082 a match unless we are allowing additional qualification.
18083 If ARG is `const int' and PARM is just `T' that's OK;
18084 that binds `const int' to `T'. */
18085 if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL,
18087 return unify_cv_qual_mismatch (explain_p, parm, arg);
18089 /* Consider the case where ARG is `const volatile int' and
18090 PARM is `const T'. Then, T should be `volatile int'. */
18091 arg = cp_build_qualified_type_real
18092 (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
18093 if (arg == error_mark_node)
18094 return unify_invalid (explain_p);
18096 /* Simple cases: Value already set, does match or doesn't. */
18097 if (targ != NULL_TREE && same_type_p (targ, arg))
18098 return unify_success (explain_p);
18100 return unify_inconsistency (explain_p, parm, targ, arg);
18102 /* Make sure that ARG is not a variable-sized array. (Note
18103 that were talking about variable-sized arrays (like
18104 `int[n]'), rather than arrays of unknown size (like
18105 `int[]').) We'll get very confused by such a type since
18106 the bound of the array is not constant, and therefore
18107 not mangleable. Besides, such types are not allowed in
18108 ISO C++, so we can do as we please here. We do allow
18109 them for 'auto' deduction, since that isn't ABI-exposed. */
18110 if (!is_auto (parm) && variably_modified_type_p (arg, NULL_TREE))
18111 return unify_vla_arg (explain_p, arg);
18113 /* Strip typedefs as in convert_template_argument. */
18114 arg = canonicalize_type_argument (arg, tf_none);
18117 /* If ARG is a parameter pack or an expansion, we cannot unify
18118 against it unless PARM is also a parameter pack. */
18119 if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
18120 && !template_parameter_pack_p (parm))
18121 return unify_parameter_pack_mismatch (explain_p, parm, arg);
18123 /* If the argument deduction results is a METHOD_TYPE,
18124 then there is a problem.
18125 METHOD_TYPE doesn't map to any real C++ type the result of
18126 the deduction can not be of that type. */
18127 if (TREE_CODE (arg) == METHOD_TYPE)
18128 return unify_method_type_error (explain_p, arg);
18130 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
18131 return unify_success (explain_p);
18133 case TEMPLATE_PARM_INDEX:
18134 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
18135 if (error_operand_p (tparm))
18136 return unify_invalid (explain_p);
18138 if (TEMPLATE_PARM_LEVEL (parm)
18139 != template_decl_level (tparm))
18141 /* The PARM is not one we're trying to unify. Just check
18142 to see if it matches ARG. */
18143 int result = !(TREE_CODE (arg) == TREE_CODE (parm)
18144 && cp_tree_equal (parm, arg));
18146 unify_expression_unequal (explain_p, parm, arg);
18150 idx = TEMPLATE_PARM_IDX (parm);
18151 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
18155 int x = !cp_tree_equal (targ, arg);
18157 unify_inconsistency (explain_p, parm, targ, arg);
18161 /* [temp.deduct.type] If, in the declaration of a function template
18162 with a non-type template-parameter, the non-type
18163 template-parameter is used in an expression in the function
18164 parameter-list and, if the corresponding template-argument is
18165 deduced, the template-argument type shall match the type of the
18166 template-parameter exactly, except that a template-argument
18167 deduced from an array bound may be of any integral type.
18168 The non-type parameter might use already deduced type parameters. */
18169 tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE);
18170 if (!TREE_TYPE (arg))
18171 /* Template-parameter dependent expression. Just accept it for now.
18172 It will later be processed in convert_template_argument. */
18174 else if (same_type_p (TREE_TYPE (arg), tparm))
18176 else if ((strict & UNIFY_ALLOW_INTEGER)
18177 && CP_INTEGRAL_TYPE_P (tparm))
18178 /* Convert the ARG to the type of PARM; the deduced non-type
18179 template argument must exactly match the types of the
18180 corresponding parameter. */
18181 arg = fold (build_nop (tparm, arg));
18182 else if (uses_template_parms (tparm))
18183 /* We haven't deduced the type of this parameter yet. Try again
18185 return unify_success (explain_p);
18187 return unify_type_mismatch (explain_p, tparm, TREE_TYPE (arg));
18189 /* If ARG is a parameter pack or an expansion, we cannot unify
18190 against it unless PARM is also a parameter pack. */
18191 if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
18192 && !TEMPLATE_PARM_PARAMETER_PACK (parm))
18193 return unify_parameter_pack_mismatch (explain_p, parm, arg);
18195 arg = strip_typedefs_expr (arg);
18196 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
18197 return unify_success (explain_p);
18201 /* A pointer-to-member constant can be unified only with
18202 another constant. */
18203 if (TREE_CODE (arg) != PTRMEM_CST)
18204 return unify_ptrmem_cst_mismatch (explain_p, parm, arg);
18206 /* Just unify the class member. It would be useless (and possibly
18207 wrong, depending on the strict flags) to unify also
18208 PTRMEM_CST_CLASS, because we want to be sure that both parm and
18209 arg refer to the same variable, even if through different
18210 classes. For instance:
18212 struct A { int x; };
18215 Unification of &A::x and &B::x must succeed. */
18216 return unify (tparms, targs, PTRMEM_CST_MEMBER (parm),
18217 PTRMEM_CST_MEMBER (arg), strict, explain_p);
18222 if (!TYPE_PTR_P (arg))
18223 return unify_type_mismatch (explain_p, parm, arg);
18225 /* [temp.deduct.call]
18227 A can be another pointer or pointer to member type that can
18228 be converted to the deduced A via a qualification
18229 conversion (_conv.qual_).
18231 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
18232 This will allow for additional cv-qualification of the
18233 pointed-to types if appropriate. */
18235 if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
18236 /* The derived-to-base conversion only persists through one
18237 level of pointers. */
18238 strict |= (strict_in & UNIFY_ALLOW_DERIVED);
18240 return unify (tparms, targs, TREE_TYPE (parm),
18241 TREE_TYPE (arg), strict, explain_p);
18244 case REFERENCE_TYPE:
18245 if (TREE_CODE (arg) != REFERENCE_TYPE)
18246 return unify_type_mismatch (explain_p, parm, arg);
18247 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
18248 strict & UNIFY_ALLOW_MORE_CV_QUAL, explain_p);
18251 if (TREE_CODE (arg) != ARRAY_TYPE)
18252 return unify_type_mismatch (explain_p, parm, arg);
18253 if ((TYPE_DOMAIN (parm) == NULL_TREE)
18254 != (TYPE_DOMAIN (arg) == NULL_TREE))
18255 return unify_type_mismatch (explain_p, parm, arg);
18256 RECUR_AND_CHECK_FAILURE (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
18257 strict & UNIFY_ALLOW_MORE_CV_QUAL, explain_p);
18258 if (TYPE_DOMAIN (parm) != NULL_TREE)
18259 return unify_array_domain (tparms, targs, TYPE_DOMAIN (parm),
18260 TYPE_DOMAIN (arg), explain_p);
18261 return unify_success (explain_p);
18268 case ENUMERAL_TYPE:
18271 if (TREE_CODE (arg) != TREE_CODE (parm))
18272 return unify_type_mismatch (explain_p, parm, arg);
18274 /* We have already checked cv-qualification at the top of the
18276 if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
18277 return unify_type_mismatch (explain_p, parm, arg);
18279 /* As far as unification is concerned, this wins. Later checks
18280 will invalidate it if necessary. */
18281 return unify_success (explain_p);
18283 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
18284 /* Type INTEGER_CST can come from ordinary constant template args. */
18286 while (TREE_CODE (arg) == NOP_EXPR)
18287 arg = TREE_OPERAND (arg, 0);
18289 if (TREE_CODE (arg) != INTEGER_CST)
18290 return unify_template_argument_mismatch (explain_p, parm, arg);
18291 return (tree_int_cst_equal (parm, arg)
18292 ? unify_success (explain_p)
18293 : unify_template_argument_mismatch (explain_p, parm, arg));
18297 int i, len, argslen;
18298 int parm_variadic_p = 0;
18300 if (TREE_CODE (arg) != TREE_VEC)
18301 return unify_template_argument_mismatch (explain_p, parm, arg);
18303 len = TREE_VEC_LENGTH (parm);
18304 argslen = TREE_VEC_LENGTH (arg);
18306 /* Check for pack expansions in the parameters. */
18307 for (i = 0; i < len; ++i)
18309 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm, i)))
18312 /* We can unify against something with a trailing
18314 parm_variadic_p = 1;
18316 /* [temp.deduct.type]/9: If the template argument list of
18317 P contains a pack expansion that is not the last
18318 template argument, the entire template argument list
18319 is a non-deduced context. */
18320 return unify_success (explain_p);
18324 /* If we don't have enough arguments to satisfy the parameters
18325 (not counting the pack expression at the end), or we have
18326 too many arguments for a parameter list that doesn't end in
18327 a pack expression, we can't unify. */
18328 if (parm_variadic_p
18329 ? argslen < len - parm_variadic_p
18331 return unify_arity (explain_p, TREE_VEC_LENGTH (arg), len);
18333 /* Unify all of the parameters that precede the (optional)
18334 pack expression. */
18335 for (i = 0; i < len - parm_variadic_p; ++i)
18337 RECUR_AND_CHECK_FAILURE (tparms, targs,
18338 TREE_VEC_ELT (parm, i),
18339 TREE_VEC_ELT (arg, i),
18340 UNIFY_ALLOW_NONE, explain_p);
18342 if (parm_variadic_p)
18343 return unify_pack_expansion (tparms, targs, parm, arg,
18345 /*subr=*/true, explain_p);
18346 return unify_success (explain_p);
18351 if (TREE_CODE (arg) != TREE_CODE (parm))
18352 return unify_type_mismatch (explain_p, parm, arg);
18354 if (TYPE_PTRMEMFUNC_P (parm))
18356 if (!TYPE_PTRMEMFUNC_P (arg))
18357 return unify_type_mismatch (explain_p, parm, arg);
18359 return unify (tparms, targs,
18360 TYPE_PTRMEMFUNC_FN_TYPE (parm),
18361 TYPE_PTRMEMFUNC_FN_TYPE (arg),
18362 strict, explain_p);
18364 else if (TYPE_PTRMEMFUNC_P (arg))
18365 return unify_type_mismatch (explain_p, parm, arg);
18367 if (CLASSTYPE_TEMPLATE_INFO (parm))
18369 tree t = NULL_TREE;
18371 if (strict_in & UNIFY_ALLOW_DERIVED)
18373 /* First, we try to unify the PARM and ARG directly. */
18374 t = try_class_unification (tparms, targs,
18375 parm, arg, explain_p);
18379 /* Fallback to the special case allowed in
18380 [temp.deduct.call]:
18382 If P is a class, and P has the form
18383 template-id, then A can be a derived class of
18384 the deduced A. Likewise, if P is a pointer to
18385 a class of the form template-id, A can be a
18386 pointer to a derived class pointed to by the
18388 enum template_base_result r;
18389 r = get_template_base (tparms, targs, parm, arg,
18393 return unify_no_common_base (explain_p, r, parm, arg);
18396 else if (CLASSTYPE_TEMPLATE_INFO (arg)
18397 && (CLASSTYPE_TI_TEMPLATE (parm)
18398 == CLASSTYPE_TI_TEMPLATE (arg)))
18399 /* Perhaps PARM is something like S<U> and ARG is S<int>.
18400 Then, we should unify `int' and `U'. */
18403 /* There's no chance of unification succeeding. */
18404 return unify_type_mismatch (explain_p, parm, arg);
18406 return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
18407 CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE, explain_p);
18409 else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
18410 return unify_type_mismatch (explain_p, parm, arg);
18411 return unify_success (explain_p);
18414 case FUNCTION_TYPE:
18416 unsigned int nargs;
18421 if (TREE_CODE (arg) != TREE_CODE (parm))
18422 return unify_type_mismatch (explain_p, parm, arg);
18424 /* CV qualifications for methods can never be deduced, they must
18425 match exactly. We need to check them explicitly here,
18426 because type_unification_real treats them as any other
18427 cv-qualified parameter. */
18428 if (TREE_CODE (parm) == METHOD_TYPE
18429 && (!check_cv_quals_for_unify
18431 class_of_this_parm (arg),
18432 class_of_this_parm (parm))))
18433 return unify_cv_qual_mismatch (explain_p, parm, arg);
18435 RECUR_AND_CHECK_FAILURE (tparms, targs, TREE_TYPE (parm),
18436 TREE_TYPE (arg), UNIFY_ALLOW_NONE, explain_p);
18438 nargs = list_length (TYPE_ARG_TYPES (arg));
18439 args = XALLOCAVEC (tree, nargs);
18440 for (a = TYPE_ARG_TYPES (arg), i = 0;
18441 a != NULL_TREE && a != void_list_node;
18442 a = TREE_CHAIN (a), ++i)
18443 args[i] = TREE_VALUE (a);
18446 return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
18447 args, nargs, 1, DEDUCE_EXACT,
18448 LOOKUP_NORMAL, NULL, explain_p);
18452 /* Unify a pointer to member with a pointer to member function, which
18453 deduces the type of the member as a function type. */
18454 if (TYPE_PTRMEMFUNC_P (arg))
18456 /* Check top-level cv qualifiers */
18457 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE, arg, parm))
18458 return unify_cv_qual_mismatch (explain_p, parm, arg);
18460 RECUR_AND_CHECK_FAILURE (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
18461 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg),
18462 UNIFY_ALLOW_NONE, explain_p);
18464 /* Determine the type of the function we are unifying against. */
18465 tree fntype = static_fn_type (arg);
18467 return unify (tparms, targs, TREE_TYPE (parm), fntype, strict, explain_p);
18470 if (TREE_CODE (arg) != OFFSET_TYPE)
18471 return unify_type_mismatch (explain_p, parm, arg);
18472 RECUR_AND_CHECK_FAILURE (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
18473 TYPE_OFFSET_BASETYPE (arg),
18474 UNIFY_ALLOW_NONE, explain_p);
18475 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
18476 strict, explain_p);
18479 if (DECL_TEMPLATE_PARM_P (parm))
18480 return unify (tparms, targs, DECL_INITIAL (parm), arg, strict, explain_p);
18481 if (arg != scalar_constant_value (parm))
18482 return unify_template_argument_mismatch (explain_p, parm, arg);
18483 return unify_success (explain_p);
18486 case TEMPLATE_DECL:
18487 /* Matched cases are handled by the ARG == PARM test above. */
18488 return unify_template_argument_mismatch (explain_p, parm, arg);
18491 /* A non-type template parameter that is a variable should be a
18492 an integral constant, in which case, it whould have been
18493 folded into its (constant) value. So we should not be getting
18494 a variable here. */
18495 gcc_unreachable ();
18497 case TYPE_ARGUMENT_PACK:
18498 case NONTYPE_ARGUMENT_PACK:
18499 return unify (tparms, targs, ARGUMENT_PACK_ARGS (parm),
18500 ARGUMENT_PACK_ARGS (arg), strict, explain_p);
18503 case DECLTYPE_TYPE:
18504 case UNDERLYING_TYPE:
18505 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
18506 or UNDERLYING_TYPE nodes. */
18507 return unify_success (explain_p);
18510 /* Unification fails if we hit an error node. */
18511 return unify_invalid (explain_p);
18514 if (REFERENCE_REF_P (parm))
18516 if (REFERENCE_REF_P (arg))
18517 arg = TREE_OPERAND (arg, 0);
18518 return unify (tparms, targs, TREE_OPERAND (parm, 0), arg,
18519 strict, explain_p);
18524 /* An unresolved overload is a nondeduced context. */
18525 if (is_overloaded_fn (parm) || type_unknown_p (parm))
18526 return unify_success (explain_p);
18527 gcc_assert (EXPR_P (parm));
18529 /* We must be looking at an expression. This can happen with
18533 void foo(S<I>, S<I + 2>);
18535 This is a "nondeduced context":
18539 The nondeduced contexts are:
18541 --A type that is a template-id in which one or more of
18542 the template-arguments is an expression that references
18543 a template-parameter.
18545 In these cases, we assume deduction succeeded, but don't
18546 actually infer any unifications. */
18548 if (!uses_template_parms (parm)
18549 && !template_args_equal (parm, arg))
18550 return unify_expression_unequal (explain_p, parm, arg);
18552 return unify_success (explain_p);
18555 #undef RECUR_AND_CHECK_FAILURE
18557 /* Note that DECL can be defined in this translation unit, if
18561 mark_definable (tree decl)
18564 DECL_NOT_REALLY_EXTERN (decl) = 1;
18565 FOR_EACH_CLONE (clone, decl)
18566 DECL_NOT_REALLY_EXTERN (clone) = 1;
18569 /* Called if RESULT is explicitly instantiated, or is a member of an
18570 explicitly instantiated class. */
18573 mark_decl_instantiated (tree result, int extern_p)
18575 SET_DECL_EXPLICIT_INSTANTIATION (result);
18577 /* If this entity has already been written out, it's too late to
18578 make any modifications. */
18579 if (TREE_ASM_WRITTEN (result))
18582 /* For anonymous namespace we don't need to do anything. */
18583 if (decl_anon_ns_mem_p (result))
18585 gcc_assert (!TREE_PUBLIC (result));
18589 if (TREE_CODE (result) != FUNCTION_DECL)
18590 /* The TREE_PUBLIC flag for function declarations will have been
18591 set correctly by tsubst. */
18592 TREE_PUBLIC (result) = 1;
18594 /* This might have been set by an earlier implicit instantiation. */
18595 DECL_COMDAT (result) = 0;
18598 DECL_NOT_REALLY_EXTERN (result) = 0;
18601 mark_definable (result);
18602 mark_needed (result);
18603 /* Always make artificials weak. */
18604 if (DECL_ARTIFICIAL (result) && flag_weak)
18605 comdat_linkage (result);
18606 /* For WIN32 we also want to put explicit instantiations in
18607 linkonce sections. */
18608 else if (TREE_PUBLIC (result))
18609 maybe_make_one_only (result);
18612 /* If EXTERN_P, then this function will not be emitted -- unless
18613 followed by an explicit instantiation, at which point its linkage
18614 will be adjusted. If !EXTERN_P, then this function will be
18615 emitted here. In neither circumstance do we want
18616 import_export_decl to adjust the linkage. */
18617 DECL_INTERFACE_KNOWN (result) = 1;
18620 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
18621 important template arguments. If any are missing, we check whether
18622 they're important by using error_mark_node for substituting into any
18623 args that were used for partial ordering (the ones between ARGS and END)
18624 and seeing if it bubbles up. */
18627 check_undeduced_parms (tree targs, tree args, tree end)
18629 bool found = false;
18631 for (i = TREE_VEC_LENGTH (targs) - 1; i >= 0; --i)
18632 if (TREE_VEC_ELT (targs, i) == NULL_TREE)
18635 TREE_VEC_ELT (targs, i) = error_mark_node;
18639 tree substed = tsubst_arg_types (args, targs, end, tf_none, NULL_TREE);
18640 if (substed == error_mark_node)
18646 /* Given two function templates PAT1 and PAT2, return:
18648 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
18649 -1 if PAT2 is more specialized than PAT1.
18650 0 if neither is more specialized.
18652 LEN indicates the number of parameters we should consider
18653 (defaulted parameters should not be considered).
18655 The 1998 std underspecified function template partial ordering, and
18656 DR214 addresses the issue. We take pairs of arguments, one from
18657 each of the templates, and deduce them against each other. One of
18658 the templates will be more specialized if all the *other*
18659 template's arguments deduce against its arguments and at least one
18660 of its arguments *does* *not* deduce against the other template's
18661 corresponding argument. Deduction is done as for class templates.
18662 The arguments used in deduction have reference and top level cv
18663 qualifiers removed. Iff both arguments were originally reference
18664 types *and* deduction succeeds in both directions, an lvalue reference
18665 wins against an rvalue reference and otherwise the template
18666 with the more cv-qualified argument wins for that pairing (if
18667 neither is more cv-qualified, they both are equal). Unlike regular
18668 deduction, after all the arguments have been deduced in this way,
18669 we do *not* verify the deduced template argument values can be
18670 substituted into non-deduced contexts.
18672 The logic can be a bit confusing here, because we look at deduce1 and
18673 targs1 to see if pat2 is at least as specialized, and vice versa; if we
18674 can find template arguments for pat1 to make arg1 look like arg2, that
18675 means that arg2 is at least as specialized as arg1. */
18678 more_specialized_fn (tree pat1, tree pat2, int len)
18680 tree decl1 = DECL_TEMPLATE_RESULT (pat1);
18681 tree decl2 = DECL_TEMPLATE_RESULT (pat2);
18682 tree targs1 = make_tree_vec (DECL_NTPARMS (pat1));
18683 tree targs2 = make_tree_vec (DECL_NTPARMS (pat2));
18684 tree tparms1 = DECL_INNERMOST_TEMPLATE_PARMS (pat1);
18685 tree tparms2 = DECL_INNERMOST_TEMPLATE_PARMS (pat2);
18686 tree args1 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
18687 tree args2 = TYPE_ARG_TYPES (TREE_TYPE (decl2));
18688 tree origs1, origs2;
18689 bool lose1 = false;
18690 bool lose2 = false;
18692 /* Remove the this parameter from non-static member functions. If
18693 one is a non-static member function and the other is not a static
18694 member function, remove the first parameter from that function
18695 also. This situation occurs for operator functions where we
18696 locate both a member function (with this pointer) and non-member
18697 operator (with explicit first operand). */
18698 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1))
18700 len--; /* LEN is the number of significant arguments for DECL1 */
18701 args1 = TREE_CHAIN (args1);
18702 if (!DECL_STATIC_FUNCTION_P (decl2))
18703 args2 = TREE_CHAIN (args2);
18705 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2))
18707 args2 = TREE_CHAIN (args2);
18708 if (!DECL_STATIC_FUNCTION_P (decl1))
18711 args1 = TREE_CHAIN (args1);
18715 /* If only one is a conversion operator, they are unordered. */
18716 if (DECL_CONV_FN_P (decl1) != DECL_CONV_FN_P (decl2))
18719 /* Consider the return type for a conversion function */
18720 if (DECL_CONV_FN_P (decl1))
18722 args1 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl1)), args1);
18723 args2 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl2)), args2);
18727 processing_template_decl++;
18733 /* Stop when an ellipsis is seen. */
18734 && args1 != NULL_TREE && args2 != NULL_TREE)
18736 tree arg1 = TREE_VALUE (args1);
18737 tree arg2 = TREE_VALUE (args2);
18738 int deduce1, deduce2;
18744 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
18745 && TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
18747 /* When both arguments are pack expansions, we need only
18748 unify the patterns themselves. */
18749 arg1 = PACK_EXPANSION_PATTERN (arg1);
18750 arg2 = PACK_EXPANSION_PATTERN (arg2);
18752 /* This is the last comparison we need to do. */
18756 if (TREE_CODE (arg1) == REFERENCE_TYPE)
18758 ref1 = TYPE_REF_IS_RVALUE (arg1) + 1;
18759 arg1 = TREE_TYPE (arg1);
18760 quals1 = cp_type_quals (arg1);
18763 if (TREE_CODE (arg2) == REFERENCE_TYPE)
18765 ref2 = TYPE_REF_IS_RVALUE (arg2) + 1;
18766 arg2 = TREE_TYPE (arg2);
18767 quals2 = cp_type_quals (arg2);
18770 arg1 = TYPE_MAIN_VARIANT (arg1);
18771 arg2 = TYPE_MAIN_VARIANT (arg2);
18773 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION)
18775 int i, len2 = list_length (args2);
18776 tree parmvec = make_tree_vec (1);
18777 tree argvec = make_tree_vec (len2);
18780 /* Setup the parameter vector, which contains only ARG1. */
18781 TREE_VEC_ELT (parmvec, 0) = arg1;
18783 /* Setup the argument vector, which contains the remaining
18785 for (i = 0; i < len2; i++, ta = TREE_CHAIN (ta))
18786 TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
18788 deduce1 = (unify_pack_expansion (tparms1, targs1, parmvec,
18789 argvec, DEDUCE_EXACT,
18790 /*subr=*/true, /*explain_p=*/false)
18793 /* We cannot deduce in the other direction, because ARG1 is
18794 a pack expansion but ARG2 is not. */
18797 else if (TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
18799 int i, len1 = list_length (args1);
18800 tree parmvec = make_tree_vec (1);
18801 tree argvec = make_tree_vec (len1);
18804 /* Setup the parameter vector, which contains only ARG1. */
18805 TREE_VEC_ELT (parmvec, 0) = arg2;
18807 /* Setup the argument vector, which contains the remaining
18809 for (i = 0; i < len1; i++, ta = TREE_CHAIN (ta))
18810 TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
18812 deduce2 = (unify_pack_expansion (tparms2, targs2, parmvec,
18813 argvec, DEDUCE_EXACT,
18814 /*subr=*/true, /*explain_p=*/false)
18817 /* We cannot deduce in the other direction, because ARG2 is
18818 a pack expansion but ARG1 is not.*/
18824 /* The normal case, where neither argument is a pack
18826 deduce1 = (unify (tparms1, targs1, arg1, arg2,
18827 UNIFY_ALLOW_NONE, /*explain_p=*/false)
18829 deduce2 = (unify (tparms2, targs2, arg2, arg1,
18830 UNIFY_ALLOW_NONE, /*explain_p=*/false)
18834 /* If we couldn't deduce arguments for tparms1 to make arg1 match
18835 arg2, then arg2 is not as specialized as arg1. */
18841 /* "If, for a given type, deduction succeeds in both directions
18842 (i.e., the types are identical after the transformations above)
18843 and both P and A were reference types (before being replaced with
18844 the type referred to above):
18845 - if the type from the argument template was an lvalue reference and
18846 the type from the parameter template was not, the argument type is
18847 considered to be more specialized than the other; otherwise,
18848 - if the type from the argument template is more cv-qualified
18849 than the type from the parameter template (as described above),
18850 the argument type is considered to be more specialized than the other;
18852 - neither type is more specialized than the other." */
18854 if (deduce1 && deduce2)
18856 if (ref1 && ref2 && ref1 != ref2)
18863 else if (quals1 != quals2 && quals1 >= 0 && quals2 >= 0)
18865 if ((quals1 & quals2) == quals2)
18867 if ((quals1 & quals2) == quals1)
18872 if (lose1 && lose2)
18873 /* We've failed to deduce something in either direction.
18874 These must be unordered. */
18877 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
18878 || TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
18879 /* We have already processed all of the arguments in our
18880 handing of the pack expansion type. */
18883 args1 = TREE_CHAIN (args1);
18884 args2 = TREE_CHAIN (args2);
18887 /* "In most cases, all template parameters must have values in order for
18888 deduction to succeed, but for partial ordering purposes a template
18889 parameter may remain without a value provided it is not used in the
18890 types being used for partial ordering."
18892 Thus, if we are missing any of the targs1 we need to substitute into
18893 origs1, then pat2 is not as specialized as pat1. This can happen when
18894 there is a nondeduced context. */
18895 if (!lose2 && check_undeduced_parms (targs1, origs1, args1))
18897 if (!lose1 && check_undeduced_parms (targs2, origs2, args2))
18900 processing_template_decl--;
18902 /* All things being equal, if the next argument is a pack expansion
18903 for one function but not for the other, prefer the
18904 non-variadic function. FIXME this is bogus; see c++/41958. */
18906 && args1 && TREE_VALUE (args1)
18907 && args2 && TREE_VALUE (args2))
18909 lose1 = TREE_CODE (TREE_VALUE (args1)) == TYPE_PACK_EXPANSION;
18910 lose2 = TREE_CODE (TREE_VALUE (args2)) == TYPE_PACK_EXPANSION;
18913 if (lose1 == lose2)
18921 /* Determine which of two partial specializations of TMPL is more
18924 PAT1 is a TREE_LIST whose TREE_VALUE is the TEMPLATE_DECL corresponding
18925 to the first partial specialization. The TREE_PURPOSE is the
18926 innermost set of template parameters for the partial
18927 specialization. PAT2 is similar, but for the second template.
18929 Return 1 if the first partial specialization is more specialized;
18930 -1 if the second is more specialized; 0 if neither is more
18933 See [temp.class.order] for information about determining which of
18934 two templates is more specialized. */
18937 more_specialized_partial_spec (tree tmpl, tree pat1, tree pat2)
18941 bool any_deductions = false;
18943 tree tmpl1 = TREE_VALUE (pat1);
18944 tree tmpl2 = TREE_VALUE (pat2);
18945 tree parms1 = DECL_INNERMOST_TEMPLATE_PARMS (tmpl1);
18946 tree parms2 = DECL_INNERMOST_TEMPLATE_PARMS (tmpl2);
18947 tree specargs1 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl1)));
18948 tree specargs2 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl2)));
18950 /* Just like what happens for functions, if we are ordering between
18951 different template specializations, we may encounter dependent
18952 types in the arguments, and we need our dependency check functions
18953 to behave correctly. */
18954 ++processing_template_decl;
18955 targs = get_partial_spec_bindings (tmpl, parms1, specargs1, specargs2);
18959 any_deductions = true;
18962 targs = get_partial_spec_bindings (tmpl, parms2, specargs2, specargs1);
18966 any_deductions = true;
18968 --processing_template_decl;
18970 /* In the case of a tie where at least one of the templates
18971 has a parameter pack at the end, the template with the most
18972 non-packed parameters wins. */
18975 && (template_args_variadic_p (TREE_PURPOSE (pat1))
18976 || template_args_variadic_p (TREE_PURPOSE (pat2))))
18978 tree args1 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1));
18979 tree args2 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2));
18980 int len1 = TREE_VEC_LENGTH (args1);
18981 int len2 = TREE_VEC_LENGTH (args2);
18983 /* We don't count the pack expansion at the end. */
18984 if (template_args_variadic_p (TREE_PURPOSE (pat1)))
18986 if (template_args_variadic_p (TREE_PURPOSE (pat2)))
18991 else if (len1 < len2)
18998 /* Return the template arguments that will produce the function signature
18999 DECL from the function template FN, with the explicit template
19000 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
19001 also match. Return NULL_TREE if no satisfactory arguments could be
19005 get_bindings (tree fn, tree decl, tree explicit_args, bool check_rettype)
19007 int ntparms = DECL_NTPARMS (fn);
19008 tree targs = make_tree_vec (ntparms);
19009 tree decl_type = TREE_TYPE (decl);
19010 tree decl_arg_types;
19012 unsigned int nargs, ix;
19015 gcc_assert (decl != DECL_TEMPLATE_RESULT (fn));
19017 /* Never do unification on the 'this' parameter. */
19018 decl_arg_types = skip_artificial_parms_for (decl,
19019 TYPE_ARG_TYPES (decl_type));
19021 nargs = list_length (decl_arg_types);
19022 args = XALLOCAVEC (tree, nargs);
19023 for (arg = decl_arg_types, ix = 0;
19024 arg != NULL_TREE && arg != void_list_node;
19025 arg = TREE_CHAIN (arg), ++ix)
19026 args[ix] = TREE_VALUE (arg);
19028 if (fn_type_unification (fn, explicit_args, targs,
19030 (check_rettype || DECL_CONV_FN_P (fn)
19031 ? TREE_TYPE (decl_type) : NULL_TREE),
19032 DEDUCE_EXACT, LOOKUP_NORMAL, /*explain_p=*/false,
19034 == error_mark_node)
19040 /* Return the innermost template arguments that, when applied to a partial
19041 specialization of TMPL whose innermost template parameters are
19042 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
19045 For example, suppose we have:
19047 template <class T, class U> struct S {};
19048 template <class T> struct S<T*, int> {};
19050 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
19051 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
19052 int}. The resulting vector will be {double}, indicating that `T'
19053 is bound to `double'. */
19056 get_partial_spec_bindings (tree tmpl, tree tparms, tree spec_args, tree args)
19058 int i, ntparms = TREE_VEC_LENGTH (tparms);
19060 tree innermost_deduced_args;
19062 innermost_deduced_args = make_tree_vec (ntparms);
19063 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
19065 deduced_args = copy_node (args);
19066 SET_TMPL_ARGS_LEVEL (deduced_args,
19067 TMPL_ARGS_DEPTH (deduced_args),
19068 innermost_deduced_args);
19071 deduced_args = innermost_deduced_args;
19073 if (unify (tparms, deduced_args,
19074 INNERMOST_TEMPLATE_ARGS (spec_args),
19075 INNERMOST_TEMPLATE_ARGS (args),
19076 UNIFY_ALLOW_NONE, /*explain_p=*/false))
19079 for (i = 0; i < ntparms; ++i)
19080 if (! TREE_VEC_ELT (innermost_deduced_args, i))
19083 /* Verify that nondeduced template arguments agree with the type
19084 obtained from argument deduction.
19088 struct A { typedef int X; };
19089 template <class T, class U> struct C {};
19090 template <class T> struct C<T, typename T::X> {};
19092 Then with the instantiation `C<A, int>', we can deduce that
19093 `T' is `A' but unify () does not check whether `typename T::X'
19095 spec_args = tsubst (spec_args, deduced_args, tf_none, NULL_TREE);
19096 spec_args = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
19098 tf_none, false, false);
19099 if (spec_args == error_mark_node
19100 /* We only need to check the innermost arguments; the other
19101 arguments will always agree. */
19102 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args),
19103 INNERMOST_TEMPLATE_ARGS (args)))
19106 /* Now that we have bindings for all of the template arguments,
19107 ensure that the arguments deduced for the template template
19108 parameters have compatible template parameter lists. See the use
19109 of template_template_parm_bindings_ok_p in fn_type_unification
19110 for more information. */
19111 if (!template_template_parm_bindings_ok_p (tparms, deduced_args))
19114 return deduced_args;
19117 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
19118 Return the TREE_LIST node with the most specialized template, if
19119 any. If there is no most specialized template, the error_mark_node
19122 Note that this function does not look at, or modify, the
19123 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
19124 returned is one of the elements of INSTANTIATIONS, callers may
19125 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
19126 and retrieve it from the value returned. */
19129 most_specialized_instantiation (tree templates)
19133 ++processing_template_decl;
19136 for (fn = TREE_CHAIN (templates); fn; fn = TREE_CHAIN (fn))
19140 if (get_bindings (TREE_VALUE (champ),
19141 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
19142 NULL_TREE, /*check_ret=*/true))
19145 if (get_bindings (TREE_VALUE (fn),
19146 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
19147 NULL_TREE, /*check_ret=*/true))
19154 /* Equally specialized, move to next function. If there
19155 is no next function, nothing's most specialized. */
19156 fn = TREE_CHAIN (fn);
19164 /* Now verify that champ is better than everything earlier in the
19165 instantiation list. */
19166 for (fn = templates; fn != champ; fn = TREE_CHAIN (fn))
19167 if (get_bindings (TREE_VALUE (champ),
19168 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
19169 NULL_TREE, /*check_ret=*/true)
19170 || !get_bindings (TREE_VALUE (fn),
19171 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
19172 NULL_TREE, /*check_ret=*/true))
19178 processing_template_decl--;
19181 return error_mark_node;
19186 /* If DECL is a specialization of some template, return the most
19187 general such template. Otherwise, returns NULL_TREE.
19189 For example, given:
19191 template <class T> struct S { template <class U> void f(U); };
19193 if TMPL is `template <class U> void S<int>::f(U)' this will return
19194 the full template. This function will not trace past partial
19195 specializations, however. For example, given in addition:
19197 template <class T> struct S<T*> { template <class U> void f(U); };
19199 if TMPL is `template <class U> void S<int*>::f(U)' this will return
19200 `template <class T> template <class U> S<T*>::f(U)'. */
19203 most_general_template (tree decl)
19205 if (TREE_CODE (decl) != TEMPLATE_DECL)
19207 if (tree tinfo = get_template_info (decl))
19208 decl = TI_TEMPLATE (tinfo);
19209 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
19210 template friend, or a FIELD_DECL for a capture pack. */
19211 if (TREE_CODE (decl) != TEMPLATE_DECL)
19215 /* Look for more and more general templates. */
19216 while (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
19218 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
19219 (See cp-tree.h for details.) */
19220 if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
19223 if (CLASS_TYPE_P (TREE_TYPE (decl))
19224 && !TYPE_DECL_ALIAS_P (TYPE_NAME (TREE_TYPE (decl)))
19225 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
19228 /* Stop if we run into an explicitly specialized class template. */
19229 if (!DECL_NAMESPACE_SCOPE_P (decl)
19230 && DECL_CONTEXT (decl)
19231 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl)))
19234 decl = DECL_TI_TEMPLATE (decl);
19240 /* Return the most specialized of the template partial specializations
19241 which can produce TARGET, a specialization of some class or variable
19242 template. The value returned is actually a TREE_LIST; the TREE_VALUE is
19243 a TEMPLATE_DECL node corresponding to the partial specialization, while
19244 the TREE_PURPOSE is the set of template arguments that must be
19245 substituted into the template pattern in order to generate TARGET.
19247 If the choice of partial specialization is ambiguous, a diagnostic
19248 is issued, and the error_mark_node is returned. If there are no
19249 partial specializations matching TARGET, then NULL_TREE is
19250 returned, indicating that the primary template should be used. */
19253 most_specialized_partial_spec (tree target, tsubst_flags_t complain)
19255 tree list = NULL_TREE;
19260 tree outer_args = NULL_TREE;
19263 if (TYPE_P (target))
19265 tree tinfo = CLASSTYPE_TEMPLATE_INFO (target);
19266 tmpl = TI_TEMPLATE (tinfo);
19267 args = TI_ARGS (tinfo);
19269 else if (TREE_CODE (target) == TEMPLATE_ID_EXPR)
19271 tmpl = TREE_OPERAND (target, 0);
19272 args = TREE_OPERAND (target, 1);
19274 else if (VAR_P (target))
19276 tree tinfo = DECL_TEMPLATE_INFO (target);
19277 tmpl = TI_TEMPLATE (tinfo);
19278 args = TI_ARGS (tinfo);
19281 gcc_unreachable ();
19283 tree main_tmpl = most_general_template (tmpl);
19285 /* For determining which partial specialization to use, only the
19286 innermost args are interesting. */
19287 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
19289 outer_args = strip_innermost_template_args (args, 1);
19290 args = INNERMOST_TEMPLATE_ARGS (args);
19293 for (t = DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl); t; t = TREE_CHAIN (t))
19295 tree partial_spec_args;
19297 tree spec_tmpl = TREE_VALUE (t);
19299 partial_spec_args = TREE_PURPOSE (t);
19301 ++processing_template_decl;
19305 /* Discard the outer levels of args, and then substitute in the
19306 template args from the enclosing class. */
19307 partial_spec_args = INNERMOST_TEMPLATE_ARGS (partial_spec_args);
19308 partial_spec_args = tsubst_template_args
19309 (partial_spec_args, outer_args, tf_none, NULL_TREE);
19311 /* And the same for the partial specialization TEMPLATE_DECL. */
19312 spec_tmpl = tsubst (spec_tmpl, outer_args, tf_none, NULL_TREE);
19315 partial_spec_args =
19316 coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
19319 /*require_all_args=*/true,
19320 /*use_default_args=*/true);
19322 --processing_template_decl;
19324 if (partial_spec_args == error_mark_node)
19325 return error_mark_node;
19326 if (spec_tmpl == error_mark_node)
19327 return error_mark_node;
19329 tree parms = DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl);
19330 spec_args = get_partial_spec_bindings (tmpl, parms,
19336 spec_args = add_to_template_args (outer_args, spec_args);
19337 list = tree_cons (spec_args, TREE_VALUE (t), list);
19338 TREE_TYPE (list) = TREE_TYPE (t);
19345 ambiguous_p = false;
19348 t = TREE_CHAIN (t);
19349 for (; t; t = TREE_CHAIN (t))
19351 fate = more_specialized_partial_spec (tmpl, champ, t);
19358 t = TREE_CHAIN (t);
19361 ambiguous_p = true;
19370 for (t = list; t && t != champ; t = TREE_CHAIN (t))
19372 fate = more_specialized_partial_spec (tmpl, champ, t);
19375 ambiguous_p = true;
19383 char *spaces = NULL;
19384 if (!(complain & tf_error))
19385 return error_mark_node;
19386 if (TYPE_P (target))
19387 error ("ambiguous template instantiation for %q#T", target);
19389 error ("ambiguous template instantiation for %q#D", target);
19390 str = ngettext ("candidate is:", "candidates are:", list_length (list));
19391 for (t = list; t; t = TREE_CHAIN (t))
19393 tree subst = build_tree_list (TREE_VALUE (t), TREE_PURPOSE (t));
19394 inform (DECL_SOURCE_LOCATION (TREE_VALUE (t)),
19395 "%s %#S", spaces ? spaces : str, subst);
19396 spaces = spaces ? spaces : get_spaces (str);
19399 return error_mark_node;
19405 /* Explicitly instantiate DECL. */
19408 do_decl_instantiation (tree decl, tree storage)
19410 tree result = NULL_TREE;
19413 if (!decl || decl == error_mark_node)
19414 /* An error occurred, for which grokdeclarator has already issued
19415 an appropriate message. */
19417 else if (! DECL_LANG_SPECIFIC (decl))
19419 error ("explicit instantiation of non-template %q#D", decl);
19423 bool var_templ = (DECL_TEMPLATE_INFO (decl)
19424 && variable_template_p (DECL_TI_TEMPLATE (decl)));
19426 if (VAR_P (decl) && !var_templ)
19428 /* There is an asymmetry here in the way VAR_DECLs and
19429 FUNCTION_DECLs are handled by grokdeclarator. In the case of
19430 the latter, the DECL we get back will be marked as a
19431 template instantiation, and the appropriate
19432 DECL_TEMPLATE_INFO will be set up. This does not happen for
19433 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
19434 should handle VAR_DECLs as it currently handles
19436 if (!DECL_CLASS_SCOPE_P (decl))
19438 error ("%qD is not a static data member of a class template", decl);
19441 result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false);
19442 if (!result || !VAR_P (result))
19444 error ("no matching template for %qD found", decl);
19447 if (!same_type_p (TREE_TYPE (result), TREE_TYPE (decl)))
19449 error ("type %qT for explicit instantiation %qD does not match "
19450 "declared type %qT", TREE_TYPE (result), decl,
19455 else if (TREE_CODE (decl) != FUNCTION_DECL && !var_templ)
19457 error ("explicit instantiation of %q#D", decl);
19463 /* Check for various error cases. Note that if the explicit
19464 instantiation is valid the RESULT will currently be marked as an
19465 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
19466 until we get here. */
19468 if (DECL_TEMPLATE_SPECIALIZATION (result))
19470 /* DR 259 [temp.spec].
19472 Both an explicit instantiation and a declaration of an explicit
19473 specialization shall not appear in a program unless the explicit
19474 instantiation follows a declaration of the explicit specialization.
19476 For a given set of template parameters, if an explicit
19477 instantiation of a template appears after a declaration of an
19478 explicit specialization for that template, the explicit
19479 instantiation has no effect. */
19482 else if (DECL_EXPLICIT_INSTANTIATION (result))
19486 No program shall explicitly instantiate any template more
19489 We check DECL_NOT_REALLY_EXTERN so as not to complain when
19490 the first instantiation was `extern' and the second is not,
19491 and EXTERN_P for the opposite case. */
19492 if (DECL_NOT_REALLY_EXTERN (result) && !extern_p)
19493 permerror (input_location, "duplicate explicit instantiation of %q#D", result);
19494 /* If an "extern" explicit instantiation follows an ordinary
19495 explicit instantiation, the template is instantiated. */
19499 else if (!DECL_IMPLICIT_INSTANTIATION (result))
19501 error ("no matching template for %qD found", result);
19504 else if (!DECL_TEMPLATE_INFO (result))
19506 permerror (input_location, "explicit instantiation of non-template %q#D", result);
19510 if (storage == NULL_TREE)
19512 else if (storage == ridpointers[(int) RID_EXTERN])
19514 if (!in_system_header_at (input_location) && (cxx_dialect == cxx98))
19515 pedwarn (input_location, OPT_Wpedantic,
19516 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
19521 error ("storage class %qD applied to template instantiation", storage);
19523 check_explicit_instantiation_namespace (result);
19524 mark_decl_instantiated (result, extern_p);
19526 instantiate_decl (result, /*defer_ok=*/1,
19527 /*expl_inst_class_mem_p=*/false);
19531 mark_class_instantiated (tree t, int extern_p)
19533 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
19534 SET_CLASSTYPE_INTERFACE_KNOWN (t);
19535 CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
19536 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
19539 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
19540 rest_of_type_compilation (t, 1);
19544 /* Called from do_type_instantiation through binding_table_foreach to
19545 do recursive instantiation for the type bound in ENTRY. */
19547 bt_instantiate_type_proc (binding_entry entry, void *data)
19549 tree storage = *(tree *) data;
19551 if (MAYBE_CLASS_TYPE_P (entry->type)
19552 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type)))
19553 do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0);
19556 /* Called from do_type_instantiation to instantiate a member
19557 (a member function or a static member variable) of an
19558 explicitly instantiated class template. */
19560 instantiate_class_member (tree decl, int extern_p)
19562 mark_decl_instantiated (decl, extern_p);
19564 instantiate_decl (decl, /*defer_ok=*/1,
19565 /*expl_inst_class_mem_p=*/true);
19568 /* Perform an explicit instantiation of template class T. STORAGE, if
19569 non-null, is the RID for extern, inline or static. COMPLAIN is
19570 nonzero if this is called from the parser, zero if called recursively,
19571 since the standard is unclear (as detailed below). */
19574 do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
19579 int previous_instantiation_extern_p = 0;
19581 if (TREE_CODE (t) == TYPE_DECL)
19584 if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t))
19587 (TYPE_TEMPLATE_INFO (t)) ? TYPE_TI_TEMPLATE (t) : NULL;
19589 error ("explicit instantiation of non-class template %qD", tmpl);
19591 error ("explicit instantiation of non-template type %qT", t);
19597 if (!COMPLETE_TYPE_P (t))
19599 if (complain & tf_error)
19600 error ("explicit instantiation of %q#T before definition of template",
19605 if (storage != NULL_TREE)
19607 if (!in_system_header_at (input_location))
19609 if (storage == ridpointers[(int) RID_EXTERN])
19611 if (cxx_dialect == cxx98)
19612 pedwarn (input_location, OPT_Wpedantic,
19613 "ISO C++ 1998 forbids the use of %<extern%> on "
19614 "explicit instantiations");
19617 pedwarn (input_location, OPT_Wpedantic,
19618 "ISO C++ forbids the use of %qE"
19619 " on explicit instantiations", storage);
19622 if (storage == ridpointers[(int) RID_INLINE])
19624 else if (storage == ridpointers[(int) RID_EXTERN])
19626 else if (storage == ridpointers[(int) RID_STATIC])
19630 error ("storage class %qD applied to template instantiation",
19636 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
19638 /* DR 259 [temp.spec].
19640 Both an explicit instantiation and a declaration of an explicit
19641 specialization shall not appear in a program unless the explicit
19642 instantiation follows a declaration of the explicit specialization.
19644 For a given set of template parameters, if an explicit
19645 instantiation of a template appears after a declaration of an
19646 explicit specialization for that template, the explicit
19647 instantiation has no effect. */
19650 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t))
19654 No program shall explicitly instantiate any template more
19657 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
19658 instantiation was `extern'. If EXTERN_P then the second is.
19659 These cases are OK. */
19660 previous_instantiation_extern_p = CLASSTYPE_INTERFACE_ONLY (t);
19662 if (!previous_instantiation_extern_p && !extern_p
19663 && (complain & tf_error))
19664 permerror (input_location, "duplicate explicit instantiation of %q#T", t);
19666 /* If we've already instantiated the template, just return now. */
19667 if (!CLASSTYPE_INTERFACE_ONLY (t))
19671 check_explicit_instantiation_namespace (TYPE_NAME (t));
19672 mark_class_instantiated (t, extern_p);
19680 /* In contrast to implicit instantiation, where only the
19681 declarations, and not the definitions, of members are
19682 instantiated, we have here:
19686 The explicit instantiation of a class template specialization
19687 implies the instantiation of all of its members not
19688 previously explicitly specialized in the translation unit
19689 containing the explicit instantiation.
19691 Of course, we can't instantiate member template classes, since
19692 we don't have any arguments for them. Note that the standard
19693 is unclear on whether the instantiation of the members are
19694 *explicit* instantiations or not. However, the most natural
19695 interpretation is that it should be an explicit instantiation. */
19698 for (tmp = TYPE_METHODS (t); tmp; tmp = DECL_CHAIN (tmp))
19699 if (TREE_CODE (tmp) == FUNCTION_DECL
19700 && DECL_TEMPLATE_INSTANTIATION (tmp))
19701 instantiate_class_member (tmp, extern_p);
19703 for (tmp = TYPE_FIELDS (t); tmp; tmp = DECL_CHAIN (tmp))
19704 if (VAR_P (tmp) && DECL_TEMPLATE_INSTANTIATION (tmp))
19705 instantiate_class_member (tmp, extern_p);
19707 if (CLASSTYPE_NESTED_UTDS (t))
19708 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t),
19709 bt_instantiate_type_proc, &storage);
19713 /* Given a function DECL, which is a specialization of TMPL, modify
19714 DECL to be a re-instantiation of TMPL with the same template
19715 arguments. TMPL should be the template into which tsubst'ing
19716 should occur for DECL, not the most general template.
19718 One reason for doing this is a scenario like this:
19721 void f(const T&, int i);
19723 void g() { f(3, 7); }
19726 void f(const T& t, const int i) { }
19728 Note that when the template is first instantiated, with
19729 instantiate_template, the resulting DECL will have no name for the
19730 first parameter, and the wrong type for the second. So, when we go
19731 to instantiate the DECL, we regenerate it. */
19734 regenerate_decl_from_template (tree decl, tree tmpl)
19736 /* The arguments used to instantiate DECL, from the most general
19741 args = DECL_TI_ARGS (decl);
19742 code_pattern = DECL_TEMPLATE_RESULT (tmpl);
19744 /* Make sure that we can see identifiers, and compute access
19746 push_access_scope (decl);
19748 if (TREE_CODE (decl) == FUNCTION_DECL)
19756 args_depth = TMPL_ARGS_DEPTH (args);
19757 parms_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
19758 if (args_depth > parms_depth)
19759 args = get_innermost_template_args (args, parms_depth);
19761 specs = tsubst_exception_specification (TREE_TYPE (code_pattern),
19762 args, tf_error, NULL_TREE,
19763 /*defer_ok*/false);
19764 if (specs && specs != error_mark_node)
19765 TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl),
19768 /* Merge parameter declarations. */
19769 decl_parm = skip_artificial_parms_for (decl,
19770 DECL_ARGUMENTS (decl));
19772 = skip_artificial_parms_for (code_pattern,
19773 DECL_ARGUMENTS (code_pattern));
19774 while (decl_parm && !DECL_PACK_P (pattern_parm))
19779 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
19780 DECL_NAME (decl_parm) = DECL_NAME (pattern_parm);
19781 parm_type = tsubst (TREE_TYPE (pattern_parm), args, tf_error,
19783 parm_type = type_decays_to (parm_type);
19784 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
19785 TREE_TYPE (decl_parm) = parm_type;
19786 attributes = DECL_ATTRIBUTES (pattern_parm);
19787 if (DECL_ATTRIBUTES (decl_parm) != attributes)
19789 DECL_ATTRIBUTES (decl_parm) = attributes;
19790 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
19792 decl_parm = DECL_CHAIN (decl_parm);
19793 pattern_parm = DECL_CHAIN (pattern_parm);
19795 /* Merge any parameters that match with the function parameter
19797 if (pattern_parm && DECL_PACK_P (pattern_parm))
19800 tree expanded_types;
19801 /* Expand the TYPE_PACK_EXPANSION that provides the types for
19802 the parameters in this function parameter pack. */
19803 expanded_types = tsubst_pack_expansion (TREE_TYPE (pattern_parm),
19804 args, tf_error, NULL_TREE);
19805 len = TREE_VEC_LENGTH (expanded_types);
19806 for (i = 0; i < len; i++)
19811 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
19812 /* Rename the parameter to include the index. */
19813 DECL_NAME (decl_parm) =
19814 make_ith_pack_parameter_name (DECL_NAME (pattern_parm), i);
19815 parm_type = TREE_VEC_ELT (expanded_types, i);
19816 parm_type = type_decays_to (parm_type);
19817 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
19818 TREE_TYPE (decl_parm) = parm_type;
19819 attributes = DECL_ATTRIBUTES (pattern_parm);
19820 if (DECL_ATTRIBUTES (decl_parm) != attributes)
19822 DECL_ATTRIBUTES (decl_parm) = attributes;
19823 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
19825 decl_parm = DECL_CHAIN (decl_parm);
19828 /* Merge additional specifiers from the CODE_PATTERN. */
19829 if (DECL_DECLARED_INLINE_P (code_pattern)
19830 && !DECL_DECLARED_INLINE_P (decl))
19831 DECL_DECLARED_INLINE_P (decl) = 1;
19833 else if (VAR_P (decl))
19835 DECL_INITIAL (decl) =
19836 tsubst_expr (DECL_INITIAL (code_pattern), args,
19837 tf_error, DECL_TI_TEMPLATE (decl),
19838 /*integral_constant_expression_p=*/false);
19839 if (VAR_HAD_UNKNOWN_BOUND (decl))
19840 TREE_TYPE (decl) = tsubst (TREE_TYPE (code_pattern), args,
19841 tf_error, DECL_TI_TEMPLATE (decl));
19844 gcc_unreachable ();
19846 pop_access_scope (decl);
19849 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
19850 substituted to get DECL. */
19853 template_for_substitution (tree decl)
19855 tree tmpl = DECL_TI_TEMPLATE (decl);
19857 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
19858 for the instantiation. This is not always the most general
19859 template. Consider, for example:
19862 struct S { template <class U> void f();
19863 template <> void f<int>(); };
19865 and an instantiation of S<double>::f<int>. We want TD to be the
19866 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
19867 while (/* An instantiation cannot have a definition, so we need a
19868 more general template. */
19869 DECL_TEMPLATE_INSTANTIATION (tmpl)
19870 /* We must also deal with friend templates. Given:
19872 template <class T> struct S {
19873 template <class U> friend void f() {};
19876 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
19877 so far as the language is concerned, but that's still
19878 where we get the pattern for the instantiation from. On
19879 other hand, if the definition comes outside the class, say:
19881 template <class T> struct S {
19882 template <class U> friend void f();
19884 template <class U> friend void f() {}
19886 we don't need to look any further. That's what the check for
19887 DECL_INITIAL is for. */
19888 || (TREE_CODE (decl) == FUNCTION_DECL
19889 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl)
19890 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl))))
19892 /* The present template, TD, should not be a definition. If it
19893 were a definition, we should be using it! Note that we
19894 cannot restructure the loop to just keep going until we find
19895 a template with a definition, since that might go too far if
19896 a specialization was declared, but not defined. */
19898 /* Fetch the more general template. */
19899 tmpl = DECL_TI_TEMPLATE (tmpl);
19905 /* Returns true if we need to instantiate this template instance even if we
19906 know we aren't going to emit it.. */
19909 always_instantiate_p (tree decl)
19911 /* We always instantiate inline functions so that we can inline them. An
19912 explicit instantiation declaration prohibits implicit instantiation of
19913 non-inline functions. With high levels of optimization, we would
19914 normally inline non-inline functions -- but we're not allowed to do
19915 that for "extern template" functions. Therefore, we check
19916 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
19917 return ((TREE_CODE (decl) == FUNCTION_DECL
19918 && (DECL_DECLARED_INLINE_P (decl)
19919 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl)))))
19920 /* And we need to instantiate static data members so that
19921 their initializers are available in integral constant
19924 && decl_maybe_constant_var_p (decl)));
19927 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
19928 instantiate it now, modifying TREE_TYPE (fn). */
19931 maybe_instantiate_noexcept (tree fn)
19933 tree fntype, spec, noex, clone;
19935 /* Don't instantiate a noexcept-specification from template context. */
19936 if (processing_template_decl)
19939 if (DECL_CLONED_FUNCTION_P (fn))
19940 fn = DECL_CLONED_FUNCTION (fn);
19941 fntype = TREE_TYPE (fn);
19942 spec = TYPE_RAISES_EXCEPTIONS (fntype);
19944 if (!spec || !TREE_PURPOSE (spec))
19947 noex = TREE_PURPOSE (spec);
19949 if (TREE_CODE (noex) == DEFERRED_NOEXCEPT)
19951 if (DEFERRED_NOEXCEPT_PATTERN (noex) == NULL_TREE)
19952 spec = get_defaulted_eh_spec (fn);
19953 else if (push_tinst_level (fn))
19955 push_access_scope (fn);
19956 push_deferring_access_checks (dk_no_deferred);
19957 input_location = DECL_SOURCE_LOCATION (fn);
19958 noex = tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex),
19959 DEFERRED_NOEXCEPT_ARGS (noex),
19960 tf_warning_or_error, fn,
19961 /*function_p=*/false,
19962 /*integral_constant_expression_p=*/true);
19963 pop_deferring_access_checks ();
19964 pop_access_scope (fn);
19965 pop_tinst_level ();
19966 spec = build_noexcept_spec (noex, tf_warning_or_error);
19967 if (spec == error_mark_node)
19968 spec = noexcept_false_spec;
19971 spec = noexcept_false_spec;
19973 TREE_TYPE (fn) = build_exception_variant (fntype, spec);
19976 FOR_EACH_CLONE (clone, fn)
19978 if (TREE_TYPE (clone) == fntype)
19979 TREE_TYPE (clone) = TREE_TYPE (fn);
19981 TREE_TYPE (clone) = build_exception_variant (TREE_TYPE (clone), spec);
19985 /* Produce the definition of D, a _DECL generated from a template. If
19986 DEFER_OK is nonzero, then we don't have to actually do the
19987 instantiation now; we just have to do it sometime. Normally it is
19988 an error if this is an explicit instantiation but D is undefined.
19989 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
19990 explicitly instantiated class template. */
19993 instantiate_decl (tree d, int defer_ok,
19994 bool expl_inst_class_mem_p)
19996 tree tmpl = DECL_TI_TEMPLATE (d);
20003 bool pattern_defined;
20004 location_t saved_loc = input_location;
20005 int saved_unevaluated_operand = cp_unevaluated_operand;
20006 int saved_inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
20012 /* This function should only be used to instantiate templates for
20013 functions and static member variables. */
20014 gcc_assert (VAR_OR_FUNCTION_DECL_P (d));
20016 /* Variables are never deferred; if instantiation is required, they
20017 are instantiated right away. That allows for better code in the
20018 case that an expression refers to the value of the variable --
20019 if the variable has a constant value the referring expression can
20020 take advantage of that fact. */
20022 || DECL_DECLARED_CONSTEXPR_P (d))
20025 /* Don't instantiate cloned functions. Instead, instantiate the
20026 functions they cloned. */
20027 if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d))
20028 d = DECL_CLONED_FUNCTION (d);
20030 if (DECL_TEMPLATE_INSTANTIATED (d)
20031 || (TREE_CODE (d) == FUNCTION_DECL
20032 && DECL_DEFAULTED_FN (d) && DECL_INITIAL (d))
20033 || DECL_TEMPLATE_SPECIALIZATION (d))
20034 /* D has already been instantiated or explicitly specialized, so
20035 there's nothing for us to do here.
20037 It might seem reasonable to check whether or not D is an explicit
20038 instantiation, and, if so, stop here. But when an explicit
20039 instantiation is deferred until the end of the compilation,
20040 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
20041 the instantiation. */
20044 /* Check to see whether we know that this template will be
20045 instantiated in some other file, as with "extern template"
20047 external_p = (DECL_INTERFACE_KNOWN (d) && DECL_REALLY_EXTERN (d));
20049 /* In general, we do not instantiate such templates. */
20050 if (external_p && !always_instantiate_p (d))
20053 gen_tmpl = most_general_template (tmpl);
20054 gen_args = DECL_TI_ARGS (d);
20056 if (tmpl != gen_tmpl)
20057 /* We should already have the extra args. */
20058 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl))
20059 == TMPL_ARGS_DEPTH (gen_args));
20060 /* And what's in the hash table should match D. */
20061 gcc_assert ((spec = retrieve_specialization (gen_tmpl, gen_args, 0)) == d
20062 || spec == NULL_TREE);
20064 /* This needs to happen before any tsubsting. */
20065 if (! push_tinst_level (d))
20068 timevar_push (TV_TEMPLATE_INST);
20070 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
20071 for the instantiation. */
20072 td = template_for_substitution (d);
20073 code_pattern = DECL_TEMPLATE_RESULT (td);
20075 /* We should never be trying to instantiate a member of a class
20076 template or partial specialization. */
20077 gcc_assert (d != code_pattern);
20079 if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d))
20080 || DECL_TEMPLATE_SPECIALIZATION (td))
20081 /* In the case of a friend template whose definition is provided
20082 outside the class, we may have too many arguments. Drop the
20083 ones we don't need. The same is true for specializations. */
20084 args = get_innermost_template_args
20085 (gen_args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td)));
20089 if (TREE_CODE (d) == FUNCTION_DECL)
20091 deleted_p = DECL_DELETED_FN (code_pattern);
20092 pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE
20093 || DECL_DEFAULTED_OUTSIDE_CLASS_P (code_pattern)
20099 pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
20102 /* We may be in the middle of deferred access check. Disable it now. */
20103 push_deferring_access_checks (dk_no_deferred);
20105 /* Unless an explicit instantiation directive has already determined
20106 the linkage of D, remember that a definition is available for
20108 if (pattern_defined
20109 && !DECL_INTERFACE_KNOWN (d)
20110 && !DECL_NOT_REALLY_EXTERN (d))
20111 mark_definable (d);
20113 DECL_SOURCE_LOCATION (td) = DECL_SOURCE_LOCATION (code_pattern);
20114 DECL_SOURCE_LOCATION (d) = DECL_SOURCE_LOCATION (code_pattern);
20115 input_location = DECL_SOURCE_LOCATION (d);
20117 /* If D is a member of an explicitly instantiated class template,
20118 and no definition is available, treat it like an implicit
20120 if (!pattern_defined && expl_inst_class_mem_p
20121 && DECL_EXPLICIT_INSTANTIATION (d))
20123 /* Leave linkage flags alone on instantiations with anonymous
20125 if (TREE_PUBLIC (d))
20127 DECL_NOT_REALLY_EXTERN (d) = 0;
20128 DECL_INTERFACE_KNOWN (d) = 0;
20130 SET_DECL_IMPLICIT_INSTANTIATION (d);
20133 /* Defer all other templates, unless we have been explicitly
20134 forbidden from doing so. */
20135 if (/* If there is no definition, we cannot instantiate the
20138 /* If it's OK to postpone instantiation, do so. */
20140 /* If this is a static data member that will be defined
20141 elsewhere, we don't want to instantiate the entire data
20142 member, but we do want to instantiate the initializer so that
20143 we can substitute that elsewhere. */
20144 || (external_p && VAR_P (d))
20145 /* Handle here a deleted function too, avoid generating
20146 its body (c++/61080). */
20149 /* The definition of the static data member is now required so
20150 we must substitute the initializer. */
20152 && !DECL_INITIAL (d)
20153 && DECL_INITIAL (code_pattern))
20157 bool const_init = false;
20158 bool enter_context = DECL_CLASS_SCOPE_P (d);
20160 ns = decl_namespace_context (d);
20161 push_nested_namespace (ns);
20163 push_nested_class (DECL_CONTEXT (d));
20164 init = tsubst_expr (DECL_INITIAL (code_pattern),
20166 tf_warning_or_error, NULL_TREE,
20167 /*integral_constant_expression_p=*/false);
20168 /* If instantiating the initializer involved instantiating this
20169 again, don't call cp_finish_decl twice. */
20170 if (!DECL_INITIAL (d))
20172 /* Make sure the initializer is still constant, in case of
20173 circular dependency (template/instantiate6.C). */
20175 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern);
20176 cp_finish_decl (d, init, /*init_const_expr_p=*/const_init,
20177 /*asmspec_tree=*/NULL_TREE,
20178 LOOKUP_ONLYCONVERTING);
20181 pop_nested_class ();
20182 pop_nested_namespace (ns);
20185 /* We restore the source position here because it's used by
20186 add_pending_template. */
20187 input_location = saved_loc;
20189 if (at_eof && !pattern_defined
20190 && DECL_EXPLICIT_INSTANTIATION (d)
20191 && DECL_NOT_REALLY_EXTERN (d))
20194 The definition of a non-exported function template, a
20195 non-exported member function template, or a non-exported
20196 member function or static data member of a class template
20197 shall be present in every translation unit in which it is
20198 explicitly instantiated. */
20199 permerror (input_location, "explicit instantiation of %qD "
20200 "but no definition available", d);
20202 /* If we're in unevaluated context, we just wanted to get the
20203 constant value; this isn't an odr use, so don't queue
20204 a full instantiation. */
20205 if (cp_unevaluated_operand != 0)
20207 /* ??? Historically, we have instantiated inline functions, even
20208 when marked as "extern template". */
20209 if (!(external_p && VAR_P (d)))
20210 add_pending_template (d);
20213 /* Tell the repository that D is available in this translation unit
20214 -- and see if it is supposed to be instantiated here. */
20215 if (TREE_PUBLIC (d) && !DECL_REALLY_EXTERN (d) && !repo_emit_p (d))
20217 /* In a PCH file, despite the fact that the repository hasn't
20218 requested instantiation in the PCH it is still possible that
20219 an instantiation will be required in a file that includes the
20222 add_pending_template (d);
20223 /* Instantiate inline functions so that the inliner can do its
20224 job, even though we'll not be emitting a copy of this
20226 if (!(TREE_CODE (d) == FUNCTION_DECL && possibly_inlined_p (d)))
20230 fn_context = decl_function_context (d);
20231 nested = (current_function_decl != NULL_TREE);
20233 push_to_top_level ();
20237 push_function_context ();
20238 cp_unevaluated_operand = 0;
20239 c_inhibit_evaluation_warnings = 0;
20242 /* Mark D as instantiated so that recursive calls to
20243 instantiate_decl do not try to instantiate it again. */
20244 DECL_TEMPLATE_INSTANTIATED (d) = 1;
20246 /* Regenerate the declaration in case the template has been modified
20247 by a subsequent redeclaration. */
20248 regenerate_decl_from_template (d, td);
20250 /* We already set the file and line above. Reset them now in case
20251 they changed as a result of calling regenerate_decl_from_template. */
20252 input_location = DECL_SOURCE_LOCATION (d);
20257 bool const_init = false;
20259 /* Clear out DECL_RTL; whatever was there before may not be right
20260 since we've reset the type of the declaration. */
20261 SET_DECL_RTL (d, NULL);
20262 DECL_IN_AGGR_P (d) = 0;
20264 /* The initializer is placed in DECL_INITIAL by
20265 regenerate_decl_from_template so we don't need to
20266 push/pop_access_scope again here. Pull it out so that
20267 cp_finish_decl can process it. */
20268 init = DECL_INITIAL (d);
20269 DECL_INITIAL (d) = NULL_TREE;
20270 DECL_INITIALIZED_P (d) = 0;
20272 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
20273 initializer. That function will defer actual emission until
20274 we have a chance to determine linkage. */
20275 DECL_EXTERNAL (d) = 0;
20277 /* Enter the scope of D so that access-checking works correctly. */
20278 bool enter_context = DECL_CLASS_SCOPE_P (d);
20280 push_nested_class (DECL_CONTEXT (d));
20282 const_init = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern);
20283 cp_finish_decl (d, init, const_init, NULL_TREE, 0);
20286 pop_nested_class ();
20288 if (variable_template_p (td))
20289 note_variable_template_instantiation (d);
20291 else if (TREE_CODE (d) == FUNCTION_DECL && DECL_DEFAULTED_FN (code_pattern))
20292 synthesize_method (d);
20293 else if (TREE_CODE (d) == FUNCTION_DECL)
20295 hash_map<tree, tree> *saved_local_specializations;
20299 tree block = NULL_TREE;
20301 /* Save away the current list, in case we are instantiating one
20302 template from within the body of another. */
20303 saved_local_specializations = local_specializations;
20305 /* Set up the list of local specializations. */
20306 local_specializations = new hash_map<tree, tree>;
20308 /* Set up context. */
20309 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern)
20310 && TREE_CODE (DECL_CONTEXT (code_pattern)) == FUNCTION_DECL)
20311 block = push_stmt_list ();
20313 start_preparsed_function (d, NULL_TREE, SF_PRE_PARSED);
20315 /* Some typedefs referenced from within the template code need to be
20316 access checked at template instantiation time, i.e now. These
20317 types were added to the template at parsing time. Let's get those
20318 and perform the access checks then. */
20319 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (gen_tmpl),
20322 /* Create substitution entries for the parameters. */
20323 subst_decl = DECL_TEMPLATE_RESULT (template_for_substitution (d));
20324 tmpl_parm = DECL_ARGUMENTS (subst_decl);
20325 spec_parm = DECL_ARGUMENTS (d);
20326 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d))
20328 register_local_specialization (spec_parm, tmpl_parm);
20329 spec_parm = skip_artificial_parms_for (d, spec_parm);
20330 tmpl_parm = skip_artificial_parms_for (subst_decl, tmpl_parm);
20332 for (; tmpl_parm; tmpl_parm = DECL_CHAIN (tmpl_parm))
20334 if (!DECL_PACK_P (tmpl_parm))
20336 register_local_specialization (spec_parm, tmpl_parm);
20337 spec_parm = DECL_CHAIN (spec_parm);
20341 /* Register the (value) argument pack as a specialization of
20342 TMPL_PARM, then move on. */
20343 tree argpack = extract_fnparm_pack (tmpl_parm, &spec_parm);
20344 register_local_specialization (argpack, tmpl_parm);
20347 gcc_assert (!spec_parm);
20349 /* Substitute into the body of the function. */
20350 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern))
20351 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern), args,
20352 tf_warning_or_error, tmpl);
20355 tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
20356 tf_warning_or_error, tmpl,
20357 /*integral_constant_expression_p=*/false);
20359 /* Set the current input_location to the end of the function
20360 so that finish_function knows where we are. */
20362 = DECL_STRUCT_FUNCTION (code_pattern)->function_end_locus;
20364 /* Remember if we saw an infinite loop in the template. */
20365 current_function_infinite_loop
20366 = DECL_STRUCT_FUNCTION (code_pattern)->language->infinite_loop;
20369 /* We don't need the local specializations any more. */
20370 delete local_specializations;
20371 local_specializations = saved_local_specializations;
20373 /* Finish the function. */
20374 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern)
20375 && TREE_CODE (DECL_CONTEXT (code_pattern)) == FUNCTION_DECL)
20376 DECL_SAVED_TREE (d) = pop_stmt_list (block);
20379 d = finish_function (0);
20380 expand_or_defer_fn (d);
20383 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern))
20384 cp_check_omp_declare_reduction (d);
20387 /* We're not deferring instantiation any more. */
20388 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
20391 pop_from_top_level ();
20393 pop_function_context ();
20396 input_location = saved_loc;
20397 cp_unevaluated_operand = saved_unevaluated_operand;
20398 c_inhibit_evaluation_warnings = saved_inhibit_evaluation_warnings;
20399 pop_deferring_access_checks ();
20400 pop_tinst_level ();
20402 timevar_pop (TV_TEMPLATE_INST);
20407 /* Run through the list of templates that we wish we could
20408 instantiate, and instantiate any we can. RETRIES is the
20409 number of times we retry pending template instantiation. */
20412 instantiate_pending_templates (int retries)
20415 location_t saved_loc = input_location;
20417 /* Instantiating templates may trigger vtable generation. This in turn
20418 may require further template instantiations. We place a limit here
20419 to avoid infinite loop. */
20420 if (pending_templates && retries >= max_tinst_depth)
20422 tree decl = pending_templates->tinst->decl;
20424 fatal_error (input_location,
20425 "template instantiation depth exceeds maximum of %d"
20426 " instantiating %q+D, possibly from virtual table generation"
20427 " (use -ftemplate-depth= to increase the maximum)",
20428 max_tinst_depth, decl);
20429 if (TREE_CODE (decl) == FUNCTION_DECL)
20430 /* Pretend that we defined it. */
20431 DECL_INITIAL (decl) = error_mark_node;
20437 struct pending_template **t = &pending_templates;
20438 struct pending_template *last = NULL;
20442 tree instantiation = reopen_tinst_level ((*t)->tinst);
20443 bool complete = false;
20445 if (TYPE_P (instantiation))
20449 if (!COMPLETE_TYPE_P (instantiation))
20451 instantiate_class_template (instantiation);
20452 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
20453 for (fn = TYPE_METHODS (instantiation);
20455 fn = TREE_CHAIN (fn))
20456 if (! DECL_ARTIFICIAL (fn))
20457 instantiate_decl (fn,
20459 /*expl_inst_class_mem_p=*/false);
20460 if (COMPLETE_TYPE_P (instantiation))
20464 complete = COMPLETE_TYPE_P (instantiation);
20468 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation)
20469 && !DECL_TEMPLATE_INSTANTIATED (instantiation))
20472 = instantiate_decl (instantiation,
20474 /*expl_inst_class_mem_p=*/false);
20475 if (DECL_TEMPLATE_INSTANTIATED (instantiation))
20479 complete = (DECL_TEMPLATE_SPECIALIZATION (instantiation)
20480 || DECL_TEMPLATE_INSTANTIATED (instantiation));
20484 /* If INSTANTIATION has been instantiated, then we don't
20485 need to consider it again in the future. */
20493 current_tinst_level = NULL;
20495 last_pending_template = last;
20497 while (reconsider);
20499 input_location = saved_loc;
20502 /* Substitute ARGVEC into T, which is a list of initializers for
20503 either base class or a non-static data member. The TREE_PURPOSEs
20504 are DECLs, and the TREE_VALUEs are the initializer values. Used by
20505 instantiate_decl. */
20508 tsubst_initializer_list (tree t, tree argvec)
20510 tree inits = NULL_TREE;
20512 for (; t; t = TREE_CHAIN (t))
20516 tree expanded_bases = NULL_TREE;
20517 tree expanded_arguments = NULL_TREE;
20520 if (TREE_CODE (TREE_PURPOSE (t)) == TYPE_PACK_EXPANSION)
20525 /* Expand the base class expansion type into separate base
20527 expanded_bases = tsubst_pack_expansion (TREE_PURPOSE (t), argvec,
20528 tf_warning_or_error,
20530 if (expanded_bases == error_mark_node)
20533 /* We'll be building separate TREE_LISTs of arguments for
20535 len = TREE_VEC_LENGTH (expanded_bases);
20536 expanded_arguments = make_tree_vec (len);
20537 for (i = 0; i < len; i++)
20538 TREE_VEC_ELT (expanded_arguments, i) = NULL_TREE;
20540 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
20541 expand each argument in the TREE_VALUE of t. */
20542 expr = make_node (EXPR_PACK_EXPANSION);
20543 PACK_EXPANSION_LOCAL_P (expr) = true;
20544 PACK_EXPANSION_PARAMETER_PACKS (expr) =
20545 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t));
20547 if (TREE_VALUE (t) == void_type_node)
20548 /* VOID_TYPE_NODE is used to indicate
20549 value-initialization. */
20551 for (i = 0; i < len; i++)
20552 TREE_VEC_ELT (expanded_arguments, i) = void_type_node;
20556 /* Substitute parameter packs into each argument in the
20558 in_base_initializer = 1;
20559 for (arg = TREE_VALUE (t); arg; arg = TREE_CHAIN (arg))
20561 tree expanded_exprs;
20563 /* Expand the argument. */
20564 SET_PACK_EXPANSION_PATTERN (expr, TREE_VALUE (arg));
20566 = tsubst_pack_expansion (expr, argvec,
20567 tf_warning_or_error,
20569 if (expanded_exprs == error_mark_node)
20572 /* Prepend each of the expanded expressions to the
20573 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
20574 for (i = 0; i < len; i++)
20576 TREE_VEC_ELT (expanded_arguments, i) =
20577 tree_cons (NULL_TREE,
20578 TREE_VEC_ELT (expanded_exprs, i),
20579 TREE_VEC_ELT (expanded_arguments, i));
20582 in_base_initializer = 0;
20584 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
20585 since we built them backwards. */
20586 for (i = 0; i < len; i++)
20588 TREE_VEC_ELT (expanded_arguments, i) =
20589 nreverse (TREE_VEC_ELT (expanded_arguments, i));
20594 for (i = 0; i < len; ++i)
20596 if (expanded_bases)
20598 decl = TREE_VEC_ELT (expanded_bases, i);
20599 decl = expand_member_init (decl);
20600 init = TREE_VEC_ELT (expanded_arguments, i);
20605 decl = tsubst_copy (TREE_PURPOSE (t), argvec,
20606 tf_warning_or_error, NULL_TREE);
20608 decl = expand_member_init (decl);
20609 if (decl && !DECL_P (decl))
20610 in_base_initializer = 1;
20612 init = TREE_VALUE (t);
20614 if (init != void_type_node)
20615 init = tsubst_expr (init, argvec,
20616 tf_warning_or_error, NULL_TREE,
20617 /*integral_constant_expression_p=*/false);
20618 if (init == NULL_TREE && tmp != NULL_TREE)
20619 /* If we had an initializer but it instantiated to nothing,
20620 value-initialize the object. This will only occur when
20621 the initializer was a pack expansion where the parameter
20622 packs used in that expansion were of length zero. */
20623 init = void_type_node;
20624 in_base_initializer = 0;
20629 init = build_tree_list (decl, init);
20630 TREE_CHAIN (init) = inits;
20638 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
20641 set_current_access_from_decl (tree decl)
20643 if (TREE_PRIVATE (decl))
20644 current_access_specifier = access_private_node;
20645 else if (TREE_PROTECTED (decl))
20646 current_access_specifier = access_protected_node;
20648 current_access_specifier = access_public_node;
20651 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
20652 is the instantiation (which should have been created with
20653 start_enum) and ARGS are the template arguments to use. */
20656 tsubst_enum (tree tag, tree newtag, tree args)
20660 if (SCOPED_ENUM_P (newtag))
20661 begin_scope (sk_scoped_enum, newtag);
20663 for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
20668 decl = TREE_VALUE (e);
20669 /* Note that in a template enum, the TREE_VALUE is the
20670 CONST_DECL, not the corresponding INTEGER_CST. */
20671 value = tsubst_expr (DECL_INITIAL (decl),
20672 args, tf_warning_or_error, NULL_TREE,
20673 /*integral_constant_expression_p=*/true);
20675 /* Give this enumeration constant the correct access. */
20676 set_current_access_from_decl (decl);
20678 /* Actually build the enumerator itself. */
20680 (DECL_NAME (decl), value, newtag, DECL_SOURCE_LOCATION (decl));
20683 if (SCOPED_ENUM_P (newtag))
20686 finish_enum_value_list (newtag);
20687 finish_enum (newtag);
20689 DECL_SOURCE_LOCATION (TYPE_NAME (newtag))
20690 = DECL_SOURCE_LOCATION (TYPE_NAME (tag));
20693 /* DECL is a FUNCTION_DECL that is a template specialization. Return
20694 its type -- but without substituting the innermost set of template
20695 arguments. So, innermost set of template parameters will appear in
20699 get_mostly_instantiated_function_type (tree decl)
20701 /* For a function, DECL_TI_TEMPLATE is partially instantiated. */
20702 return TREE_TYPE (DECL_TI_TEMPLATE (decl));
20705 /* Return truthvalue if we're processing a template different from
20706 the last one involved in diagnostics. */
20708 problematic_instantiation_changed (void)
20710 return current_tinst_level != last_error_tinst_level;
20713 /* Remember current template involved in diagnostics. */
20715 record_last_problematic_instantiation (void)
20717 last_error_tinst_level = current_tinst_level;
20720 struct tinst_level *
20721 current_instantiation (void)
20723 return current_tinst_level;
20726 /* Return TRUE if current_function_decl is being instantiated, false
20730 instantiating_current_function_p (void)
20732 return (current_instantiation ()
20733 && current_instantiation ()->decl == current_function_decl);
20736 /* [temp.param] Check that template non-type parm TYPE is of an allowable
20737 type. Return zero for ok, nonzero for disallowed. Issue error and
20738 warning messages under control of COMPLAIN. */
20741 invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain)
20743 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type))
20745 else if (POINTER_TYPE_P (type))
20747 else if (TYPE_PTRMEM_P (type))
20749 else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
20751 else if (TREE_CODE (type) == TYPENAME_TYPE)
20753 else if (TREE_CODE (type) == DECLTYPE_TYPE)
20755 else if (TREE_CODE (type) == NULLPTR_TYPE)
20758 if (complain & tf_error)
20760 if (type == error_mark_node)
20761 inform (input_location, "invalid template non-type parameter");
20763 error ("%q#T is not a valid type for a template non-type parameter",
20769 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
20770 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
20773 dependent_type_p_r (tree type)
20779 A type is dependent if it is:
20781 -- a template parameter. Template template parameters are types
20782 for us (since TYPE_P holds true for them) so we handle
20784 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
20785 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
20787 /* -- a qualified-id with a nested-name-specifier which contains a
20788 class-name that names a dependent type or whose unqualified-id
20789 names a dependent type. */
20790 if (TREE_CODE (type) == TYPENAME_TYPE)
20792 /* -- a cv-qualified type where the cv-unqualified type is
20794 No code is necessary for this bullet; the code below handles
20795 cv-qualified types, and we don't want to strip aliases with
20796 TYPE_MAIN_VARIANT because of DR 1558. */
20797 /* -- a compound type constructed from any dependent type. */
20798 if (TYPE_PTRMEM_P (type))
20799 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type))
20800 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
20802 else if (TYPE_PTR_P (type)
20803 || TREE_CODE (type) == REFERENCE_TYPE)
20804 return dependent_type_p (TREE_TYPE (type));
20805 else if (TREE_CODE (type) == FUNCTION_TYPE
20806 || TREE_CODE (type) == METHOD_TYPE)
20810 if (dependent_type_p (TREE_TYPE (type)))
20812 for (arg_type = TYPE_ARG_TYPES (type);
20814 arg_type = TREE_CHAIN (arg_type))
20815 if (dependent_type_p (TREE_VALUE (arg_type)))
20819 /* -- an array type constructed from any dependent type or whose
20820 size is specified by a constant expression that is
20823 We checked for type- and value-dependence of the bounds in
20824 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
20825 if (TREE_CODE (type) == ARRAY_TYPE)
20827 if (TYPE_DOMAIN (type)
20828 && dependent_type_p (TYPE_DOMAIN (type)))
20830 return dependent_type_p (TREE_TYPE (type));
20833 /* -- a template-id in which either the template name is a template
20835 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
20837 /* ... or any of the template arguments is a dependent type or
20838 an expression that is type-dependent or value-dependent. */
20839 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
20840 && (any_dependent_template_arguments_p
20841 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
20843 /* For an alias template specialization, check the arguments both to the
20844 class template and the alias template. */
20845 else if (alias_template_specialization_p (type)
20846 && (any_dependent_template_arguments_p
20847 (INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (type)))))
20850 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
20851 dependent; if the argument of the `typeof' expression is not
20852 type-dependent, then it should already been have resolved. */
20853 if (TREE_CODE (type) == TYPEOF_TYPE
20854 || TREE_CODE (type) == DECLTYPE_TYPE
20855 || TREE_CODE (type) == UNDERLYING_TYPE)
20858 /* A template argument pack is dependent if any of its packed
20860 if (TREE_CODE (type) == TYPE_ARGUMENT_PACK)
20862 tree args = ARGUMENT_PACK_ARGS (type);
20863 int i, len = TREE_VEC_LENGTH (args);
20864 for (i = 0; i < len; ++i)
20865 if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
20869 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
20870 be template parameters. */
20871 if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
20874 /* The standard does not specifically mention types that are local
20875 to template functions or local classes, but they should be
20876 considered dependent too. For example:
20878 template <int I> void f() {
20883 The size of `E' cannot be known until the value of `I' has been
20884 determined. Therefore, `E' must be considered dependent. */
20885 scope = TYPE_CONTEXT (type);
20886 if (scope && TYPE_P (scope))
20887 return dependent_type_p (scope);
20888 /* Don't use type_dependent_expression_p here, as it can lead
20889 to infinite recursion trying to determine whether a lambda
20890 nested in a lambda is dependent (c++/47687). */
20891 else if (scope && TREE_CODE (scope) == FUNCTION_DECL
20892 && DECL_LANG_SPECIFIC (scope)
20893 && DECL_TEMPLATE_INFO (scope)
20894 && (any_dependent_template_arguments_p
20895 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope)))))
20898 /* Other types are non-dependent. */
20902 /* Returns TRUE if TYPE is dependent, in the sense of
20903 [temp.dep.type]. Note that a NULL type is considered dependent. */
20906 dependent_type_p (tree type)
20908 /* If there are no template parameters in scope, then there can't be
20909 any dependent types. */
20910 if (!processing_template_decl)
20912 /* If we are not processing a template, then nobody should be
20913 providing us with a dependent type. */
20915 gcc_assert (TREE_CODE (type) != TEMPLATE_TYPE_PARM || is_auto (type));
20919 /* If the type is NULL, we have not computed a type for the entity
20920 in question; in that case, the type is dependent. */
20924 /* Erroneous types can be considered non-dependent. */
20925 if (type == error_mark_node)
20928 /* If we have not already computed the appropriate value for TYPE,
20930 if (!TYPE_DEPENDENT_P_VALID (type))
20932 TYPE_DEPENDENT_P (type) = dependent_type_p_r (type);
20933 TYPE_DEPENDENT_P_VALID (type) = 1;
20936 return TYPE_DEPENDENT_P (type);
20939 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
20940 lookup. In other words, a dependent type that is not the current
20944 dependent_scope_p (tree scope)
20946 return (scope && TYPE_P (scope) && dependent_type_p (scope)
20947 && !currently_open_class (scope));
20950 /* T is a SCOPE_REF; return whether we need to consider it
20951 instantiation-dependent so that we can check access at instantiation
20952 time even though we know which member it resolves to. */
20955 instantiation_dependent_scope_ref_p (tree t)
20957 if (DECL_P (TREE_OPERAND (t, 1))
20958 && CLASS_TYPE_P (TREE_OPERAND (t, 0))
20959 && accessible_in_template_p (TREE_OPERAND (t, 0),
20960 TREE_OPERAND (t, 1)))
20966 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
20967 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
20970 /* Note that this predicate is not appropriate for general expressions;
20971 only constant expressions (that satisfy potential_constant_expression)
20972 can be tested for value dependence. */
20975 value_dependent_expression_p (tree expression)
20977 if (!processing_template_decl)
20980 /* A name declared with a dependent type. */
20981 if (DECL_P (expression) && type_dependent_expression_p (expression))
20984 switch (TREE_CODE (expression))
20986 case IDENTIFIER_NODE:
20987 /* A name that has not been looked up -- must be dependent. */
20990 case TEMPLATE_PARM_INDEX:
20991 /* A non-type template parm. */
20995 /* A non-type template parm. */
20996 if (DECL_TEMPLATE_PARM_P (expression))
20998 return value_dependent_expression_p (DECL_INITIAL (expression));
21001 /* A constant with literal type and is initialized
21002 with an expression that is value-dependent.
21004 Note that a non-dependent parenthesized initializer will have
21005 already been replaced with its constant value, so if we see
21006 a TREE_LIST it must be dependent. */
21007 if (DECL_INITIAL (expression)
21008 && decl_constant_var_p (expression)
21009 && (TREE_CODE (DECL_INITIAL (expression)) == TREE_LIST
21010 /* cp_finish_decl doesn't fold reference initializers. */
21011 || TREE_CODE (TREE_TYPE (expression)) == REFERENCE_TYPE
21012 || value_dependent_expression_p (DECL_INITIAL (expression))))
21016 case DYNAMIC_CAST_EXPR:
21017 case STATIC_CAST_EXPR:
21018 case CONST_CAST_EXPR:
21019 case REINTERPRET_CAST_EXPR:
21021 /* These expressions are value-dependent if the type to which
21022 the cast occurs is dependent or the expression being casted
21023 is value-dependent. */
21025 tree type = TREE_TYPE (expression);
21027 if (dependent_type_p (type))
21030 /* A functional cast has a list of operands. */
21031 expression = TREE_OPERAND (expression, 0);
21034 /* If there are no operands, it must be an expression such
21035 as "int()". This should not happen for aggregate types
21036 because it would form non-constant expressions. */
21037 gcc_assert (cxx_dialect >= cxx11
21038 || INTEGRAL_OR_ENUMERATION_TYPE_P (type));
21043 if (TREE_CODE (expression) == TREE_LIST)
21044 return any_value_dependent_elements_p (expression);
21046 return value_dependent_expression_p (expression);
21050 if (SIZEOF_EXPR_TYPE_P (expression))
21051 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression, 0)));
21055 /* A `sizeof' expression is value-dependent if the operand is
21056 type-dependent or is a pack expansion. */
21057 expression = TREE_OPERAND (expression, 0);
21058 if (PACK_EXPANSION_P (expression))
21060 else if (TYPE_P (expression))
21061 return dependent_type_p (expression);
21062 return instantiation_dependent_expression_p (expression);
21064 case AT_ENCODE_EXPR:
21065 /* An 'encode' expression is value-dependent if the operand is
21067 expression = TREE_OPERAND (expression, 0);
21068 return dependent_type_p (expression);
21070 case NOEXCEPT_EXPR:
21071 expression = TREE_OPERAND (expression, 0);
21072 return instantiation_dependent_expression_p (expression);
21075 /* All instantiation-dependent expressions should also be considered
21076 value-dependent. */
21077 return instantiation_dependent_scope_ref_p (expression);
21079 case COMPONENT_REF:
21080 return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
21081 || value_dependent_expression_p (TREE_OPERAND (expression, 1)));
21083 case NONTYPE_ARGUMENT_PACK:
21084 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
21085 is value-dependent. */
21087 tree values = ARGUMENT_PACK_ARGS (expression);
21088 int i, len = TREE_VEC_LENGTH (values);
21090 for (i = 0; i < len; ++i)
21091 if (value_dependent_expression_p (TREE_VEC_ELT (values, i)))
21099 tree type2 = TRAIT_EXPR_TYPE2 (expression);
21100 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression))
21101 || (type2 ? dependent_type_p (type2) : false));
21105 return ((value_dependent_expression_p (TREE_OPERAND (expression, 0)))
21106 || (value_dependent_expression_p (TREE_OPERAND (expression, 2))));
21109 return ((value_dependent_expression_p (TREE_OPERAND (expression, 0)))
21110 || (value_dependent_expression_p (TREE_OPERAND (expression, 1))));
21114 tree op = TREE_OPERAND (expression, 0);
21115 return (value_dependent_expression_p (op)
21116 || has_value_dependent_address (op));
21121 tree fn = get_callee_fndecl (expression);
21123 if (!fn && value_dependent_expression_p (CALL_EXPR_FN (expression)))
21125 nargs = call_expr_nargs (expression);
21126 for (i = 0; i < nargs; ++i)
21128 tree op = CALL_EXPR_ARG (expression, i);
21129 /* In a call to a constexpr member function, look through the
21130 implicit ADDR_EXPR on the object argument so that it doesn't
21131 cause the call to be considered value-dependent. We also
21132 look through it in potential_constant_expression. */
21133 if (i == 0 && fn && DECL_DECLARED_CONSTEXPR_P (fn)
21134 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
21135 && TREE_CODE (op) == ADDR_EXPR)
21136 op = TREE_OPERAND (op, 0);
21137 if (value_dependent_expression_p (op))
21143 case TEMPLATE_ID_EXPR:
21144 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
21146 return type_dependent_expression_p (expression);
21152 if (dependent_type_p (TREE_TYPE (expression)))
21154 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression), ix, val)
21155 if (value_dependent_expression_p (val))
21161 /* Treat a GNU statement expression as dependent to avoid crashing
21162 under instantiate_non_dependent_expr; it can't be constant. */
21166 /* A constant expression is value-dependent if any subexpression is
21167 value-dependent. */
21168 switch (TREE_CODE_CLASS (TREE_CODE (expression)))
21170 case tcc_reference:
21172 case tcc_comparison:
21174 case tcc_expression:
21177 int i, len = cp_tree_operand_length (expression);
21179 for (i = 0; i < len; i++)
21181 tree t = TREE_OPERAND (expression, i);
21183 /* In some cases, some of the operands may be missing.l
21184 (For example, in the case of PREDECREMENT_EXPR, the
21185 amount to increment by may be missing.) That doesn't
21186 make the expression dependent. */
21187 if (t && value_dependent_expression_p (t))
21198 /* The expression is not value-dependent. */
21202 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
21203 [temp.dep.expr]. Note that an expression with no type is
21204 considered dependent. Other parts of the compiler arrange for an
21205 expression with type-dependent subexpressions to have no type, so
21206 this function doesn't have to be fully recursive. */
21209 type_dependent_expression_p (tree expression)
21211 if (!processing_template_decl)
21214 if (expression == NULL_TREE || expression == error_mark_node)
21217 /* An unresolved name is always dependent. */
21218 if (identifier_p (expression) || TREE_CODE (expression) == USING_DECL)
21221 /* Some expression forms are never type-dependent. */
21222 if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR
21223 || TREE_CODE (expression) == SIZEOF_EXPR
21224 || TREE_CODE (expression) == ALIGNOF_EXPR
21225 || TREE_CODE (expression) == AT_ENCODE_EXPR
21226 || TREE_CODE (expression) == NOEXCEPT_EXPR
21227 || TREE_CODE (expression) == TRAIT_EXPR
21228 || TREE_CODE (expression) == TYPEID_EXPR
21229 || TREE_CODE (expression) == DELETE_EXPR
21230 || TREE_CODE (expression) == VEC_DELETE_EXPR
21231 || TREE_CODE (expression) == THROW_EXPR)
21234 /* The types of these expressions depends only on the type to which
21235 the cast occurs. */
21236 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
21237 || TREE_CODE (expression) == STATIC_CAST_EXPR
21238 || TREE_CODE (expression) == CONST_CAST_EXPR
21239 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
21240 || TREE_CODE (expression) == IMPLICIT_CONV_EXPR
21241 || TREE_CODE (expression) == CAST_EXPR)
21242 return dependent_type_p (TREE_TYPE (expression));
21244 /* The types of these expressions depends only on the type created
21245 by the expression. */
21246 if (TREE_CODE (expression) == NEW_EXPR
21247 || TREE_CODE (expression) == VEC_NEW_EXPR)
21249 /* For NEW_EXPR tree nodes created inside a template, either
21250 the object type itself or a TREE_LIST may appear as the
21252 tree type = TREE_OPERAND (expression, 1);
21253 if (TREE_CODE (type) == TREE_LIST)
21254 /* This is an array type. We need to check array dimensions
21256 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type)))
21257 || value_dependent_expression_p
21258 (TREE_OPERAND (TREE_VALUE (type), 1));
21260 return dependent_type_p (type);
21263 if (TREE_CODE (expression) == SCOPE_REF)
21265 tree scope = TREE_OPERAND (expression, 0);
21266 tree name = TREE_OPERAND (expression, 1);
21268 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
21269 contains an identifier associated by name lookup with one or more
21270 declarations declared with a dependent type, or...a
21271 nested-name-specifier or qualified-id that names a member of an
21272 unknown specialization. */
21273 return (type_dependent_expression_p (name)
21274 || dependent_scope_p (scope));
21277 if (TREE_CODE (expression) == FUNCTION_DECL
21278 && DECL_LANG_SPECIFIC (expression)
21279 && DECL_TEMPLATE_INFO (expression)
21280 && (any_dependent_template_arguments_p
21281 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
21284 if (TREE_CODE (expression) == TEMPLATE_DECL
21285 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression))
21288 if (TREE_CODE (expression) == STMT_EXPR)
21289 expression = stmt_expr_value_expr (expression);
21291 if (BRACE_ENCLOSED_INITIALIZER_P (expression))
21296 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression), i, elt)
21298 if (type_dependent_expression_p (elt))
21304 /* A static data member of the current instantiation with incomplete
21305 array type is type-dependent, as the definition and specializations
21306 can have different bounds. */
21307 if (VAR_P (expression)
21308 && DECL_CLASS_SCOPE_P (expression)
21309 && dependent_type_p (DECL_CONTEXT (expression))
21310 && VAR_HAD_UNKNOWN_BOUND (expression))
21313 /* An array of unknown bound depending on a variadic parameter, eg:
21315 template<typename... Args>
21316 void foo (Args... args)
21318 int arr[] = { args... };
21321 template<int... vals>
21324 int arr[] = { vals... };
21327 If the array has no length and has an initializer, it must be that
21328 we couldn't determine its length in cp_complete_array_type because
21329 it is dependent. */
21330 if (VAR_P (expression)
21331 && TREE_CODE (TREE_TYPE (expression)) == ARRAY_TYPE
21332 && !TYPE_DOMAIN (TREE_TYPE (expression))
21333 && DECL_INITIAL (expression))
21336 /* A variable template specialization is type-dependent if it has any
21337 dependent template arguments. */
21338 if (VAR_P (expression)
21339 && DECL_LANG_SPECIFIC (expression)
21340 && DECL_TEMPLATE_INFO (expression)
21341 && variable_template_p (DECL_TI_TEMPLATE (expression)))
21342 return any_dependent_template_arguments_p (DECL_TI_ARGS (expression));
21344 if (TREE_TYPE (expression) == unknown_type_node)
21346 if (TREE_CODE (expression) == ADDR_EXPR)
21347 return type_dependent_expression_p (TREE_OPERAND (expression, 0));
21348 if (TREE_CODE (expression) == COMPONENT_REF
21349 || TREE_CODE (expression) == OFFSET_REF)
21351 if (type_dependent_expression_p (TREE_OPERAND (expression, 0)))
21353 expression = TREE_OPERAND (expression, 1);
21354 if (identifier_p (expression))
21357 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
21358 if (TREE_CODE (expression) == SCOPE_REF)
21361 /* Always dependent, on the number of arguments if nothing else. */
21362 if (TREE_CODE (expression) == EXPR_PACK_EXPANSION)
21365 if (BASELINK_P (expression))
21367 if (BASELINK_OPTYPE (expression)
21368 && dependent_type_p (BASELINK_OPTYPE (expression)))
21370 expression = BASELINK_FUNCTIONS (expression);
21373 if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
21375 if (any_dependent_template_arguments_p
21376 (TREE_OPERAND (expression, 1)))
21378 expression = TREE_OPERAND (expression, 0);
21380 gcc_assert (TREE_CODE (expression) == OVERLOAD
21381 || TREE_CODE (expression) == FUNCTION_DECL);
21385 if (type_dependent_expression_p (OVL_CURRENT (expression)))
21387 expression = OVL_NEXT (expression);
21392 gcc_assert (TREE_CODE (expression) != TYPE_DECL);
21394 return (dependent_type_p (TREE_TYPE (expression)));
21397 /* walk_tree callback function for instantiation_dependent_expression_p,
21398 below. Returns non-zero if a dependent subexpression is found. */
21401 instantiation_dependent_r (tree *tp, int *walk_subtrees,
21406 /* We don't have to worry about decltype currently because decltype
21407 of an instantiation-dependent expr is a dependent type. This
21408 might change depending on the resolution of DR 1172. */
21409 *walk_subtrees = false;
21412 enum tree_code code = TREE_CODE (*tp);
21415 /* Don't treat an argument list as dependent just because it has no
21423 /* A constant with a dependent initializer is dependent. */
21424 if (value_dependent_expression_p (*tp))
21428 case TEMPLATE_PARM_INDEX:
21431 /* Handle expressions with type operands. */
21435 case AT_ENCODE_EXPR:
21437 tree op = TREE_OPERAND (*tp, 0);
21438 if (code == SIZEOF_EXPR && SIZEOF_EXPR_TYPE_P (*tp))
21439 op = TREE_TYPE (op);
21442 if (dependent_type_p (op))
21446 *walk_subtrees = false;
21454 if (dependent_type_p (TRAIT_EXPR_TYPE1 (*tp))
21455 || (TRAIT_EXPR_TYPE2 (*tp)
21456 && dependent_type_p (TRAIT_EXPR_TYPE2 (*tp))))
21458 *walk_subtrees = false;
21461 case COMPONENT_REF:
21462 if (identifier_p (TREE_OPERAND (*tp, 1)))
21463 /* In a template, finish_class_member_access_expr creates a
21464 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
21465 type-dependent, so that we can check access control at
21466 instantiation time (PR 42277). See also Core issue 1273. */
21471 if (instantiation_dependent_scope_ref_p (*tp))
21476 /* Treat statement-expressions as dependent. */
21484 if (type_dependent_expression_p (*tp))
21490 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
21491 sense defined by the ABI:
21493 "An expression is instantiation-dependent if it is type-dependent
21494 or value-dependent, or it has a subexpression that is type-dependent
21495 or value-dependent." */
21498 instantiation_dependent_expression_p (tree expression)
21502 if (!processing_template_decl)
21505 if (expression == error_mark_node)
21508 result = cp_walk_tree_without_duplicates (&expression,
21509 instantiation_dependent_r, NULL);
21510 return result != NULL_TREE;
21513 /* Like type_dependent_expression_p, but it also works while not processing
21514 a template definition, i.e. during substitution or mangling. */
21517 type_dependent_expression_p_push (tree expr)
21520 ++processing_template_decl;
21521 b = type_dependent_expression_p (expr);
21522 --processing_template_decl;
21526 /* Returns TRUE if ARGS contains a type-dependent expression. */
21529 any_type_dependent_arguments_p (const vec<tree, va_gc> *args)
21534 FOR_EACH_VEC_SAFE_ELT (args, i, arg)
21536 if (type_dependent_expression_p (arg))
21542 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21543 expressions) contains any type-dependent expressions. */
21546 any_type_dependent_elements_p (const_tree list)
21548 for (; list; list = TREE_CHAIN (list))
21549 if (type_dependent_expression_p (TREE_VALUE (list)))
21555 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21556 expressions) contains any value-dependent expressions. */
21559 any_value_dependent_elements_p (const_tree list)
21561 for (; list; list = TREE_CHAIN (list))
21562 if (value_dependent_expression_p (TREE_VALUE (list)))
21568 /* Returns TRUE if the ARG (a template argument) is dependent. */
21571 dependent_template_arg_p (tree arg)
21573 if (!processing_template_decl)
21576 /* Assume a template argument that was wrongly written by the user
21577 is dependent. This is consistent with what
21578 any_dependent_template_arguments_p [that calls this function]
21580 if (!arg || arg == error_mark_node)
21583 if (TREE_CODE (arg) == ARGUMENT_PACK_SELECT)
21584 arg = ARGUMENT_PACK_SELECT_ARG (arg);
21586 if (TREE_CODE (arg) == TEMPLATE_DECL
21587 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
21588 return dependent_template_p (arg);
21589 else if (ARGUMENT_PACK_P (arg))
21591 tree args = ARGUMENT_PACK_ARGS (arg);
21592 int i, len = TREE_VEC_LENGTH (args);
21593 for (i = 0; i < len; ++i)
21595 if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
21601 else if (TYPE_P (arg))
21602 return dependent_type_p (arg);
21604 return (type_dependent_expression_p (arg)
21605 || value_dependent_expression_p (arg));
21608 /* Returns true if ARGS (a collection of template arguments) contains
21609 any types that require structural equality testing. */
21612 any_template_arguments_need_structural_equality_p (tree args)
21619 if (args == error_mark_node)
21622 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
21624 tree level = TMPL_ARGS_LEVEL (args, i + 1);
21625 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
21627 tree arg = TREE_VEC_ELT (level, j);
21628 tree packed_args = NULL_TREE;
21631 if (ARGUMENT_PACK_P (arg))
21633 /* Look inside the argument pack. */
21634 packed_args = ARGUMENT_PACK_ARGS (arg);
21635 len = TREE_VEC_LENGTH (packed_args);
21638 for (k = 0; k < len; ++k)
21641 arg = TREE_VEC_ELT (packed_args, k);
21643 if (error_operand_p (arg))
21645 else if (TREE_CODE (arg) == TEMPLATE_DECL)
21647 else if (TYPE_P (arg) && TYPE_STRUCTURAL_EQUALITY_P (arg))
21649 else if (!TYPE_P (arg) && TREE_TYPE (arg)
21650 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg)))
21659 /* Returns true if ARGS (a collection of template arguments) contains
21660 any dependent arguments. */
21663 any_dependent_template_arguments_p (const_tree args)
21670 if (args == error_mark_node)
21673 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
21675 const_tree level = TMPL_ARGS_LEVEL (args, i + 1);
21676 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
21677 if (dependent_template_arg_p (TREE_VEC_ELT (level, j)))
21684 /* Returns TRUE if the template TMPL is dependent. */
21687 dependent_template_p (tree tmpl)
21689 if (TREE_CODE (tmpl) == OVERLOAD)
21693 if (dependent_template_p (OVL_CURRENT (tmpl)))
21695 tmpl = OVL_NEXT (tmpl);
21700 /* Template template parameters are dependent. */
21701 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
21702 || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
21704 /* So are names that have not been looked up. */
21705 if (TREE_CODE (tmpl) == SCOPE_REF || identifier_p (tmpl))
21707 /* So are member templates of dependent classes. */
21708 if (TYPE_P (CP_DECL_CONTEXT (tmpl)))
21709 return dependent_type_p (DECL_CONTEXT (tmpl));
21713 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
21716 dependent_template_id_p (tree tmpl, tree args)
21718 return (dependent_template_p (tmpl)
21719 || any_dependent_template_arguments_p (args));
21722 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
21726 dependent_omp_for_p (tree declv, tree initv, tree condv, tree incrv)
21730 if (!processing_template_decl)
21733 for (i = 0; i < TREE_VEC_LENGTH (declv); i++)
21735 tree decl = TREE_VEC_ELT (declv, i);
21736 tree init = TREE_VEC_ELT (initv, i);
21737 tree cond = TREE_VEC_ELT (condv, i);
21738 tree incr = TREE_VEC_ELT (incrv, i);
21740 if (type_dependent_expression_p (decl))
21743 if (init && type_dependent_expression_p (init))
21746 if (type_dependent_expression_p (cond))
21749 if (COMPARISON_CLASS_P (cond)
21750 && (type_dependent_expression_p (TREE_OPERAND (cond, 0))
21751 || type_dependent_expression_p (TREE_OPERAND (cond, 1))))
21754 if (TREE_CODE (incr) == MODOP_EXPR)
21756 if (type_dependent_expression_p (TREE_OPERAND (incr, 0))
21757 || type_dependent_expression_p (TREE_OPERAND (incr, 2)))
21760 else if (type_dependent_expression_p (incr))
21762 else if (TREE_CODE (incr) == MODIFY_EXPR)
21764 if (type_dependent_expression_p (TREE_OPERAND (incr, 0)))
21766 else if (BINARY_CLASS_P (TREE_OPERAND (incr, 1)))
21768 tree t = TREE_OPERAND (incr, 1);
21769 if (type_dependent_expression_p (TREE_OPERAND (t, 0))
21770 || type_dependent_expression_p (TREE_OPERAND (t, 1)))
21779 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
21780 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
21781 no such TYPE can be found. Note that this function peers inside
21782 uninstantiated templates and therefore should be used only in
21783 extremely limited situations. ONLY_CURRENT_P restricts this
21784 peering to the currently open classes hierarchy (which is required
21785 when comparing types). */
21788 resolve_typename_type (tree type, bool only_current_p)
21797 gcc_assert (TREE_CODE (type) == TYPENAME_TYPE);
21799 scope = TYPE_CONTEXT (type);
21800 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
21801 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
21802 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
21803 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
21804 identifier of the TYPENAME_TYPE anymore.
21805 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
21806 TYPENAME_TYPE instead, we avoid messing up with a possible
21807 typedef variant case. */
21808 name = TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
21810 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
21811 it first before we can figure out what NAME refers to. */
21812 if (TREE_CODE (scope) == TYPENAME_TYPE)
21814 if (TYPENAME_IS_RESOLVING_P (scope))
21815 /* Given a class template A with a dependent base with nested type C,
21816 typedef typename A::C::C C will land us here, as trying to resolve
21817 the initial A::C leads to the local C typedef, which leads back to
21818 A::C::C. So we break the recursion now. */
21821 scope = resolve_typename_type (scope, only_current_p);
21823 /* If we don't know what SCOPE refers to, then we cannot resolve the
21825 if (TREE_CODE (scope) == TYPENAME_TYPE)
21827 /* If the SCOPE is a template type parameter, we have no way of
21828 resolving the name. */
21829 if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
21831 /* If the SCOPE is not the current instantiation, there's no reason
21832 to look inside it. */
21833 if (only_current_p && !currently_open_class (scope))
21835 /* If this is a typedef, we don't want to look inside (c++/11987). */
21836 if (typedef_variant_p (type))
21838 /* If SCOPE isn't the template itself, it will not have a valid
21839 TYPE_FIELDS list. */
21840 if (same_type_p (scope, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope)))
21841 /* scope is either the template itself or a compatible instantiation
21842 like X<T>, so look up the name in the original template. */
21843 scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope);
21845 /* scope is a partial instantiation, so we can't do the lookup or we
21846 will lose the template arguments. */
21848 /* Enter the SCOPE so that name lookup will be resolved as if we
21849 were in the class definition. In particular, SCOPE will no
21850 longer be considered a dependent type. */
21851 pushed_scope = push_scope (scope);
21852 /* Look up the declaration. */
21853 decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true,
21854 tf_warning_or_error);
21856 result = NULL_TREE;
21858 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
21859 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
21862 else if (identifier_p (TYPENAME_TYPE_FULLNAME (type))
21863 && TREE_CODE (decl) == TYPE_DECL)
21865 result = TREE_TYPE (decl);
21866 if (result == error_mark_node)
21867 result = NULL_TREE;
21869 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR
21870 && DECL_CLASS_TEMPLATE_P (decl))
21874 /* Obtain the template and the arguments. */
21875 tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0);
21876 args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1);
21877 /* Instantiate the template. */
21878 result = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE,
21879 /*entering_scope=*/0,
21880 tf_error | tf_user);
21881 if (result == error_mark_node)
21882 result = NULL_TREE;
21885 /* Leave the SCOPE. */
21887 pop_scope (pushed_scope);
21889 /* If we failed to resolve it, return the original typename. */
21893 /* If lookup found a typename type, resolve that too. */
21894 if (TREE_CODE (result) == TYPENAME_TYPE && !TYPENAME_IS_RESOLVING_P (result))
21896 /* Ill-formed programs can cause infinite recursion here, so we
21897 must catch that. */
21898 TYPENAME_IS_RESOLVING_P (type) = 1;
21899 result = resolve_typename_type (result, only_current_p);
21900 TYPENAME_IS_RESOLVING_P (type) = 0;
21903 /* Qualify the resulting type. */
21904 quals = cp_type_quals (type);
21906 result = cp_build_qualified_type (result, cp_type_quals (result) | quals);
21911 /* EXPR is an expression which is not type-dependent. Return a proxy
21912 for EXPR that can be used to compute the types of larger
21913 expressions containing EXPR. */
21916 build_non_dependent_expr (tree expr)
21920 #ifdef ENABLE_CHECKING
21921 /* Try to get a constant value for all non-dependent expressions in
21922 order to expose bugs in *_dependent_expression_p and constexpr. */
21923 if (cxx_dialect >= cxx11)
21924 fold_non_dependent_expr (expr);
21927 /* Preserve OVERLOADs; the functions must be available to resolve
21930 if (TREE_CODE (inner_expr) == STMT_EXPR)
21931 inner_expr = stmt_expr_value_expr (inner_expr);
21932 if (TREE_CODE (inner_expr) == ADDR_EXPR)
21933 inner_expr = TREE_OPERAND (inner_expr, 0);
21934 if (TREE_CODE (inner_expr) == COMPONENT_REF)
21935 inner_expr = TREE_OPERAND (inner_expr, 1);
21936 if (is_overloaded_fn (inner_expr)
21937 || TREE_CODE (inner_expr) == OFFSET_REF)
21939 /* There is no need to return a proxy for a variable. */
21942 /* Preserve string constants; conversions from string constants to
21943 "char *" are allowed, even though normally a "const char *"
21944 cannot be used to initialize a "char *". */
21945 if (TREE_CODE (expr) == STRING_CST)
21947 /* Preserve void and arithmetic constants, as an optimization -- there is no
21948 reason to create a new node. */
21949 if (TREE_CODE (expr) == VOID_CST
21950 || TREE_CODE (expr) == INTEGER_CST
21951 || TREE_CODE (expr) == REAL_CST)
21953 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
21954 There is at least one place where we want to know that a
21955 particular expression is a throw-expression: when checking a ?:
21956 expression, there are special rules if the second or third
21957 argument is a throw-expression. */
21958 if (TREE_CODE (expr) == THROW_EXPR)
21961 /* Don't wrap an initializer list, we need to be able to look inside. */
21962 if (BRACE_ENCLOSED_INITIALIZER_P (expr))
21965 /* Don't wrap a dummy object, we need to be able to test for it. */
21966 if (is_dummy_object (expr))
21969 if (TREE_CODE (expr) == COND_EXPR)
21970 return build3 (COND_EXPR,
21972 TREE_OPERAND (expr, 0),
21973 (TREE_OPERAND (expr, 1)
21974 ? build_non_dependent_expr (TREE_OPERAND (expr, 1))
21975 : build_non_dependent_expr (TREE_OPERAND (expr, 0))),
21976 build_non_dependent_expr (TREE_OPERAND (expr, 2)));
21977 if (TREE_CODE (expr) == COMPOUND_EXPR
21978 && !COMPOUND_EXPR_OVERLOADED (expr))
21979 return build2 (COMPOUND_EXPR,
21981 TREE_OPERAND (expr, 0),
21982 build_non_dependent_expr (TREE_OPERAND (expr, 1)));
21984 /* If the type is unknown, it can't really be non-dependent */
21985 gcc_assert (TREE_TYPE (expr) != unknown_type_node);
21987 /* Otherwise, build a NON_DEPENDENT_EXPR. */
21988 return build1 (NON_DEPENDENT_EXPR, TREE_TYPE (expr), expr);
21991 /* ARGS is a vector of expressions as arguments to a function call.
21992 Replace the arguments with equivalent non-dependent expressions.
21993 This modifies ARGS in place. */
21996 make_args_non_dependent (vec<tree, va_gc> *args)
22001 FOR_EACH_VEC_SAFE_ELT (args, ix, arg)
22003 tree newarg = build_non_dependent_expr (arg);
22005 (*args)[ix] = newarg;
22009 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
22010 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
22014 make_auto_1 (tree name)
22016 tree au = cxx_make_type (TEMPLATE_TYPE_PARM);
22017 TYPE_NAME (au) = build_decl (input_location,
22018 TYPE_DECL, name, au);
22019 TYPE_STUB_DECL (au) = TYPE_NAME (au);
22020 TEMPLATE_TYPE_PARM_INDEX (au) = build_template_parm_index
22021 (0, processing_template_decl + 1, processing_template_decl + 1,
22022 TYPE_NAME (au), NULL_TREE);
22023 TYPE_CANONICAL (au) = canonical_type_parameter (au);
22024 DECL_ARTIFICIAL (TYPE_NAME (au)) = 1;
22025 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au));
22031 make_decltype_auto (void)
22033 return make_auto_1 (get_identifier ("decltype(auto)"));
22039 return make_auto_1 (get_identifier ("auto"));
22042 /* Given type ARG, return std::initializer_list<ARG>. */
22047 tree std_init_list = namespace_binding
22048 (get_identifier ("initializer_list"), std_node);
22050 if (!std_init_list || !DECL_CLASS_TEMPLATE_P (std_init_list))
22052 error ("deducing from brace-enclosed initializer list requires "
22053 "#include <initializer_list>");
22054 return error_mark_node;
22056 argvec = make_tree_vec (1);
22057 TREE_VEC_ELT (argvec, 0) = arg;
22058 return lookup_template_class (std_init_list, argvec, NULL_TREE,
22059 NULL_TREE, 0, tf_warning_or_error);
22062 /* Replace auto in TYPE with std::initializer_list<auto>. */
22065 listify_autos (tree type, tree auto_node)
22067 tree init_auto = listify (auto_node);
22068 tree argvec = make_tree_vec (1);
22069 TREE_VEC_ELT (argvec, 0) = init_auto;
22070 if (processing_template_decl)
22071 argvec = add_to_template_args (current_template_args (), argvec);
22072 return tsubst (type, argvec, tf_warning_or_error, NULL_TREE);
22075 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
22076 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
22079 do_auto_deduction (tree type, tree init, tree auto_node)
22083 if (init == error_mark_node)
22084 return error_mark_node;
22086 if (type_dependent_expression_p (init))
22087 /* Defining a subset of type-dependent expressions that we can deduce
22088 from ahead of time isn't worth the trouble. */
22091 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
22092 with either a new invented type template parameter U or, if the
22093 initializer is a braced-init-list (8.5.4), with
22094 std::initializer_list<U>. */
22095 if (BRACE_ENCLOSED_INITIALIZER_P (init))
22097 if (!DIRECT_LIST_INIT_P (init))
22098 type = listify_autos (type, auto_node);
22099 else if (CONSTRUCTOR_NELTS (init) == 1)
22100 init = CONSTRUCTOR_ELT (init, 0)->value;
22103 if (permerror (input_location, "direct-list-initialization of "
22104 "%<auto%> requires exactly one element"))
22105 inform (input_location,
22106 "for deduction to %<std::initializer_list%>, use copy-"
22107 "list-initialization (i.e. add %<=%> before the %<{%>)");
22108 type = listify_autos (type, auto_node);
22112 init = resolve_nondeduced_context (init);
22114 targs = make_tree_vec (1);
22115 if (AUTO_IS_DECLTYPE (auto_node))
22117 bool id = (DECL_P (init) || (TREE_CODE (init) == COMPONENT_REF
22118 && !REF_PARENTHESIZED_P (init)));
22119 TREE_VEC_ELT (targs, 0)
22120 = finish_decltype_type (init, id, tf_warning_or_error);
22121 if (type != auto_node)
22123 error ("%qT as type rather than plain %<decltype(auto)%>", type);
22124 return error_mark_node;
22129 tree parms = build_tree_list (NULL_TREE, type);
22130 tree tparms = make_tree_vec (1);
22133 TREE_VEC_ELT (tparms, 0)
22134 = build_tree_list (NULL_TREE, TYPE_NAME (auto_node));
22135 val = type_unification_real (tparms, targs, parms, &init, 1, 0,
22136 DEDUCE_CALL, LOOKUP_NORMAL,
22137 NULL, /*explain_p=*/false);
22140 if (processing_template_decl)
22141 /* Try again at instantiation time. */
22143 if (type && type != error_mark_node)
22144 /* If type is error_mark_node a diagnostic must have been
22145 emitted by now. Also, having a mention to '<type error>'
22146 in the diagnostic is not really useful to the user. */
22148 if (cfun && auto_node == current_function_auto_return_pattern
22149 && LAMBDA_FUNCTION_P (current_function_decl))
22150 error ("unable to deduce lambda return type from %qE", init);
22152 error ("unable to deduce %qT from %qE", type, init);
22154 return error_mark_node;
22158 /* If the list of declarators contains more than one declarator, the type
22159 of each declared variable is determined as described above. If the
22160 type deduced for the template parameter U is not the same in each
22161 deduction, the program is ill-formed. */
22162 if (TREE_TYPE (auto_node)
22163 && !same_type_p (TREE_TYPE (auto_node), TREE_VEC_ELT (targs, 0)))
22165 if (cfun && auto_node == current_function_auto_return_pattern
22166 && LAMBDA_FUNCTION_P (current_function_decl))
22167 error ("inconsistent types %qT and %qT deduced for "
22168 "lambda return type", TREE_TYPE (auto_node),
22169 TREE_VEC_ELT (targs, 0));
22171 error ("inconsistent deduction for %qT: %qT and then %qT",
22172 auto_node, TREE_TYPE (auto_node), TREE_VEC_ELT (targs, 0));
22173 return error_mark_node;
22175 TREE_TYPE (auto_node) = TREE_VEC_ELT (targs, 0);
22177 if (processing_template_decl)
22178 targs = add_to_template_args (current_template_args (), targs);
22179 return tsubst (type, targs, tf_warning_or_error, NULL_TREE);
22182 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
22186 splice_late_return_type (tree type, tree late_return_type)
22190 if (late_return_type == NULL_TREE)
22192 argvec = make_tree_vec (1);
22193 TREE_VEC_ELT (argvec, 0) = late_return_type;
22194 if (processing_template_parmlist)
22195 /* For a late-specified return type in a template type-parameter, we
22196 need to add a dummy argument level for its parmlist. */
22197 argvec = add_to_template_args
22198 (make_tree_vec (processing_template_parmlist), argvec);
22199 if (current_template_parms)
22200 argvec = add_to_template_args (current_template_args (), argvec);
22201 return tsubst (type, argvec, tf_warning_or_error, NULL_TREE);
22204 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
22205 'decltype(auto)'. */
22208 is_auto (const_tree type)
22210 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
22211 && (TYPE_IDENTIFIER (type) == get_identifier ("auto")
22212 || TYPE_IDENTIFIER (type) == get_identifier ("decltype(auto)")))
22218 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
22219 a use of `auto'. Returns NULL_TREE otherwise. */
22222 type_uses_auto (tree type)
22224 return find_type_usage (type, is_auto);
22227 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto',
22228 'decltype(auto)' or a concept. */
22231 is_auto_or_concept (const_tree type)
22233 return is_auto (type); // or concept
22236 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing a generic type (`auto' or
22237 a concept identifier) iff TYPE contains a use of a generic type. Returns
22238 NULL_TREE otherwise. */
22241 type_uses_auto_or_concept (tree type)
22243 return find_type_usage (type, is_auto_or_concept);
22247 /* For a given template T, return the vector of typedefs referenced
22248 in T for which access check is needed at T instantiation time.
22249 T is either a FUNCTION_DECL or a RECORD_TYPE.
22250 Those typedefs were added to T by the function
22251 append_type_to_template_for_access_check. */
22253 vec<qualified_typedef_usage_t, va_gc> *
22254 get_types_needing_access_check (tree t)
22257 vec<qualified_typedef_usage_t, va_gc> *result = NULL;
22259 if (!t || t == error_mark_node)
22262 if (!(ti = get_template_info (t)))
22265 if (CLASS_TYPE_P (t)
22266 || TREE_CODE (t) == FUNCTION_DECL)
22268 if (!TI_TEMPLATE (ti))
22271 result = TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti);
22277 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
22278 tied to T. That list of typedefs will be access checked at
22279 T instantiation time.
22280 T is either a FUNCTION_DECL or a RECORD_TYPE.
22281 TYPE_DECL is a TYPE_DECL node representing a typedef.
22282 SCOPE is the scope through which TYPE_DECL is accessed.
22283 LOCATION is the location of the usage point of TYPE_DECL.
22285 This function is a subroutine of
22286 append_type_to_template_for_access_check. */
22289 append_type_to_template_for_access_check_1 (tree t,
22292 location_t location)
22294 qualified_typedef_usage_t typedef_usage;
22297 if (!t || t == error_mark_node)
22300 gcc_assert ((TREE_CODE (t) == FUNCTION_DECL
22301 || CLASS_TYPE_P (t))
22303 && TREE_CODE (type_decl) == TYPE_DECL
22306 if (!(ti = get_template_info (t)))
22309 gcc_assert (TI_TEMPLATE (ti));
22311 typedef_usage.typedef_decl = type_decl;
22312 typedef_usage.context = scope;
22313 typedef_usage.locus = location;
22315 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti), typedef_usage);
22318 /* Append TYPE_DECL to the template TEMPL.
22319 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
22320 At TEMPL instanciation time, TYPE_DECL will be checked to see
22321 if it can be accessed through SCOPE.
22322 LOCATION is the location of the usage point of TYPE_DECL.
22324 e.g. consider the following code snippet:
22331 template<class U> struct S
22333 C::myint mi; // <-- usage point of the typedef C::myint
22338 At S<char> instantiation time, we need to check the access of C::myint
22339 In other words, we need to check the access of the myint typedef through
22340 the C scope. For that purpose, this function will add the myint typedef
22341 and the scope C through which its being accessed to a list of typedefs
22342 tied to the template S. That list will be walked at template instantiation
22343 time and access check performed on each typedefs it contains.
22344 Note that this particular code snippet should yield an error because
22345 myint is private to C. */
22348 append_type_to_template_for_access_check (tree templ,
22351 location_t location)
22353 qualified_typedef_usage_t *iter;
22356 gcc_assert (type_decl && (TREE_CODE (type_decl) == TYPE_DECL));
22358 /* Make sure we don't append the type to the template twice. */
22359 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ), i, iter)
22360 if (iter->typedef_decl == type_decl && scope == iter->context)
22363 append_type_to_template_for_access_check_1 (templ, type_decl,
22367 /* Convert the generic type parameters in PARM that match the types given in the
22368 range [START_IDX, END_IDX) from the current_template_parms into generic type
22372 convert_generic_types_to_packs (tree parm, int start_idx, int end_idx)
22374 tree current = current_template_parms;
22375 int depth = TMPL_PARMS_DEPTH (current);
22376 current = INNERMOST_TEMPLATE_PARMS (current);
22377 tree replacement = make_tree_vec (TREE_VEC_LENGTH (current));
22379 for (int i = 0; i < start_idx; ++i)
22380 TREE_VEC_ELT (replacement, i)
22381 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current, i)));
22383 for (int i = start_idx; i < end_idx; ++i)
22385 /* Create a distinct parameter pack type from the current parm and add it
22386 to the replacement args to tsubst below into the generic function
22389 tree o = TREE_TYPE (TREE_VALUE
22390 (TREE_VEC_ELT (current, i)));
22391 tree t = copy_type (o);
22392 TEMPLATE_TYPE_PARM_INDEX (t)
22393 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o),
22395 TREE_TYPE (TEMPLATE_TYPE_DECL (t)) = t;
22396 TYPE_STUB_DECL (t) = TYPE_NAME (t) = TEMPLATE_TYPE_DECL (t);
22397 TYPE_MAIN_VARIANT (t) = t;
22398 TEMPLATE_TYPE_PARAMETER_PACK (t) = true;
22399 TYPE_CANONICAL (t) = canonical_type_parameter (t);
22400 TREE_VEC_ELT (replacement, i) = t;
22401 TREE_VALUE (TREE_VEC_ELT (current, i)) = TREE_CHAIN (t);
22404 for (int i = end_idx, e = TREE_VEC_LENGTH (current); i < e; ++i)
22405 TREE_VEC_ELT (replacement, i)
22406 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current, i)));
22408 /* If there are more levels then build up the replacement with the outer
22411 replacement = add_to_template_args (template_parms_to_args
22412 (TREE_CHAIN (current_template_parms)),
22415 return tsubst (parm, replacement, tf_none, NULL_TREE);
22419 /* Set up the hash tables for template instantiations. */
22422 init_template_processing (void)
22424 decl_specializations = hash_table<spec_hasher>::create_ggc (37);
22425 type_specializations = hash_table<spec_hasher>::create_ggc (37);
22428 /* Print stats about the template hash tables for -fstats. */
22431 print_template_statistics (void)
22433 fprintf (stderr, "decl_specializations: size %ld, %ld elements, "
22434 "%f collisions\n", (long) decl_specializations->size (),
22435 (long) decl_specializations->elements (),
22436 decl_specializations->collisions ());
22437 fprintf (stderr, "type_specializations: size %ld, %ld elements, "
22438 "%f collisions\n", (long) type_specializations->size (),
22439 (long) type_specializations->elements (),
22440 type_specializations->collisions ());
22443 #include "gt-cp-pt.h"