1 /* Handle parameterized types (templates) for GNU C++.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
5 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
6 Rewritten by Jason Merrill (jason@cygnus.com).
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
15 GCC is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
24 /* Known bugs or deficiencies include:
26 all methods must be provided in header files; can't use a source
27 file that contains only the method templates and "just win". */
31 #include "coretypes.h"
35 #include "pointer-set.h"
38 #include "c-family/c-common.h"
39 #include "cp-objcp-common.h"
40 #include "tree-inline.h"
45 #include "tree-iterator.h"
48 /* The type of functions taking a tree, and some additional data, and
50 typedef int (*tree_fn_t) (tree, void*);
52 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
53 instantiations have been deferred, either because their definitions
54 were not yet available, or because we were putting off doing the work. */
55 struct GTY (()) pending_template {
56 struct pending_template *next;
57 struct tinst_level *tinst;
60 static GTY(()) struct pending_template *pending_templates;
61 static GTY(()) struct pending_template *last_pending_template;
63 int processing_template_parmlist;
64 static int template_header_count;
66 static GTY(()) tree saved_trees;
67 static VEC(int,heap) *inline_parm_levels;
69 static GTY(()) struct tinst_level *current_tinst_level;
71 static GTY(()) tree saved_access_scope;
73 /* Live only within one (recursive) call to tsubst_expr. We use
74 this to pass the statement expression node from the STMT_EXPR
75 to the EXPR_STMT that is its result. */
76 static tree cur_stmt_expr;
78 /* A map from local variable declarations in the body of the template
79 presently being instantiated to the corresponding instantiated
81 static htab_t local_specializations;
83 typedef struct GTY(()) spec_entry
90 static GTY ((param_is (spec_entry)))
91 htab_t decl_specializations;
93 static GTY ((param_is (spec_entry)))
94 htab_t type_specializations;
96 /* Contains canonical template parameter types. The vector is indexed by
97 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
98 TREE_LIST, whose TREE_VALUEs contain the canonical template
99 parameters of various types and levels. */
100 static GTY(()) VEC(tree,gc) *canonical_template_parms;
102 #define UNIFY_ALLOW_NONE 0
103 #define UNIFY_ALLOW_MORE_CV_QUAL 1
104 #define UNIFY_ALLOW_LESS_CV_QUAL 2
105 #define UNIFY_ALLOW_DERIVED 4
106 #define UNIFY_ALLOW_INTEGER 8
107 #define UNIFY_ALLOW_OUTER_LEVEL 16
108 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
109 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
111 static void push_access_scope (tree);
112 static void pop_access_scope (tree);
113 static bool resolve_overloaded_unification (tree, tree, tree, tree,
114 unification_kind_t, int);
115 static int try_one_overload (tree, tree, tree, tree, tree,
116 unification_kind_t, int, bool);
117 static int unify (tree, tree, tree, tree, int);
118 static void add_pending_template (tree);
119 static tree reopen_tinst_level (struct tinst_level *);
120 static tree tsubst_initializer_list (tree, tree);
121 static tree get_class_bindings (tree, tree, tree);
122 static tree coerce_template_parms (tree, tree, tree, tsubst_flags_t,
124 static void tsubst_enum (tree, tree, tree);
125 static tree add_to_template_args (tree, tree);
126 static tree add_outermost_template_args (tree, tree);
127 static bool check_instantiated_args (tree, tree, tsubst_flags_t);
128 static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*,
130 static int type_unification_real (tree, tree, tree, const tree *,
131 unsigned int, int, unification_kind_t, int);
132 static void note_template_header (int);
133 static tree convert_nontype_argument_function (tree, tree);
134 static tree convert_nontype_argument (tree, tree);
135 static tree convert_template_argument (tree, tree, tree,
136 tsubst_flags_t, int, tree);
137 static int for_each_template_parm (tree, tree_fn_t, void*,
138 struct pointer_set_t*, bool);
139 static tree expand_template_argument_pack (tree);
140 static tree build_template_parm_index (int, int, int, tree, tree);
141 static bool inline_needs_template_parms (tree);
142 static void push_inline_template_parms_recursive (tree, int);
143 static tree retrieve_local_specialization (tree);
144 static void register_local_specialization (tree, tree);
145 static hashval_t hash_specialization (const void *p);
146 static tree reduce_template_parm_level (tree, tree, int, tree, tsubst_flags_t);
147 static int mark_template_parm (tree, void *);
148 static int template_parm_this_level_p (tree, void *);
149 static tree tsubst_friend_function (tree, tree);
150 static tree tsubst_friend_class (tree, tree);
151 static int can_complete_type_without_circularity (tree);
152 static tree get_bindings (tree, tree, tree, bool);
153 static int template_decl_level (tree);
154 static int check_cv_quals_for_unify (int, tree, tree);
155 static void template_parm_level_and_index (tree, int*, int*);
156 static int unify_pack_expansion (tree, tree, tree, tree, int, bool, bool);
157 static tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree);
158 static tree tsubst_template_args (tree, tree, tsubst_flags_t, tree);
159 static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
160 static void regenerate_decl_from_template (tree, tree);
161 static tree most_specialized_class (tree, tree, tsubst_flags_t);
162 static tree tsubst_aggr_type (tree, tree, tsubst_flags_t, tree, int);
163 static tree tsubst_arg_types (tree, tree, tsubst_flags_t, tree);
164 static tree tsubst_function_type (tree, tree, tsubst_flags_t, tree);
165 static bool check_specialization_scope (void);
166 static tree process_partial_specialization (tree);
167 static void set_current_access_from_decl (tree);
168 static tree get_template_base (tree, tree, tree, tree);
169 static tree try_class_unification (tree, tree, tree, tree);
170 static int coerce_template_template_parms (tree, tree, tsubst_flags_t,
172 static bool template_template_parm_bindings_ok_p (tree, tree);
173 static int template_args_equal (tree, tree);
174 static void tsubst_default_arguments (tree);
175 static tree for_each_template_parm_r (tree *, int *, void *);
176 static tree copy_default_args_to_explicit_spec_1 (tree, tree);
177 static void copy_default_args_to_explicit_spec (tree);
178 static int invalid_nontype_parm_type_p (tree, tsubst_flags_t);
179 static int eq_local_specializations (const void *, const void *);
180 static bool dependent_template_arg_p (tree);
181 static bool any_template_arguments_need_structural_equality_p (tree);
182 static bool dependent_type_p_r (tree);
183 static tree tsubst_expr (tree, tree, tsubst_flags_t, tree, bool);
184 static tree tsubst_copy (tree, tree, tsubst_flags_t, tree);
185 static tree tsubst_pack_expansion (tree, tree, tsubst_flags_t, tree);
186 static tree tsubst_decl (tree, tree, tsubst_flags_t);
187 static void perform_typedefs_access_check (tree tmpl, tree targs);
188 static void append_type_to_template_for_access_check_1 (tree, tree, tree,
190 static hashval_t iterative_hash_template_arg (tree arg, hashval_t val);
191 static tree listify (tree);
192 static tree listify_autos (tree, tree);
194 /* Make the current scope suitable for access checking when we are
195 processing T. T can be FUNCTION_DECL for instantiated function
196 template, or VAR_DECL for static member variable (need by
197 instantiate_decl). */
200 push_access_scope (tree t)
202 gcc_assert (TREE_CODE (t) == FUNCTION_DECL
203 || TREE_CODE (t) == VAR_DECL);
205 if (DECL_FRIEND_CONTEXT (t))
206 push_nested_class (DECL_FRIEND_CONTEXT (t));
207 else if (DECL_CLASS_SCOPE_P (t))
208 push_nested_class (DECL_CONTEXT (t));
210 push_to_top_level ();
212 if (TREE_CODE (t) == FUNCTION_DECL)
214 saved_access_scope = tree_cons
215 (NULL_TREE, current_function_decl, saved_access_scope);
216 current_function_decl = t;
220 /* Restore the scope set up by push_access_scope. T is the node we
224 pop_access_scope (tree t)
226 if (TREE_CODE (t) == FUNCTION_DECL)
228 current_function_decl = TREE_VALUE (saved_access_scope);
229 saved_access_scope = TREE_CHAIN (saved_access_scope);
232 if (DECL_FRIEND_CONTEXT (t) || DECL_CLASS_SCOPE_P (t))
235 pop_from_top_level ();
238 /* Do any processing required when DECL (a member template
239 declaration) is finished. Returns the TEMPLATE_DECL corresponding
240 to DECL, unless it is a specialization, in which case the DECL
241 itself is returned. */
244 finish_member_template_decl (tree decl)
246 if (decl == error_mark_node)
247 return error_mark_node;
249 gcc_assert (DECL_P (decl));
251 if (TREE_CODE (decl) == TYPE_DECL)
255 type = TREE_TYPE (decl);
256 if (type == error_mark_node)
257 return error_mark_node;
258 if (MAYBE_CLASS_TYPE_P (type)
259 && CLASSTYPE_TEMPLATE_INFO (type)
260 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
262 tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
263 check_member_template (tmpl);
268 else if (TREE_CODE (decl) == FIELD_DECL)
269 error ("data member %qD cannot be a member template", decl);
270 else if (DECL_TEMPLATE_INFO (decl))
272 if (!DECL_TEMPLATE_SPECIALIZATION (decl))
274 check_member_template (DECL_TI_TEMPLATE (decl));
275 return DECL_TI_TEMPLATE (decl);
281 error ("invalid member template declaration %qD", decl);
283 return error_mark_node;
286 /* Create a template info node. */
289 build_template_info (tree template_decl, tree template_args)
291 tree result = make_node (TEMPLATE_INFO);
292 TI_TEMPLATE (result) = template_decl;
293 TI_ARGS (result) = template_args;
297 /* Return the template info node corresponding to T, whatever T is. */
300 get_template_info (const_tree t)
302 tree tinfo = NULL_TREE;
304 if (!t || t == error_mark_node)
307 if (DECL_P (t) && DECL_LANG_SPECIFIC (t))
308 tinfo = DECL_TEMPLATE_INFO (t);
310 if (!tinfo && DECL_IMPLICIT_TYPEDEF_P (t))
313 if (TAGGED_TYPE_P (t))
314 tinfo = TYPE_TEMPLATE_INFO (t);
315 else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
316 tinfo = TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t);
321 /* Returns the template nesting level of the indicated class TYPE.
331 A<T>::B<U> has depth two, while A<T> has depth one.
332 Both A<T>::B<int> and A<int>::B<U> have depth one, if
333 they are instantiations, not specializations.
335 This function is guaranteed to return 0 if passed NULL_TREE so
336 that, for example, `template_class_depth (current_class_type)' is
340 template_class_depth (tree type)
345 type && TREE_CODE (type) != NAMESPACE_DECL;
346 type = (TREE_CODE (type) == FUNCTION_DECL)
347 ? CP_DECL_CONTEXT (type) : TYPE_CONTEXT (type))
349 tree tinfo = get_template_info (type);
351 if (tinfo && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo))
352 && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo))))
359 /* Subroutine of maybe_begin_member_template_processing.
360 Returns true if processing DECL needs us to push template parms. */
363 inline_needs_template_parms (tree decl)
365 if (! DECL_TEMPLATE_INFO (decl))
368 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl)))
369 > (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl)));
372 /* Subroutine of maybe_begin_member_template_processing.
373 Push the template parms in PARMS, starting from LEVELS steps into the
374 chain, and ending at the beginning, since template parms are listed
378 push_inline_template_parms_recursive (tree parmlist, int levels)
380 tree parms = TREE_VALUE (parmlist);
384 push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1);
386 ++processing_template_decl;
387 current_template_parms
388 = tree_cons (size_int (processing_template_decl),
389 parms, current_template_parms);
390 TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1;
392 begin_scope (TREE_VEC_LENGTH (parms) ? sk_template_parms : sk_template_spec,
394 for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
396 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
398 if (parm == error_mark_node)
401 gcc_assert (DECL_P (parm));
403 switch (TREE_CODE (parm))
412 /* Make a CONST_DECL as is done in process_template_parm.
413 It is ugly that we recreate this here; the original
414 version built in process_template_parm is no longer
416 tree decl = build_decl (DECL_SOURCE_LOCATION (parm),
417 CONST_DECL, DECL_NAME (parm),
419 DECL_ARTIFICIAL (decl) = 1;
420 TREE_CONSTANT (decl) = 1;
421 TREE_READONLY (decl) = 1;
422 DECL_INITIAL (decl) = DECL_INITIAL (parm);
423 SET_DECL_TEMPLATE_PARM_P (decl);
434 /* Restore the template parameter context for a member template or
435 a friend template defined in a class definition. */
438 maybe_begin_member_template_processing (tree decl)
443 if (inline_needs_template_parms (decl))
445 parms = DECL_TEMPLATE_PARMS (most_general_template (decl));
446 levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl;
448 if (DECL_TEMPLATE_SPECIALIZATION (decl))
451 parms = TREE_CHAIN (parms);
454 push_inline_template_parms_recursive (parms, levels);
457 /* Remember how many levels of template parameters we pushed so that
458 we can pop them later. */
459 VEC_safe_push (int, heap, inline_parm_levels, levels);
462 /* Undo the effects of maybe_begin_member_template_processing. */
465 maybe_end_member_template_processing (void)
470 if (VEC_length (int, inline_parm_levels) == 0)
473 last = VEC_pop (int, inline_parm_levels);
474 for (i = 0; i < last; ++i)
476 --processing_template_decl;
477 current_template_parms = TREE_CHAIN (current_template_parms);
482 /* Return a new template argument vector which contains all of ARGS,
483 but has as its innermost set of arguments the EXTRA_ARGS. */
486 add_to_template_args (tree args, tree extra_args)
493 if (args == NULL_TREE)
496 extra_depth = TMPL_ARGS_DEPTH (extra_args);
497 new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth);
499 for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i)
500 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));
502 for (j = 1; j <= extra_depth; ++j, ++i)
503 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));
508 /* Like add_to_template_args, but only the outermost ARGS are added to
509 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
510 (EXTRA_ARGS) levels are added. This function is used to combine
511 the template arguments from a partial instantiation with the
512 template arguments used to attain the full instantiation from the
513 partial instantiation. */
516 add_outermost_template_args (tree args, tree extra_args)
520 /* If there are more levels of EXTRA_ARGS than there are ARGS,
521 something very fishy is going on. */
522 gcc_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args));
524 /* If *all* the new arguments will be the EXTRA_ARGS, just return
526 if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
529 /* For the moment, we make ARGS look like it contains fewer levels. */
530 TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);
532 new_args = add_to_template_args (args, extra_args);
534 /* Now, we restore ARGS to its full dimensions. */
535 TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);
540 /* Return the N levels of innermost template arguments from the ARGS. */
543 get_innermost_template_args (tree args, int n)
551 /* If N is 1, just return the innermost set of template arguments. */
553 return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args));
555 /* If we're not removing anything, just return the arguments we were
557 extra_levels = TMPL_ARGS_DEPTH (args) - n;
558 gcc_assert (extra_levels >= 0);
559 if (extra_levels == 0)
562 /* Make a new set of arguments, not containing the outer arguments. */
563 new_args = make_tree_vec (n);
564 for (i = 1; i <= n; ++i)
565 SET_TMPL_ARGS_LEVEL (new_args, i,
566 TMPL_ARGS_LEVEL (args, i + extra_levels));
571 /* The inverse of get_innermost_template_args: Return all but the innermost
572 EXTRA_LEVELS levels of template arguments from the ARGS. */
575 strip_innermost_template_args (tree args, int extra_levels)
578 int n = TMPL_ARGS_DEPTH (args) - extra_levels;
583 /* If N is 1, just return the outermost set of template arguments. */
585 return TMPL_ARGS_LEVEL (args, 1);
587 /* If we're not removing anything, just return the arguments we were
589 gcc_assert (extra_levels >= 0);
590 if (extra_levels == 0)
593 /* Make a new set of arguments, not containing the inner arguments. */
594 new_args = make_tree_vec (n);
595 for (i = 1; i <= n; ++i)
596 SET_TMPL_ARGS_LEVEL (new_args, i,
597 TMPL_ARGS_LEVEL (args, i));
602 /* We've got a template header coming up; push to a new level for storing
606 begin_template_parm_list (void)
608 /* We use a non-tag-transparent scope here, which causes pushtag to
609 put tags in this scope, rather than in the enclosing class or
610 namespace scope. This is the right thing, since we want
611 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
612 global template class, push_template_decl handles putting the
613 TEMPLATE_DECL into top-level scope. For a nested template class,
616 template <class T> struct S1 {
617 template <class T> struct S2 {};
620 pushtag contains special code to call pushdecl_with_scope on the
621 TEMPLATE_DECL for S2. */
622 begin_scope (sk_template_parms, NULL);
623 ++processing_template_decl;
624 ++processing_template_parmlist;
625 note_template_header (0);
628 /* This routine is called when a specialization is declared. If it is
629 invalid to declare a specialization here, an error is reported and
630 false is returned, otherwise this routine will return true. */
633 check_specialization_scope (void)
635 tree scope = current_scope ();
639 An explicit specialization shall be declared in the namespace of
640 which the template is a member, or, for member templates, in the
641 namespace of which the enclosing class or enclosing class
642 template is a member. An explicit specialization of a member
643 function, member class or static data member of a class template
644 shall be declared in the namespace of which the class template
646 if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
648 error ("explicit specialization in non-namespace scope %qD", scope);
654 In an explicit specialization declaration for a member of a class
655 template or a member template that appears in namespace scope,
656 the member template and some of its enclosing class templates may
657 remain unspecialized, except that the declaration shall not
658 explicitly specialize a class member template if its enclosing
659 class templates are not explicitly specialized as well. */
660 if (current_template_parms)
662 error ("enclosing class templates are not explicitly specialized");
669 /* We've just seen template <>. */
672 begin_specialization (void)
674 begin_scope (sk_template_spec, NULL);
675 note_template_header (1);
676 return check_specialization_scope ();
679 /* Called at then end of processing a declaration preceded by
683 end_specialization (void)
686 reset_specialization ();
689 /* Any template <>'s that we have seen thus far are not referring to a
690 function specialization. */
693 reset_specialization (void)
695 processing_specialization = 0;
696 template_header_count = 0;
699 /* We've just seen a template header. If SPECIALIZATION is nonzero,
700 it was of the form template <>. */
703 note_template_header (int specialization)
705 processing_specialization = specialization;
706 template_header_count++;
709 /* We're beginning an explicit instantiation. */
712 begin_explicit_instantiation (void)
714 gcc_assert (!processing_explicit_instantiation);
715 processing_explicit_instantiation = true;
720 end_explicit_instantiation (void)
722 gcc_assert (processing_explicit_instantiation);
723 processing_explicit_instantiation = false;
726 /* An explicit specialization or partial specialization TMPL is being
727 declared. Check that the namespace in which the specialization is
728 occurring is permissible. Returns false iff it is invalid to
729 specialize TMPL in the current namespace. */
732 check_specialization_namespace (tree tmpl)
734 tree tpl_ns = decl_namespace_context (tmpl);
738 An explicit specialization shall be declared in the namespace of
739 which the template is a member, or, for member templates, in the
740 namespace of which the enclosing class or enclosing class
741 template is a member. An explicit specialization of a member
742 function, member class or static data member of a class template
743 shall be declared in the namespace of which the class template is
745 if (current_scope() != DECL_CONTEXT (tmpl)
746 && !at_namespace_scope_p ())
748 error ("specialization of %qD must appear at namespace scope", tmpl);
751 if (is_associated_namespace (current_namespace, tpl_ns))
752 /* Same or super-using namespace. */
756 permerror (input_location, "specialization of %qD in different namespace", tmpl);
757 permerror (input_location, " from definition of %q+#D", tmpl);
762 /* SPEC is an explicit instantiation. Check that it is valid to
763 perform this explicit instantiation in the current namespace. */
766 check_explicit_instantiation_namespace (tree spec)
770 /* DR 275: An explicit instantiation shall appear in an enclosing
771 namespace of its template. */
772 ns = decl_namespace_context (spec);
773 if (!is_ancestor (current_namespace, ns))
774 permerror (input_location, "explicit instantiation of %qD in namespace %qD "
775 "(which does not enclose namespace %qD)",
776 spec, current_namespace, ns);
779 /* The TYPE is being declared. If it is a template type, that means it
780 is a partial specialization. Do appropriate error-checking. */
783 maybe_process_partial_specialization (tree type)
787 if (type == error_mark_node)
788 return error_mark_node;
790 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
792 error ("name of class shadows template template parameter %qD",
794 return error_mark_node;
797 context = TYPE_CONTEXT (type);
799 if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type))
801 /* This is for ordinary explicit specialization and partial
802 specialization of a template class such as:
804 template <> class C<int>;
808 template <class T> class C<T*>;
810 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
812 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
813 && !COMPLETE_TYPE_P (type))
815 check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type));
816 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
817 if (processing_template_decl)
819 if (push_template_decl (TYPE_MAIN_DECL (type))
821 return error_mark_node;
824 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
825 error ("specialization of %qT after instantiation", type);
827 else if (CLASS_TYPE_P (type)
828 && !CLASSTYPE_USE_TEMPLATE (type)
829 && CLASSTYPE_TEMPLATE_INFO (type)
830 && context && CLASS_TYPE_P (context)
831 && CLASSTYPE_TEMPLATE_INFO (context))
833 /* This is for an explicit specialization of member class
834 template according to [temp.expl.spec/18]:
836 template <> template <class U> class C<int>::D;
838 The context `C<int>' must be an implicit instantiation.
839 Otherwise this is just a member class template declared
842 template <> class C<int> { template <class U> class D; };
843 template <> template <class U> class C<int>::D;
845 In the first case, `C<int>::D' is a specialization of `C<T>::D'
846 while in the second case, `C<int>::D' is a primary template
847 and `C<T>::D' may not exist. */
849 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context)
850 && !COMPLETE_TYPE_P (type))
853 tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
855 if (current_namespace
856 != decl_namespace_context (tmpl))
858 permerror (input_location, "specializing %q#T in different namespace", type);
859 permerror (input_location, " from definition of %q+#D", tmpl);
862 /* Check for invalid specialization after instantiation:
864 template <> template <> class C<int>::D<int>;
865 template <> template <class U> class C<int>::D; */
867 for (t = DECL_TEMPLATE_INSTANTIATIONS (tmpl);
868 t; t = TREE_CHAIN (t))
870 tree inst = TREE_VALUE (t);
871 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst))
873 /* We already have a full specialization of this partial
874 instantiation. Reassign it to the new member
875 specialization template. */
879 elt.tmpl = most_general_template (tmpl);
880 elt.args = CLASSTYPE_TI_ARGS (inst);
883 htab_remove_elt (type_specializations, &elt);
886 elt.args = INNERMOST_TEMPLATE_ARGS (elt.args);
888 slot = (spec_entry **)
889 htab_find_slot (type_specializations, &elt, INSERT);
890 *slot = ggc_alloc_spec_entry ();
893 else if (COMPLETE_OR_OPEN_TYPE_P (inst))
894 /* But if we've had an implicit instantiation, that's a
895 problem ([temp.expl.spec]/6). */
896 error ("specialization %qT after instantiation %qT",
900 /* Mark TYPE as a specialization. And as a result, we only
901 have one level of template argument for the innermost
903 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
904 CLASSTYPE_TI_ARGS (type)
905 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
908 else if (processing_specialization)
910 error ("explicit specialization of non-template %qT", type);
911 return error_mark_node;
917 /* Returns nonzero if we can optimize the retrieval of specializations
918 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
919 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
922 optimize_specialization_lookup_p (tree tmpl)
924 return (DECL_FUNCTION_TEMPLATE_P (tmpl)
925 && DECL_CLASS_SCOPE_P (tmpl)
926 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
928 && CLASS_TYPE_P (DECL_CONTEXT (tmpl))
929 /* The optimized lookup depends on the fact that the
930 template arguments for the member function template apply
931 purely to the containing class, which is not true if the
932 containing class is an explicit or partial
934 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl))
935 && !DECL_MEMBER_TEMPLATE_P (tmpl)
936 && !DECL_CONV_FN_P (tmpl)
937 /* It is possible to have a template that is not a member
938 template and is not a member of a template class:
940 template <typename T>
941 struct S { friend A::f(); };
943 Here, the friend function is a template, but the context does
944 not have template information. The optimized lookup relies
945 on having ARGS be the template arguments for both the class
946 and the function template. */
947 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl)));
950 /* Retrieve the specialization (in the sense of [temp.spec] - a
951 specialization is either an instantiation or an explicit
952 specialization) of TMPL for the given template ARGS. If there is
953 no such specialization, return NULL_TREE. The ARGS are a vector of
954 arguments, or a vector of vectors of arguments, in the case of
955 templates with more than one level of parameters.
957 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
958 then we search for a partial specialization matching ARGS. This
959 parameter is ignored if TMPL is not a class template. */
962 retrieve_specialization (tree tmpl, tree args, hashval_t hash)
964 if (args == error_mark_node)
967 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
969 /* There should be as many levels of arguments as there are
970 levels of parameters. */
971 gcc_assert (TMPL_ARGS_DEPTH (args)
972 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)));
974 if (optimize_specialization_lookup_p (tmpl))
977 tree class_specialization;
978 VEC(tree,gc) *methods;
982 /* The template arguments actually apply to the containing
983 class. Find the class specialization with those
985 class_template = CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl));
987 = retrieve_specialization (class_template, args, 0);
988 if (!class_specialization)
990 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
991 for the specialization. */
992 idx = class_method_index_for_fn (class_specialization, tmpl);
995 /* Iterate through the methods with the indicated name, looking
996 for the one that has an instance of TMPL. */
997 methods = CLASSTYPE_METHOD_VEC (class_specialization);
998 for (fns = VEC_index (tree, methods, idx); fns; fns = OVL_NEXT (fns))
1000 tree fn = OVL_CURRENT (fns);
1001 if (DECL_TEMPLATE_INFO (fn) && DECL_TI_TEMPLATE (fn) == tmpl
1002 /* using-declarations can add base methods to the method vec,
1003 and we don't want those here. */
1004 && DECL_CONTEXT (fn) == class_specialization)
1013 htab_t specializations;
1017 elt.spec = NULL_TREE;
1019 if (DECL_CLASS_TEMPLATE_P (tmpl))
1020 specializations = type_specializations;
1022 specializations = decl_specializations;
1025 hash = hash_specialization (&elt);
1026 found = (spec_entry *) htab_find_with_hash (specializations, &elt, hash);
1034 /* Like retrieve_specialization, but for local declarations. */
1037 retrieve_local_specialization (tree tmpl)
1041 if (local_specializations == NULL)
1044 spec = (tree) htab_find_with_hash (local_specializations, tmpl,
1045 htab_hash_pointer (tmpl));
1046 return spec ? TREE_PURPOSE (spec) : NULL_TREE;
1049 /* Returns nonzero iff DECL is a specialization of TMPL. */
1052 is_specialization_of (tree decl, tree tmpl)
1056 if (TREE_CODE (decl) == FUNCTION_DECL)
1060 t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
1066 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
1068 for (t = TREE_TYPE (decl);
1070 t = CLASSTYPE_USE_TEMPLATE (t)
1071 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
1072 if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl)))
1079 /* Returns nonzero iff DECL is a specialization of friend declaration
1080 FRIEND_DECL according to [temp.friend]. */
1083 is_specialization_of_friend (tree decl, tree friend_decl)
1085 bool need_template = true;
1088 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
1089 || TREE_CODE (decl) == TYPE_DECL);
1091 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1092 of a template class, we want to check if DECL is a specialization
1094 if (TREE_CODE (friend_decl) == FUNCTION_DECL
1095 && DECL_TEMPLATE_INFO (friend_decl)
1096 && !DECL_USE_TEMPLATE (friend_decl))
1098 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1099 friend_decl = DECL_TI_TEMPLATE (friend_decl);
1100 need_template = false;
1102 else if (TREE_CODE (friend_decl) == TEMPLATE_DECL
1103 && !PRIMARY_TEMPLATE_P (friend_decl))
1104 need_template = false;
1106 /* There is nothing to do if this is not a template friend. */
1107 if (TREE_CODE (friend_decl) != TEMPLATE_DECL)
1110 if (is_specialization_of (decl, friend_decl))
1114 A member of a class template may be declared to be a friend of a
1115 non-template class. In this case, the corresponding member of
1116 every specialization of the class template is a friend of the
1117 class granting friendship.
1119 For example, given a template friend declaration
1121 template <class T> friend void A<T>::f();
1123 the member function below is considered a friend
1125 template <> struct A<int> {
1129 For this type of template friend, TEMPLATE_DEPTH below will be
1130 nonzero. To determine if DECL is a friend of FRIEND, we first
1131 check if the enclosing class is a specialization of another. */
1133 template_depth = template_class_depth (DECL_CONTEXT (friend_decl));
1135 && DECL_CLASS_SCOPE_P (decl)
1136 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)),
1137 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl))))
1139 /* Next, we check the members themselves. In order to handle
1140 a few tricky cases, such as when FRIEND_DECL's are
1142 template <class T> friend void A<T>::g(T t);
1143 template <class T> template <T t> friend void A<T>::h();
1147 void A<int>::g(int);
1148 template <int> void A<int>::h();
1150 we need to figure out ARGS, the template arguments from
1151 the context of DECL. This is required for template substitution
1152 of `T' in the function parameter of `g' and template parameter
1153 of `h' in the above examples. Here ARGS corresponds to `int'. */
1155 tree context = DECL_CONTEXT (decl);
1156 tree args = NULL_TREE;
1157 int current_depth = 0;
1159 while (current_depth < template_depth)
1161 if (CLASSTYPE_TEMPLATE_INFO (context))
1163 if (current_depth == 0)
1164 args = TYPE_TI_ARGS (context);
1166 args = add_to_template_args (TYPE_TI_ARGS (context), args);
1169 context = TYPE_CONTEXT (context);
1172 if (TREE_CODE (decl) == FUNCTION_DECL)
1177 tree friend_args_type;
1178 tree decl_args_type;
1180 /* Make sure that both DECL and FRIEND_DECL are templates or
1182 is_template = DECL_TEMPLATE_INFO (decl)
1183 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl));
1184 if (need_template ^ is_template)
1186 else if (is_template)
1188 /* If both are templates, check template parameter list. */
1190 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl),
1192 if (!comp_template_parms
1193 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)),
1197 decl_type = TREE_TYPE (DECL_TI_TEMPLATE (decl));
1200 decl_type = TREE_TYPE (decl);
1202 friend_type = tsubst_function_type (TREE_TYPE (friend_decl), args,
1203 tf_none, NULL_TREE);
1204 if (friend_type == error_mark_node)
1207 /* Check if return types match. */
1208 if (!same_type_p (TREE_TYPE (decl_type), TREE_TYPE (friend_type)))
1211 /* Check if function parameter types match, ignoring the
1212 `this' parameter. */
1213 friend_args_type = TYPE_ARG_TYPES (friend_type);
1214 decl_args_type = TYPE_ARG_TYPES (decl_type);
1215 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl))
1216 friend_args_type = TREE_CHAIN (friend_args_type);
1217 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1218 decl_args_type = TREE_CHAIN (decl_args_type);
1220 return compparms (decl_args_type, friend_args_type);
1224 /* DECL is a TYPE_DECL */
1226 tree decl_type = TREE_TYPE (decl);
1228 /* Make sure that both DECL and FRIEND_DECL are templates or
1231 = CLASSTYPE_TEMPLATE_INFO (decl_type)
1232 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type));
1234 if (need_template ^ is_template)
1236 else if (is_template)
1239 /* If both are templates, check the name of the two
1240 TEMPLATE_DECL's first because is_friend didn't. */
1241 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type))
1242 != DECL_NAME (friend_decl))
1245 /* Now check template parameter list. */
1247 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl),
1249 return comp_template_parms
1250 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type)),
1254 return (DECL_NAME (decl)
1255 == DECL_NAME (friend_decl));
1261 /* Register the specialization SPEC as a specialization of TMPL with
1262 the indicated ARGS. IS_FRIEND indicates whether the specialization
1263 is actually just a friend declaration. Returns SPEC, or an
1264 equivalent prior declaration, if available. */
1267 register_specialization (tree spec, tree tmpl, tree args, bool is_friend,
1271 spec_entry **slot = NULL;
1274 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL && DECL_P (spec));
1276 if (TREE_CODE (spec) == FUNCTION_DECL
1277 && uses_template_parms (DECL_TI_ARGS (spec)))
1278 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1279 register it; we want the corresponding TEMPLATE_DECL instead.
1280 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1281 the more obvious `uses_template_parms (spec)' to avoid problems
1282 with default function arguments. In particular, given
1283 something like this:
1285 template <class T> void f(T t1, T t = T())
1287 the default argument expression is not substituted for in an
1288 instantiation unless and until it is actually needed. */
1291 if (optimize_specialization_lookup_p (tmpl))
1292 /* We don't put these specializations in the hash table, but we might
1293 want to give an error about a mismatch. */
1294 fn = retrieve_specialization (tmpl, args, 0);
1302 hash = hash_specialization (&elt);
1304 slot = (spec_entry **)
1305 htab_find_slot_with_hash (decl_specializations, &elt, hash, INSERT);
1312 /* We can sometimes try to re-register a specialization that we've
1313 already got. In particular, regenerate_decl_from_template calls
1314 duplicate_decls which will update the specialization list. But,
1315 we'll still get called again here anyhow. It's more convenient
1316 to simply allow this than to try to prevent it. */
1319 else if (fn && DECL_TEMPLATE_SPECIALIZATION (spec))
1321 if (DECL_TEMPLATE_INSTANTIATION (fn))
1323 if (DECL_ODR_USED (fn)
1324 || DECL_EXPLICIT_INSTANTIATION (fn))
1326 error ("specialization of %qD after instantiation",
1328 return error_mark_node;
1333 /* This situation should occur only if the first
1334 specialization is an implicit instantiation, the
1335 second is an explicit specialization, and the
1336 implicit instantiation has not yet been used. That
1337 situation can occur if we have implicitly
1338 instantiated a member function and then specialized
1341 We can also wind up here if a friend declaration that
1342 looked like an instantiation turns out to be a
1345 template <class T> void foo(T);
1346 class S { friend void foo<>(int) };
1347 template <> void foo(int);
1349 We transform the existing DECL in place so that any
1350 pointers to it become pointers to the updated
1353 If there was a definition for the template, but not
1354 for the specialization, we want this to look as if
1355 there were no definition, and vice versa. */
1356 DECL_INITIAL (fn) = NULL_TREE;
1357 duplicate_decls (spec, fn, is_friend);
1358 /* The call to duplicate_decls will have applied
1361 An explicit specialization of a function template
1362 is inline only if it is explicitly declared to be,
1363 and independently of whether its function template
1366 to the primary function; now copy the inline bits to
1367 the various clones. */
1368 FOR_EACH_CLONE (clone, fn)
1370 DECL_DECLARED_INLINE_P (clone)
1371 = DECL_DECLARED_INLINE_P (fn);
1372 DECL_SOURCE_LOCATION (clone)
1373 = DECL_SOURCE_LOCATION (fn);
1375 check_specialization_namespace (fn);
1380 else if (DECL_TEMPLATE_SPECIALIZATION (fn))
1382 if (!duplicate_decls (spec, fn, is_friend) && DECL_INITIAL (spec))
1383 /* Dup decl failed, but this is a new definition. Set the
1384 line number so any errors match this new
1386 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec);
1392 return duplicate_decls (spec, fn, is_friend);
1394 /* A specialization must be declared in the same namespace as the
1395 template it is specializing. */
1396 if (DECL_TEMPLATE_SPECIALIZATION (spec)
1397 && !check_specialization_namespace (tmpl))
1398 DECL_CONTEXT (spec) = DECL_CONTEXT (tmpl);
1400 if (!optimize_specialization_lookup_p (tmpl))
1402 gcc_assert (tmpl && args && spec);
1403 *slot = ggc_alloc_spec_entry ();
1405 if (TREE_CODE (spec) == FUNCTION_DECL && DECL_NAMESPACE_SCOPE_P (spec)
1406 && PRIMARY_TEMPLATE_P (tmpl)
1407 && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl)) == NULL_TREE)
1408 /* TMPL is a forward declaration of a template function; keep a list
1409 of all specializations in case we need to reassign them to a friend
1410 template later in tsubst_friend_function. */
1411 DECL_TEMPLATE_INSTANTIATIONS (tmpl)
1412 = tree_cons (args, spec, DECL_TEMPLATE_INSTANTIATIONS (tmpl));
1418 /* Returns true iff two spec_entry nodes are equivalent. Only compares the
1419 TMPL and ARGS members, ignores SPEC. */
1422 eq_specializations (const void *p1, const void *p2)
1424 const spec_entry *e1 = (const spec_entry *)p1;
1425 const spec_entry *e2 = (const spec_entry *)p2;
1427 return (e1->tmpl == e2->tmpl
1428 && comp_template_args (e1->args, e2->args));
1431 /* Returns a hash for a template TMPL and template arguments ARGS. */
1434 hash_tmpl_and_args (tree tmpl, tree args)
1436 hashval_t val = DECL_UID (tmpl);
1437 return iterative_hash_template_arg (args, val);
1440 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1444 hash_specialization (const void *p)
1446 const spec_entry *e = (const spec_entry *)p;
1447 return hash_tmpl_and_args (e->tmpl, e->args);
1450 /* Recursively calculate a hash value for a template argument ARG, for use
1451 in the hash tables of template specializations. */
1454 iterative_hash_template_arg (tree arg, hashval_t val)
1456 unsigned HOST_WIDE_INT i;
1457 enum tree_code code;
1460 if (arg == NULL_TREE)
1461 return iterative_hash_object (arg, val);
1466 if (TREE_CODE (arg) == ARGUMENT_PACK_SELECT)
1467 /* We can get one of these when re-hashing a previous entry in the middle
1468 of substituting into a pack expansion. Just look through it. */
1469 arg = ARGUMENT_PACK_SELECT_FROM_PACK (arg);
1471 code = TREE_CODE (arg);
1472 tclass = TREE_CODE_CLASS (code);
1474 val = iterative_hash_object (code, val);
1481 case IDENTIFIER_NODE:
1482 return iterative_hash_object (IDENTIFIER_HASH_VALUE (arg), val);
1486 int i, len = TREE_VEC_LENGTH (arg);
1487 for (i = 0; i < len; ++i)
1488 val = iterative_hash_template_arg (TREE_VEC_ELT (arg, i), val);
1492 case TYPE_PACK_EXPANSION:
1493 case EXPR_PACK_EXPANSION:
1494 return iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg), val);
1496 case TYPE_ARGUMENT_PACK:
1497 case NONTYPE_ARGUMENT_PACK:
1498 return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg), val);
1501 for (; arg; arg = TREE_CHAIN (arg))
1502 val = iterative_hash_template_arg (TREE_VALUE (arg), val);
1506 for (; arg; arg = OVL_CHAIN (arg))
1507 val = iterative_hash_template_arg (OVL_FUNCTION (arg), val);
1513 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg), i, field, value)
1515 val = iterative_hash_template_arg (field, val);
1516 val = iterative_hash_template_arg (value, val);
1522 if (!DECL_ARTIFICIAL (arg))
1523 val = iterative_hash_object (DECL_PARM_INDEX (arg), val);
1524 return iterative_hash_template_arg (TREE_TYPE (arg), val);
1527 return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg), val);
1530 val = iterative_hash_template_arg (PTRMEM_CST_CLASS (arg), val);
1531 return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg), val);
1533 case TEMPLATE_PARM_INDEX:
1534 val = iterative_hash_template_arg
1535 (TREE_TYPE (TEMPLATE_PARM_DECL (arg)), val);
1536 val = iterative_hash_object (TEMPLATE_PARM_LEVEL (arg), val);
1537 return iterative_hash_object (TEMPLATE_PARM_IDX (arg), val);
1540 val = iterative_hash_object (TRAIT_EXPR_KIND (arg), val);
1541 val = iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg), val);
1542 return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg), val);
1545 val = iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg)),
1547 return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg)),
1551 val = iterative_hash_template_arg (TREE_OPERAND (arg, 0), val);
1552 code = TREE_CODE (TREE_OPERAND (arg, 1));
1553 val = iterative_hash_object (code, val);
1554 return iterative_hash_template_arg (TREE_OPERAND (arg, 2), val);
1557 /* layout_type sets structural equality for arrays of
1558 incomplete type, so we can't rely on the canonical type
1560 val = iterative_hash_template_arg (TREE_TYPE (arg), val);
1561 return iterative_hash_template_arg (TYPE_DOMAIN (arg), val);
1564 /* A lambda can't appear in a template arg, but don't crash on
1566 gcc_assert (seen_error ());
1570 case STATIC_CAST_EXPR:
1571 case REINTERPRET_CAST_EXPR:
1572 case CONST_CAST_EXPR:
1573 case DYNAMIC_CAST_EXPR:
1575 val = iterative_hash_template_arg (TREE_TYPE (arg), val);
1576 /* Now hash operands as usual. */
1586 if (TYPE_CANONICAL (arg))
1587 return iterative_hash_object (TYPE_HASH (TYPE_CANONICAL (arg)),
1589 else if (TREE_CODE (arg) == DECLTYPE_TYPE)
1590 return iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg), val);
1591 /* Otherwise just compare the types during lookup. */
1594 case tcc_declaration:
1596 return iterative_hash_expr (arg, val);
1599 gcc_assert (IS_EXPR_CODE_CLASS (tclass));
1601 unsigned n = TREE_OPERAND_LENGTH (arg);
1602 for (i = 0; i < n; ++i)
1603 val = iterative_hash_template_arg (TREE_OPERAND (arg, i), val);
1611 /* Unregister the specialization SPEC as a specialization of TMPL.
1612 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1613 if the SPEC was listed as a specialization of TMPL.
1615 Note that SPEC has been ggc_freed, so we can't look inside it. */
1618 reregister_specialization (tree spec, tree tinfo, tree new_spec)
1623 elt.tmpl = most_general_template (TI_TEMPLATE (tinfo));
1624 elt.args = TI_ARGS (tinfo);
1625 elt.spec = NULL_TREE;
1627 slot = (spec_entry **) htab_find_slot (decl_specializations, &elt, INSERT);
1630 gcc_assert ((*slot)->spec == spec || (*slot)->spec == new_spec);
1631 gcc_assert (new_spec != NULL_TREE);
1632 (*slot)->spec = new_spec;
1639 /* Compare an entry in the local specializations hash table P1 (which
1640 is really a pointer to a TREE_LIST) with P2 (which is really a
1644 eq_local_specializations (const void *p1, const void *p2)
1646 return TREE_VALUE ((const_tree) p1) == (const_tree) p2;
1649 /* Hash P1, an entry in the local specializations table. */
1652 hash_local_specialization (const void* p1)
1654 return htab_hash_pointer (TREE_VALUE ((const_tree) p1));
1657 /* Like register_specialization, but for local declarations. We are
1658 registering SPEC, an instantiation of TMPL. */
1661 register_local_specialization (tree spec, tree tmpl)
1665 slot = htab_find_slot_with_hash (local_specializations, tmpl,
1666 htab_hash_pointer (tmpl), INSERT);
1667 *slot = build_tree_list (spec, tmpl);
1670 /* TYPE is a class type. Returns true if TYPE is an explicitly
1671 specialized class. */
1674 explicit_class_specialization_p (tree type)
1676 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
1678 return !uses_template_parms (CLASSTYPE_TI_ARGS (type));
1681 /* Print the list of functions at FNS, going through all the overloads
1682 for each element of the list. Alternatively, FNS can not be a
1683 TREE_LIST, in which case it will be printed together with all the
1686 MORE and *STR should respectively be FALSE and NULL when the function
1687 is called from the outside. They are used internally on recursive
1688 calls. print_candidates manages the two parameters and leaves NULL
1689 in *STR when it ends. */
1692 print_candidates_1 (tree fns, bool more, const char **str)
1695 char *spaces = NULL;
1697 for (fn = fns; fn; fn = OVL_NEXT (fn))
1698 if (TREE_CODE (fn) == TREE_LIST)
1700 gcc_assert (!OVL_NEXT (fn) && !is_overloaded_fn (fn));
1701 for (fn2 = fn; fn2 != NULL_TREE; fn2 = TREE_CHAIN (fn2))
1702 print_candidates_1 (TREE_VALUE (fn2),
1703 TREE_CHAIN (fn2) || more, str);
1709 /* Pick the prefix string. */
1710 if (!more && !OVL_NEXT (fns))
1712 error ("candidate is: %+#D", OVL_CURRENT (fn));
1716 *str = _("candidates are:");
1717 spaces = get_spaces (*str);
1719 error ("%s %+#D", *str, OVL_CURRENT (fn));
1720 *str = spaces ? spaces : *str;
1730 /* Print the list of candidate FNS in an error message. */
1733 print_candidates (tree fns)
1735 const char *str = NULL;
1736 print_candidates_1 (fns, false, &str);
1737 gcc_assert (str == NULL);
1740 /* Returns the template (one of the functions given by TEMPLATE_ID)
1741 which can be specialized to match the indicated DECL with the
1742 explicit template args given in TEMPLATE_ID. The DECL may be
1743 NULL_TREE if none is available. In that case, the functions in
1744 TEMPLATE_ID are non-members.
1746 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1747 specialization of a member template.
1749 The TEMPLATE_COUNT is the number of references to qualifying
1750 template classes that appeared in the name of the function. See
1751 check_explicit_specialization for a more accurate description.
1753 TSK indicates what kind of template declaration (if any) is being
1754 declared. TSK_TEMPLATE indicates that the declaration given by
1755 DECL, though a FUNCTION_DECL, has template parameters, and is
1756 therefore a template function.
1758 The template args (those explicitly specified and those deduced)
1759 are output in a newly created vector *TARGS_OUT.
1761 If it is impossible to determine the result, an error message is
1762 issued. The error_mark_node is returned to indicate failure. */
1765 determine_specialization (tree template_id,
1768 int need_member_template,
1774 tree explicit_targs;
1775 tree candidates = NULL_TREE;
1776 /* A TREE_LIST of templates of which DECL may be a specialization.
1777 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1778 corresponding TREE_PURPOSE is the set of template arguments that,
1779 when used to instantiate the template, would produce a function
1780 with the signature of DECL. */
1781 tree templates = NULL_TREE;
1783 struct cp_binding_level *b;
1785 *targs_out = NULL_TREE;
1787 if (template_id == error_mark_node || decl == error_mark_node)
1788 return error_mark_node;
1790 fns = TREE_OPERAND (template_id, 0);
1791 explicit_targs = TREE_OPERAND (template_id, 1);
1793 if (fns == error_mark_node)
1794 return error_mark_node;
1796 /* Check for baselinks. */
1797 if (BASELINK_P (fns))
1798 fns = BASELINK_FUNCTIONS (fns);
1800 if (!is_overloaded_fn (fns))
1802 error ("%qD is not a function template", fns);
1803 return error_mark_node;
1806 /* Count the number of template headers specified for this
1809 for (b = current_binding_level;
1810 b->kind == sk_template_parms;
1814 for (; fns; fns = OVL_NEXT (fns))
1816 tree fn = OVL_CURRENT (fns);
1818 if (TREE_CODE (fn) == TEMPLATE_DECL)
1820 tree decl_arg_types;
1823 /* In case of explicit specialization, we need to check if
1824 the number of template headers appearing in the specialization
1825 is correct. This is usually done in check_explicit_specialization,
1826 but the check done there cannot be exhaustive when specializing
1827 member functions. Consider the following code:
1829 template <> void A<int>::f(int);
1830 template <> template <> void A<int>::f(int);
1832 Assuming that A<int> is not itself an explicit specialization
1833 already, the first line specializes "f" which is a non-template
1834 member function, whilst the second line specializes "f" which
1835 is a template member function. So both lines are syntactically
1836 correct, and check_explicit_specialization does not reject
1839 Here, we can do better, as we are matching the specialization
1840 against the declarations. We count the number of template
1841 headers, and we check if they match TEMPLATE_COUNT + 1
1842 (TEMPLATE_COUNT is the number of qualifying template classes,
1843 plus there must be another header for the member template
1846 Notice that if header_count is zero, this is not a
1847 specialization but rather a template instantiation, so there
1848 is no check we can perform here. */
1849 if (header_count && header_count != template_count + 1)
1852 /* Check that the number of template arguments at the
1853 innermost level for DECL is the same as for FN. */
1854 if (current_binding_level->kind == sk_template_parms
1855 && !current_binding_level->explicit_spec_p
1856 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn))
1857 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
1858 (current_template_parms))))
1861 /* DECL might be a specialization of FN. */
1862 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1863 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
1865 /* For a non-static member function, we need to make sure
1866 that the const qualification is the same. Since
1867 get_bindings does not try to merge the "this" parameter,
1868 we must do the comparison explicitly. */
1869 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1870 && !same_type_p (TREE_VALUE (fn_arg_types),
1871 TREE_VALUE (decl_arg_types)))
1874 /* Skip the "this" parameter and, for constructors of
1875 classes with virtual bases, the VTT parameter. A
1876 full specialization of a constructor will have a VTT
1877 parameter, but a template never will. */
1879 = skip_artificial_parms_for (decl, decl_arg_types);
1881 = skip_artificial_parms_for (fn, fn_arg_types);
1883 /* Check that the number of function parameters matches.
1885 template <class T> void f(int i = 0);
1886 template <> void f<int>();
1887 The specialization f<int> is invalid but is not caught
1888 by get_bindings below. */
1889 if (list_length (fn_arg_types) != list_length (decl_arg_types))
1892 /* Function templates cannot be specializations; there are
1893 no partial specializations of functions. Therefore, if
1894 the type of DECL does not match FN, there is no
1896 if (tsk == tsk_template)
1898 if (compparms (fn_arg_types, decl_arg_types))
1899 candidates = tree_cons (NULL_TREE, fn, candidates);
1903 /* See whether this function might be a specialization of this
1905 targs = get_bindings (fn, decl, explicit_targs, /*check_ret=*/true);
1908 /* We cannot deduce template arguments that when used to
1909 specialize TMPL will produce DECL. */
1912 /* Save this template, and the arguments deduced. */
1913 templates = tree_cons (targs, fn, templates);
1915 else if (need_member_template)
1916 /* FN is an ordinary member function, and we need a
1917 specialization of a member template. */
1919 else if (TREE_CODE (fn) != FUNCTION_DECL)
1920 /* We can get IDENTIFIER_NODEs here in certain erroneous
1923 else if (!DECL_FUNCTION_MEMBER_P (fn))
1924 /* This is just an ordinary non-member function. Nothing can
1925 be a specialization of that. */
1927 else if (DECL_ARTIFICIAL (fn))
1928 /* Cannot specialize functions that are created implicitly. */
1932 tree decl_arg_types;
1934 /* This is an ordinary member function. However, since
1935 we're here, we can assume it's enclosing class is a
1936 template class. For example,
1938 template <typename T> struct S { void f(); };
1939 template <> void S<int>::f() {}
1941 Here, S<int>::f is a non-template, but S<int> is a
1942 template class. If FN has the same type as DECL, we
1943 might be in business. */
1945 if (!DECL_TEMPLATE_INFO (fn))
1946 /* Its enclosing class is an explicit specialization
1947 of a template class. This is not a candidate. */
1950 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
1951 TREE_TYPE (TREE_TYPE (fn))))
1952 /* The return types differ. */
1955 /* Adjust the type of DECL in case FN is a static member. */
1956 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1957 if (DECL_STATIC_FUNCTION_P (fn)
1958 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1959 decl_arg_types = TREE_CHAIN (decl_arg_types);
1961 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1964 candidates = tree_cons (NULL_TREE, fn, candidates);
1968 if (templates && TREE_CHAIN (templates))
1974 It is possible for a specialization with a given function
1975 signature to be instantiated from more than one function
1976 template. In such cases, explicit specification of the
1977 template arguments must be used to uniquely identify the
1978 function template specialization being specialized.
1980 Note that here, there's no suggestion that we're supposed to
1981 determine which of the candidate templates is most
1982 specialized. However, we, also have:
1986 Partial ordering of overloaded function template
1987 declarations is used in the following contexts to select
1988 the function template to which a function template
1989 specialization refers:
1991 -- when an explicit specialization refers to a function
1994 So, we do use the partial ordering rules, at least for now.
1995 This extension can only serve to make invalid programs valid,
1996 so it's safe. And, there is strong anecdotal evidence that
1997 the committee intended the partial ordering rules to apply;
1998 the EDG front end has that behavior, and John Spicer claims
1999 that the committee simply forgot to delete the wording in
2000 [temp.expl.spec]. */
2001 tree tmpl = most_specialized_instantiation (templates);
2002 if (tmpl != error_mark_node)
2005 TREE_CHAIN (templates) = NULL_TREE;
2009 if (templates == NULL_TREE && candidates == NULL_TREE)
2011 error ("template-id %qD for %q+D does not match any template "
2012 "declaration", template_id, decl);
2013 if (header_count && header_count != template_count + 1)
2014 inform (input_location, "saw %d %<template<>%>, need %d for "
2015 "specializing a member function template",
2016 header_count, template_count + 1);
2017 return error_mark_node;
2019 else if ((templates && TREE_CHAIN (templates))
2020 || (candidates && TREE_CHAIN (candidates))
2021 || (templates && candidates))
2023 error ("ambiguous template specialization %qD for %q+D",
2025 candidates = chainon (candidates, templates);
2026 print_candidates (candidates);
2027 return error_mark_node;
2030 /* We have one, and exactly one, match. */
2033 tree fn = TREE_VALUE (candidates);
2034 *targs_out = copy_node (DECL_TI_ARGS (fn));
2035 /* DECL is a re-declaration or partial instantiation of a template
2037 if (TREE_CODE (fn) == TEMPLATE_DECL)
2039 /* It was a specialization of an ordinary member function in a
2041 return DECL_TI_TEMPLATE (fn);
2044 /* It was a specialization of a template. */
2045 targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates)));
2046 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs))
2048 *targs_out = copy_node (targs);
2049 SET_TMPL_ARGS_LEVEL (*targs_out,
2050 TMPL_ARGS_DEPTH (*targs_out),
2051 TREE_PURPOSE (templates));
2054 *targs_out = TREE_PURPOSE (templates);
2055 return TREE_VALUE (templates);
2058 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2059 but with the default argument values filled in from those in the
2063 copy_default_args_to_explicit_spec_1 (tree spec_types,
2066 tree new_spec_types;
2071 if (spec_types == void_list_node)
2072 return void_list_node;
2074 /* Substitute into the rest of the list. */
2076 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
2077 TREE_CHAIN (tmpl_types));
2079 /* Add the default argument for this parameter. */
2080 return hash_tree_cons (TREE_PURPOSE (tmpl_types),
2081 TREE_VALUE (spec_types),
2085 /* DECL is an explicit specialization. Replicate default arguments
2086 from the template it specializes. (That way, code like:
2088 template <class T> void f(T = 3);
2089 template <> void f(double);
2092 works, as required.) An alternative approach would be to look up
2093 the correct default arguments at the call-site, but this approach
2094 is consistent with how implicit instantiations are handled. */
2097 copy_default_args_to_explicit_spec (tree decl)
2102 tree new_spec_types;
2106 tree object_type = NULL_TREE;
2107 tree in_charge = NULL_TREE;
2108 tree vtt = NULL_TREE;
2110 /* See if there's anything we need to do. */
2111 tmpl = DECL_TI_TEMPLATE (decl);
2112 tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
2113 for (t = tmpl_types; t; t = TREE_CHAIN (t))
2114 if (TREE_PURPOSE (t))
2119 old_type = TREE_TYPE (decl);
2120 spec_types = TYPE_ARG_TYPES (old_type);
2122 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2124 /* Remove the this pointer, but remember the object's type for
2126 object_type = TREE_TYPE (TREE_VALUE (spec_types));
2127 spec_types = TREE_CHAIN (spec_types);
2128 tmpl_types = TREE_CHAIN (tmpl_types);
2130 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
2132 /* DECL may contain more parameters than TMPL due to the extra
2133 in-charge parameter in constructors and destructors. */
2134 in_charge = spec_types;
2135 spec_types = TREE_CHAIN (spec_types);
2137 if (DECL_HAS_VTT_PARM_P (decl))
2140 spec_types = TREE_CHAIN (spec_types);
2144 /* Compute the merged default arguments. */
2146 copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);
2148 /* Compute the new FUNCTION_TYPE. */
2152 new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt),
2157 /* Put the in-charge parameter back. */
2158 new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
2159 TREE_VALUE (in_charge),
2162 new_type = build_method_type_directly (object_type,
2163 TREE_TYPE (old_type),
2167 new_type = build_function_type (TREE_TYPE (old_type),
2169 new_type = cp_build_type_attribute_variant (new_type,
2170 TYPE_ATTRIBUTES (old_type));
2171 new_type = build_exception_variant (new_type,
2172 TYPE_RAISES_EXCEPTIONS (old_type));
2173 TREE_TYPE (decl) = new_type;
2176 /* Check to see if the function just declared, as indicated in
2177 DECLARATOR, and in DECL, is a specialization of a function
2178 template. We may also discover that the declaration is an explicit
2179 instantiation at this point.
2181 Returns DECL, or an equivalent declaration that should be used
2182 instead if all goes well. Issues an error message if something is
2183 amiss. Returns error_mark_node if the error is not easily
2186 FLAGS is a bitmask consisting of the following flags:
2188 2: The function has a definition.
2189 4: The function is a friend.
2191 The TEMPLATE_COUNT is the number of references to qualifying
2192 template classes that appeared in the name of the function. For
2195 template <class T> struct S { void f(); };
2198 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2199 classes are not counted in the TEMPLATE_COUNT, so that in
2201 template <class T> struct S {};
2202 template <> struct S<int> { void f(); }
2203 template <> void S<int>::f();
2205 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2206 invalid; there should be no template <>.)
2208 If the function is a specialization, it is marked as such via
2209 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2210 is set up correctly, and it is added to the list of specializations
2211 for that template. */
2214 check_explicit_specialization (tree declarator,
2219 int have_def = flags & 2;
2220 int is_friend = flags & 4;
2221 int specialization = 0;
2222 int explicit_instantiation = 0;
2223 int member_specialization = 0;
2224 tree ctype = DECL_CLASS_CONTEXT (decl);
2225 tree dname = DECL_NAME (decl);
2230 if (!processing_specialization)
2233 tsk = tsk_excessive_parms;
2236 tsk = current_tmpl_spec_kind (template_count);
2241 if (processing_specialization)
2244 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
2246 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
2249 /* This could be something like:
2251 template <class T> void f(T);
2252 class S { friend void f<>(int); } */
2256 /* This case handles bogus declarations like template <>
2257 template <class T> void f<int>(); */
2259 error ("template-id %qD in declaration of primary template",
2266 case tsk_invalid_member_spec:
2267 /* The error has already been reported in
2268 check_specialization_scope. */
2269 return error_mark_node;
2271 case tsk_invalid_expl_inst:
2272 error ("template parameter list used in explicit instantiation");
2278 error ("definition provided for explicit instantiation");
2280 explicit_instantiation = 1;
2283 case tsk_excessive_parms:
2284 case tsk_insufficient_parms:
2285 if (tsk == tsk_excessive_parms)
2286 error ("too many template parameter lists in declaration of %qD",
2288 else if (template_header_count)
2289 error("too few template parameter lists in declaration of %qD", decl);
2291 error("explicit specialization of %qD must be introduced by "
2292 "%<template <>%>", decl);
2296 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
2298 member_specialization = 1;
2304 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
2306 /* This case handles bogus declarations like template <>
2307 template <class T> void f<int>(); */
2309 if (uses_template_parms (declarator))
2310 error ("function template partial specialization %qD "
2311 "is not allowed", declarator);
2313 error ("template-id %qD in declaration of primary template",
2318 if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
2319 /* This is a specialization of a member template, without
2320 specialization the containing class. Something like:
2322 template <class T> struct S {
2323 template <class U> void f (U);
2325 template <> template <class U> void S<int>::f(U) {}
2327 That's a specialization -- but of the entire template. */
2335 if (specialization || member_specialization)
2337 tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
2338 for (; t; t = TREE_CHAIN (t))
2339 if (TREE_PURPOSE (t))
2341 permerror (input_location,
2342 "default argument specified in explicit specialization");
2347 if (specialization || member_specialization || explicit_instantiation)
2349 tree tmpl = NULL_TREE;
2350 tree targs = NULL_TREE;
2352 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2353 if (TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
2357 gcc_assert (TREE_CODE (declarator) == IDENTIFIER_NODE);
2362 /* If there is no class context, the explicit instantiation
2363 must be at namespace scope. */
2364 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl));
2366 /* Find the namespace binding, using the declaration
2368 fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
2370 if (fns == error_mark_node || !is_overloaded_fn (fns))
2372 error ("%qD is not a template function", dname);
2373 fns = error_mark_node;
2377 tree fn = OVL_CURRENT (fns);
2378 if (!is_associated_namespace (CP_DECL_CONTEXT (decl),
2379 CP_DECL_CONTEXT (fn)))
2380 error ("%qD is not declared in %qD",
2381 decl, current_namespace);
2385 declarator = lookup_template_function (fns, NULL_TREE);
2388 if (declarator == error_mark_node)
2389 return error_mark_node;
2391 if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
2393 if (!explicit_instantiation)
2394 /* A specialization in class scope. This is invalid,
2395 but the error will already have been flagged by
2396 check_specialization_scope. */
2397 return error_mark_node;
2400 /* It's not valid to write an explicit instantiation in
2403 class C { template void f(); }
2405 This case is caught by the parser. However, on
2408 template class C { void f(); };
2410 (which is invalid) we can get here. The error will be
2417 else if (ctype != NULL_TREE
2418 && (TREE_CODE (TREE_OPERAND (declarator, 0)) ==
2421 /* Find the list of functions in ctype that have the same
2422 name as the declared function. */
2423 tree name = TREE_OPERAND (declarator, 0);
2424 tree fns = NULL_TREE;
2427 if (constructor_name_p (name, ctype))
2429 int is_constructor = DECL_CONSTRUCTOR_P (decl);
2431 if (is_constructor ? !TYPE_HAS_USER_CONSTRUCTOR (ctype)
2432 : !CLASSTYPE_DESTRUCTORS (ctype))
2434 /* From [temp.expl.spec]:
2436 If such an explicit specialization for the member
2437 of a class template names an implicitly-declared
2438 special member function (clause _special_), the
2439 program is ill-formed.
2441 Similar language is found in [temp.explicit]. */
2442 error ("specialization of implicitly-declared special member function");
2443 return error_mark_node;
2446 name = is_constructor ? ctor_identifier : dtor_identifier;
2449 if (!DECL_CONV_FN_P (decl))
2451 idx = lookup_fnfields_1 (ctype, name);
2453 fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (ctype), idx);
2457 VEC(tree,gc) *methods;
2460 /* For a type-conversion operator, we cannot do a
2461 name-based lookup. We might be looking for `operator
2462 int' which will be a specialization of `operator T'.
2463 So, we find *all* the conversion operators, and then
2464 select from them. */
2467 methods = CLASSTYPE_METHOD_VEC (ctype);
2469 for (idx = CLASSTYPE_FIRST_CONVERSION_SLOT;
2470 VEC_iterate (tree, methods, idx, ovl);
2473 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl)))
2474 /* There are no more conversion functions. */
2477 /* Glue all these conversion functions together
2478 with those we already have. */
2479 for (; ovl; ovl = OVL_NEXT (ovl))
2480 fns = ovl_cons (OVL_CURRENT (ovl), fns);
2484 if (fns == NULL_TREE)
2486 error ("no member function %qD declared in %qT", name, ctype);
2487 return error_mark_node;
2490 TREE_OPERAND (declarator, 0) = fns;
2493 /* Figure out what exactly is being specialized at this point.
2494 Note that for an explicit instantiation, even one for a
2495 member function, we cannot tell apriori whether the
2496 instantiation is for a member template, or just a member
2497 function of a template class. Even if a member template is
2498 being instantiated, the member template arguments may be
2499 elided if they can be deduced from the rest of the
2501 tmpl = determine_specialization (declarator, decl,
2503 member_specialization,
2507 if (!tmpl || tmpl == error_mark_node)
2508 /* We couldn't figure out what this declaration was
2510 return error_mark_node;
2513 tree gen_tmpl = most_general_template (tmpl);
2515 if (explicit_instantiation)
2517 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2518 is done by do_decl_instantiation later. */
2520 int arg_depth = TMPL_ARGS_DEPTH (targs);
2521 int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
2523 if (arg_depth > parm_depth)
2525 /* If TMPL is not the most general template (for
2526 example, if TMPL is a friend template that is
2527 injected into namespace scope), then there will
2528 be too many levels of TARGS. Remove some of them
2533 new_targs = make_tree_vec (parm_depth);
2534 for (i = arg_depth - parm_depth; i < arg_depth; ++i)
2535 TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
2536 = TREE_VEC_ELT (targs, i);
2540 return instantiate_template (tmpl, targs, tf_error);
2543 /* If we thought that the DECL was a member function, but it
2544 turns out to be specializing a static member function,
2545 make DECL a static member function as well. */
2546 if (DECL_STATIC_FUNCTION_P (tmpl)
2547 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2548 revert_static_member_fn (decl);
2550 /* If this is a specialization of a member template of a
2551 template class, we want to return the TEMPLATE_DECL, not
2552 the specialization of it. */
2553 if (tsk == tsk_template)
2555 tree result = DECL_TEMPLATE_RESULT (tmpl);
2556 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
2557 DECL_INITIAL (result) = NULL_TREE;
2561 DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
2562 DECL_SOURCE_LOCATION (result)
2563 = DECL_SOURCE_LOCATION (decl);
2564 /* We want to use the argument list specified in the
2565 definition, not in the original declaration. */
2566 DECL_ARGUMENTS (result) = DECL_ARGUMENTS (decl);
2567 for (parm = DECL_ARGUMENTS (result); parm;
2568 parm = DECL_CHAIN (parm))
2569 DECL_CONTEXT (parm) = result;
2571 return register_specialization (tmpl, gen_tmpl, targs,
2575 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2576 DECL_TEMPLATE_INFO (decl) = build_template_info (tmpl, targs);
2578 /* Inherit default function arguments from the template
2579 DECL is specializing. */
2580 copy_default_args_to_explicit_spec (decl);
2582 /* This specialization has the same protection as the
2583 template it specializes. */
2584 TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
2585 TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
2587 /* 7.1.1-1 [dcl.stc]
2589 A storage-class-specifier shall not be specified in an
2590 explicit specialization...
2592 The parser rejects these, so unless action is taken here,
2593 explicit function specializations will always appear with
2596 The action recommended by the C++ CWG in response to C++
2597 defect report 605 is to make the storage class and linkage
2598 of the explicit specialization match the templated function:
2600 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2602 if (tsk == tsk_expl_spec && DECL_FUNCTION_TEMPLATE_P (gen_tmpl))
2604 tree tmpl_func = DECL_TEMPLATE_RESULT (gen_tmpl);
2605 gcc_assert (TREE_CODE (tmpl_func) == FUNCTION_DECL);
2607 /* This specialization has the same linkage and visibility as
2608 the function template it specializes. */
2609 TREE_PUBLIC (decl) = TREE_PUBLIC (tmpl_func);
2610 if (! TREE_PUBLIC (decl))
2612 DECL_INTERFACE_KNOWN (decl) = 1;
2613 DECL_NOT_REALLY_EXTERN (decl) = 1;
2615 DECL_THIS_STATIC (decl) = DECL_THIS_STATIC (tmpl_func);
2616 if (DECL_VISIBILITY_SPECIFIED (tmpl_func))
2618 DECL_VISIBILITY_SPECIFIED (decl) = 1;
2619 DECL_VISIBILITY (decl) = DECL_VISIBILITY (tmpl_func);
2623 /* If DECL is a friend declaration, declared using an
2624 unqualified name, the namespace associated with DECL may
2625 have been set incorrectly. For example, in:
2627 template <typename T> void f(T);
2629 struct S { friend void f<int>(int); }
2632 we will have set the DECL_CONTEXT for the friend
2633 declaration to N, rather than to the global namespace. */
2634 if (DECL_NAMESPACE_SCOPE_P (decl))
2635 DECL_CONTEXT (decl) = DECL_CONTEXT (tmpl);
2637 if (is_friend && !have_def)
2638 /* This is not really a declaration of a specialization.
2639 It's just the name of an instantiation. But, it's not
2640 a request for an instantiation, either. */
2641 SET_DECL_IMPLICIT_INSTANTIATION (decl);
2642 else if (DECL_CONSTRUCTOR_P (decl) || DECL_DESTRUCTOR_P (decl))
2643 /* This is indeed a specialization. In case of constructors
2644 and destructors, we need in-charge and not-in-charge
2645 versions in V3 ABI. */
2646 clone_function_decl (decl, /*update_method_vec_p=*/0);
2648 /* Register this specialization so that we can find it
2650 decl = register_specialization (decl, gen_tmpl, targs, is_friend, 0);
2657 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2658 parameters. These are represented in the same format used for
2659 DECL_TEMPLATE_PARMS. */
2662 comp_template_parms (const_tree parms1, const_tree parms2)
2667 if (parms1 == parms2)
2670 for (p1 = parms1, p2 = parms2;
2671 p1 != NULL_TREE && p2 != NULL_TREE;
2672 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2))
2674 tree t1 = TREE_VALUE (p1);
2675 tree t2 = TREE_VALUE (p2);
2678 gcc_assert (TREE_CODE (t1) == TREE_VEC);
2679 gcc_assert (TREE_CODE (t2) == TREE_VEC);
2681 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
2684 for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
2686 tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
2687 tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
2689 /* If either of the template parameters are invalid, assume
2690 they match for the sake of error recovery. */
2691 if (parm1 == error_mark_node || parm2 == error_mark_node)
2694 if (TREE_CODE (parm1) != TREE_CODE (parm2))
2697 if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM
2698 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1)
2699 == TEMPLATE_TYPE_PARAMETER_PACK (parm2)))
2701 else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
2706 if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
2707 /* One set of parameters has more parameters lists than the
2714 /* Determine whether PARM is a parameter pack. */
2717 template_parameter_pack_p (const_tree parm)
2719 /* Determine if we have a non-type template parameter pack. */
2720 if (TREE_CODE (parm) == PARM_DECL)
2721 return (DECL_TEMPLATE_PARM_P (parm)
2722 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)));
2724 /* If this is a list of template parameters, we could get a
2725 TYPE_DECL or a TEMPLATE_DECL. */
2726 if (TREE_CODE (parm) == TYPE_DECL || TREE_CODE (parm) == TEMPLATE_DECL)
2727 parm = TREE_TYPE (parm);
2729 return ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
2730 || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM)
2731 && TEMPLATE_TYPE_PARAMETER_PACK (parm));
2734 /* Determine if T is a function parameter pack. */
2737 function_parameter_pack_p (const_tree t)
2739 if (t && TREE_CODE (t) == PARM_DECL)
2740 return FUNCTION_PARAMETER_PACK_P (t);
2744 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
2745 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
2748 get_function_template_decl (const_tree primary_func_tmpl_inst)
2750 if (! primary_func_tmpl_inst
2751 || TREE_CODE (primary_func_tmpl_inst) != FUNCTION_DECL
2752 || ! primary_template_instantiation_p (primary_func_tmpl_inst))
2755 return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst));
2758 /* Return true iff the function parameter PARAM_DECL was expanded
2759 from the function parameter pack PACK. */
2762 function_parameter_expanded_from_pack_p (tree param_decl, tree pack)
2764 if (DECL_ARTIFICIAL (param_decl)
2765 || !function_parameter_pack_p (pack))
2768 /* The parameter pack and its pack arguments have the same
2770 return DECL_PARM_INDEX (pack) == DECL_PARM_INDEX (param_decl);
2773 /* Determine whether ARGS describes a variadic template args list,
2774 i.e., one that is terminated by a template argument pack. */
2777 template_args_variadic_p (tree args)
2782 if (args == NULL_TREE)
2785 args = INNERMOST_TEMPLATE_ARGS (args);
2786 nargs = TREE_VEC_LENGTH (args);
2791 last_parm = TREE_VEC_ELT (args, nargs - 1);
2793 return ARGUMENT_PACK_P (last_parm);
2796 /* Generate a new name for the parameter pack name NAME (an
2797 IDENTIFIER_NODE) that incorporates its */
2800 make_ith_pack_parameter_name (tree name, int i)
2802 /* Munge the name to include the parameter index. */
2803 #define NUMBUF_LEN 128
2804 char numbuf[NUMBUF_LEN];
2808 snprintf (numbuf, NUMBUF_LEN, "%i", i);
2809 newname_len = IDENTIFIER_LENGTH (name)
2810 + strlen (numbuf) + 2;
2811 newname = (char*)alloca (newname_len);
2812 snprintf (newname, newname_len,
2813 "%s#%i", IDENTIFIER_POINTER (name), i);
2814 return get_identifier (newname);
2817 /* Return true if T is a primary function
2818 or class template instantiation. */
2821 primary_template_instantiation_p (const_tree t)
2826 if (TREE_CODE (t) == FUNCTION_DECL)
2827 return DECL_LANG_SPECIFIC (t)
2828 && DECL_TEMPLATE_INSTANTIATION (t)
2829 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t));
2830 else if (CLASS_TYPE_P (t))
2831 return CLASSTYPE_TEMPLATE_INSTANTIATION (t)
2832 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t));
2836 /* Return true if PARM is a template template parameter. */
2839 template_template_parameter_p (const_tree parm)
2841 return DECL_TEMPLATE_TEMPLATE_PARM_P (parm);
2844 /* Return the template parameters of T if T is a
2845 primary template instantiation, NULL otherwise. */
2848 get_primary_template_innermost_parameters (const_tree t)
2850 tree parms = NULL, template_info = NULL;
2852 if ((template_info = get_template_info (t))
2853 && primary_template_instantiation_p (t))
2854 parms = INNERMOST_TEMPLATE_PARMS
2855 (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info)));
2860 /* Return the template parameters of the LEVELth level from the full list
2861 of template parameters PARMS. */
2864 get_template_parms_at_level (tree parms, int level)
2868 || TREE_CODE (parms) != TREE_LIST
2869 || level > TMPL_PARMS_DEPTH (parms))
2872 for (p = parms; p; p = TREE_CHAIN (p))
2873 if (TMPL_PARMS_DEPTH (p) == level)
2879 /* Returns the template arguments of T if T is a template instantiation,
2883 get_template_innermost_arguments (const_tree t)
2885 tree args = NULL, template_info = NULL;
2887 if ((template_info = get_template_info (t))
2888 && TI_ARGS (template_info))
2889 args = INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info));
2894 /* Return the argument pack elements of T if T is a template argument pack,
2898 get_template_argument_pack_elems (const_tree t)
2900 if (TREE_CODE (t) != TYPE_ARGUMENT_PACK
2901 && TREE_CODE (t) != NONTYPE_ARGUMENT_PACK)
2904 return ARGUMENT_PACK_ARGS (t);
2907 /* Structure used to track the progress of find_parameter_packs_r. */
2908 struct find_parameter_pack_data
2910 /* TREE_LIST that will contain all of the parameter packs found by
2912 tree* parameter_packs;
2914 /* Set of AST nodes that have been visited by the traversal. */
2915 struct pointer_set_t *visited;
2918 /* Identifies all of the argument packs that occur in a template
2919 argument and appends them to the TREE_LIST inside DATA, which is a
2920 find_parameter_pack_data structure. This is a subroutine of
2921 make_pack_expansion and uses_parameter_packs. */
2923 find_parameter_packs_r (tree *tp, int *walk_subtrees, void* data)
2926 struct find_parameter_pack_data* ppd =
2927 (struct find_parameter_pack_data*)data;
2928 bool parameter_pack_p = false;
2930 /* Identify whether this is a parameter pack or not. */
2931 switch (TREE_CODE (t))
2933 case TEMPLATE_PARM_INDEX:
2934 if (TEMPLATE_PARM_PARAMETER_PACK (t))
2935 parameter_pack_p = true;
2938 case TEMPLATE_TYPE_PARM:
2939 case TEMPLATE_TEMPLATE_PARM:
2940 if (TEMPLATE_TYPE_PARAMETER_PACK (t))
2941 parameter_pack_p = true;
2945 if (FUNCTION_PARAMETER_PACK_P (t))
2947 /* We don't want to walk into the type of a PARM_DECL,
2948 because we don't want to see the type parameter pack. */
2950 parameter_pack_p = true;
2955 /* Not a parameter pack. */
2959 if (parameter_pack_p)
2961 /* Add this parameter pack to the list. */
2962 *ppd->parameter_packs = tree_cons (NULL_TREE, t, *ppd->parameter_packs);
2966 cp_walk_tree (&TYPE_CONTEXT (t),
2967 &find_parameter_packs_r, ppd, ppd->visited);
2969 /* This switch statement will return immediately if we don't find a
2971 switch (TREE_CODE (t))
2973 case TEMPLATE_PARM_INDEX:
2976 case BOUND_TEMPLATE_TEMPLATE_PARM:
2977 /* Check the template itself. */
2978 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t)),
2979 &find_parameter_packs_r, ppd, ppd->visited);
2980 /* Check the template arguments. */
2981 cp_walk_tree (&TYPE_TI_ARGS (t), &find_parameter_packs_r, ppd,
2986 case TEMPLATE_TYPE_PARM:
2987 case TEMPLATE_TEMPLATE_PARM:
2994 if (TYPE_PTRMEMFUNC_P (t))
3000 if (TYPE_TEMPLATE_INFO (t))
3001 cp_walk_tree (&TI_ARGS (TYPE_TEMPLATE_INFO (t)),
3002 &find_parameter_packs_r, ppd, ppd->visited);
3008 cp_walk_tree (&TREE_TYPE (t),
3009 &find_parameter_packs_r, ppd, ppd->visited);
3013 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t), &find_parameter_packs_r,
3018 case TYPE_PACK_EXPANSION:
3019 case EXPR_PACK_EXPANSION:
3024 cp_walk_tree (&TYPE_MAX_VALUE (t), &find_parameter_packs_r,
3029 case IDENTIFIER_NODE:
3030 cp_walk_tree (&TREE_TYPE (t), &find_parameter_packs_r, ppd,
3042 /* Determines if the expression or type T uses any parameter packs. */
3044 uses_parameter_packs (tree t)
3046 tree parameter_packs = NULL_TREE;
3047 struct find_parameter_pack_data ppd;
3048 ppd.parameter_packs = ¶meter_packs;
3049 ppd.visited = pointer_set_create ();
3050 cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
3051 pointer_set_destroy (ppd.visited);
3052 return parameter_packs != NULL_TREE;
3055 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3056 representation a base-class initializer into a parameter pack
3057 expansion. If all goes well, the resulting node will be an
3058 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3061 make_pack_expansion (tree arg)
3064 tree parameter_packs = NULL_TREE;
3065 bool for_types = false;
3066 struct find_parameter_pack_data ppd;
3068 if (!arg || arg == error_mark_node)
3071 if (TREE_CODE (arg) == TREE_LIST)
3073 /* The only time we will see a TREE_LIST here is for a base
3074 class initializer. In this case, the TREE_PURPOSE will be a
3075 _TYPE node (representing the base class expansion we're
3076 initializing) and the TREE_VALUE will be a TREE_LIST
3077 containing the initialization arguments.
3079 The resulting expansion looks somewhat different from most
3080 expansions. Rather than returning just one _EXPANSION, we
3081 return a TREE_LIST whose TREE_PURPOSE is a
3082 TYPE_PACK_EXPANSION containing the bases that will be
3083 initialized. The TREE_VALUE will be identical to the
3084 original TREE_VALUE, which is a list of arguments that will
3085 be passed to each base. We do not introduce any new pack
3086 expansion nodes into the TREE_VALUE (although it is possible
3087 that some already exist), because the TREE_PURPOSE and
3088 TREE_VALUE all need to be expanded together with the same
3089 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3090 resulting TREE_PURPOSE will mention the parameter packs in
3091 both the bases and the arguments to the bases. */
3094 tree parameter_packs = NULL_TREE;
3096 /* Determine which parameter packs will be used by the base
3098 ppd.visited = pointer_set_create ();
3099 ppd.parameter_packs = ¶meter_packs;
3100 cp_walk_tree (&TREE_PURPOSE (arg), &find_parameter_packs_r,
3103 if (parameter_packs == NULL_TREE)
3105 error ("base initializer expansion %<%T%> contains no parameter packs", arg);
3106 pointer_set_destroy (ppd.visited);
3107 return error_mark_node;
3110 if (TREE_VALUE (arg) != void_type_node)
3112 /* Collect the sets of parameter packs used in each of the
3113 initialization arguments. */
3114 for (value = TREE_VALUE (arg); value; value = TREE_CHAIN (value))
3116 /* Determine which parameter packs will be expanded in this
3118 cp_walk_tree (&TREE_VALUE (value), &find_parameter_packs_r,
3123 pointer_set_destroy (ppd.visited);
3125 /* Create the pack expansion type for the base type. */
3126 purpose = cxx_make_type (TYPE_PACK_EXPANSION);
3127 SET_PACK_EXPANSION_PATTERN (purpose, TREE_PURPOSE (arg));
3128 PACK_EXPANSION_PARAMETER_PACKS (purpose) = parameter_packs;
3130 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3131 they will rarely be compared to anything. */
3132 SET_TYPE_STRUCTURAL_EQUALITY (purpose);
3134 return tree_cons (purpose, TREE_VALUE (arg), NULL_TREE);
3137 if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
3140 /* Build the PACK_EXPANSION_* node. */
3142 ? cxx_make_type (TYPE_PACK_EXPANSION)
3143 : make_node (EXPR_PACK_EXPANSION);
3144 SET_PACK_EXPANSION_PATTERN (result, arg);
3145 if (TREE_CODE (result) == EXPR_PACK_EXPANSION)
3147 /* Propagate type and const-expression information. */
3148 TREE_TYPE (result) = TREE_TYPE (arg);
3149 TREE_CONSTANT (result) = TREE_CONSTANT (arg);
3152 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3153 they will rarely be compared to anything. */
3154 SET_TYPE_STRUCTURAL_EQUALITY (result);
3156 /* Determine which parameter packs will be expanded. */
3157 ppd.parameter_packs = ¶meter_packs;
3158 ppd.visited = pointer_set_create ();
3159 cp_walk_tree (&arg, &find_parameter_packs_r, &ppd, ppd.visited);
3160 pointer_set_destroy (ppd.visited);
3162 /* Make sure we found some parameter packs. */
3163 if (parameter_packs == NULL_TREE)
3166 error ("expansion pattern %<%T%> contains no argument packs", arg);
3168 error ("expansion pattern %<%E%> contains no argument packs", arg);
3169 return error_mark_node;
3171 PACK_EXPANSION_PARAMETER_PACKS (result) = parameter_packs;
3176 /* Checks T for any "bare" parameter packs, which have not yet been
3177 expanded, and issues an error if any are found. This operation can
3178 only be done on full expressions or types (e.g., an expression
3179 statement, "if" condition, etc.), because we could have expressions like:
3181 foo(f(g(h(args)))...)
3183 where "args" is a parameter pack. check_for_bare_parameter_packs
3184 should not be called for the subexpressions args, h(args),
3185 g(h(args)), or f(g(h(args))), because we would produce erroneous
3188 Returns TRUE and emits an error if there were bare parameter packs,
3189 returns FALSE otherwise. */
3191 check_for_bare_parameter_packs (tree t)
3193 tree parameter_packs = NULL_TREE;
3194 struct find_parameter_pack_data ppd;
3196 if (!processing_template_decl || !t || t == error_mark_node)
3199 if (TREE_CODE (t) == TYPE_DECL)
3202 ppd.parameter_packs = ¶meter_packs;
3203 ppd.visited = pointer_set_create ();
3204 cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
3205 pointer_set_destroy (ppd.visited);
3207 if (parameter_packs)
3209 error ("parameter packs not expanded with %<...%>:");
3210 while (parameter_packs)
3212 tree pack = TREE_VALUE (parameter_packs);
3213 tree name = NULL_TREE;
3215 if (TREE_CODE (pack) == TEMPLATE_TYPE_PARM
3216 || TREE_CODE (pack) == TEMPLATE_TEMPLATE_PARM)
3217 name = TYPE_NAME (pack);
3218 else if (TREE_CODE (pack) == TEMPLATE_PARM_INDEX)
3219 name = DECL_NAME (TEMPLATE_PARM_DECL (pack));
3221 name = DECL_NAME (pack);
3224 inform (input_location, " %qD", name);
3226 inform (input_location, " <anonymous>");
3228 parameter_packs = TREE_CHAIN (parameter_packs);
3237 /* Expand any parameter packs that occur in the template arguments in
3240 expand_template_argument_pack (tree args)
3242 tree result_args = NULL_TREE;
3243 int in_arg, out_arg = 0, nargs = args ? TREE_VEC_LENGTH (args) : 0;
3244 int num_result_args = -1;
3245 int non_default_args_count = -1;
3247 /* First, determine if we need to expand anything, and the number of
3248 slots we'll need. */
3249 for (in_arg = 0; in_arg < nargs; ++in_arg)
3251 tree arg = TREE_VEC_ELT (args, in_arg);
3252 if (arg == NULL_TREE)
3254 if (ARGUMENT_PACK_P (arg))
3256 int num_packed = TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg));
3257 if (num_result_args < 0)
3258 num_result_args = in_arg + num_packed;
3260 num_result_args += num_packed;
3264 if (num_result_args >= 0)
3269 /* If no expansion is necessary, we're done. */
3270 if (num_result_args < 0)
3273 /* Expand arguments. */
3274 result_args = make_tree_vec (num_result_args);
3275 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args))
3276 non_default_args_count =
3277 GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args);
3278 for (in_arg = 0; in_arg < nargs; ++in_arg)
3280 tree arg = TREE_VEC_ELT (args, in_arg);
3281 if (ARGUMENT_PACK_P (arg))
3283 tree packed = ARGUMENT_PACK_ARGS (arg);
3284 int i, num_packed = TREE_VEC_LENGTH (packed);
3285 for (i = 0; i < num_packed; ++i, ++out_arg)
3286 TREE_VEC_ELT (result_args, out_arg) = TREE_VEC_ELT(packed, i);
3287 if (non_default_args_count > 0)
3288 non_default_args_count += num_packed;
3292 TREE_VEC_ELT (result_args, out_arg) = arg;
3296 if (non_default_args_count >= 0)
3297 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args, non_default_args_count);
3301 /* Checks if DECL shadows a template parameter.
3303 [temp.local]: A template-parameter shall not be redeclared within its
3304 scope (including nested scopes).
3306 Emits an error and returns TRUE if the DECL shadows a parameter,
3307 returns FALSE otherwise. */
3310 check_template_shadow (tree decl)
3314 /* If we're not in a template, we can't possibly shadow a template
3316 if (!current_template_parms)
3319 /* Figure out what we're shadowing. */
3320 if (TREE_CODE (decl) == OVERLOAD)
3321 decl = OVL_CURRENT (decl);
3322 olddecl = innermost_non_namespace_value (DECL_NAME (decl));
3324 /* If there's no previous binding for this name, we're not shadowing
3325 anything, let alone a template parameter. */
3329 /* If we're not shadowing a template parameter, we're done. Note
3330 that OLDDECL might be an OVERLOAD (or perhaps even an
3331 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3333 if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
3336 /* We check for decl != olddecl to avoid bogus errors for using a
3337 name inside a class. We check TPFI to avoid duplicate errors for
3338 inline member templates. */
3340 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms))
3343 error ("declaration of %q+#D", decl);
3344 error (" shadows template parm %q+#D", olddecl);
3348 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3349 ORIG_LEVEL, DECL, and TYPE. */
3352 build_template_parm_index (int index,
3358 tree t = make_node (TEMPLATE_PARM_INDEX);
3359 TEMPLATE_PARM_IDX (t) = index;
3360 TEMPLATE_PARM_LEVEL (t) = level;
3361 TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
3362 TEMPLATE_PARM_DECL (t) = decl;
3363 TREE_TYPE (t) = type;
3364 TREE_CONSTANT (t) = TREE_CONSTANT (decl);
3365 TREE_READONLY (t) = TREE_READONLY (decl);
3370 /* Find the canonical type parameter for the given template type
3371 parameter. Returns the canonical type parameter, which may be TYPE
3372 if no such parameter existed. */
3374 canonical_type_parameter (tree type)
3377 int idx = TEMPLATE_TYPE_IDX (type);
3378 if (!canonical_template_parms)
3379 canonical_template_parms = VEC_alloc (tree, gc, idx+1);
3381 while (VEC_length (tree, canonical_template_parms) <= (unsigned)idx)
3382 VEC_safe_push (tree, gc, canonical_template_parms, NULL_TREE);
3384 list = VEC_index (tree, canonical_template_parms, idx);
3385 while (list && !comptypes (type, TREE_VALUE (list), COMPARE_STRUCTURAL))
3386 list = TREE_CHAIN (list);
3389 return TREE_VALUE (list);
3392 VEC_replace(tree, canonical_template_parms, idx,
3393 tree_cons (NULL_TREE, type,
3394 VEC_index (tree, canonical_template_parms, idx)));
3399 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3400 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3401 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3402 new one is created. */
3405 reduce_template_parm_level (tree index, tree type, int levels, tree args,
3406 tsubst_flags_t complain)
3408 if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
3409 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
3410 != TEMPLATE_PARM_LEVEL (index) - levels)
3411 || !same_type_p (type, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index))))
3413 tree orig_decl = TEMPLATE_PARM_DECL (index);
3416 decl = build_decl (DECL_SOURCE_LOCATION (orig_decl),
3417 TREE_CODE (orig_decl), DECL_NAME (orig_decl), type);
3418 TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl);
3419 TREE_READONLY (decl) = TREE_READONLY (orig_decl);
3420 DECL_ARTIFICIAL (decl) = 1;
3421 SET_DECL_TEMPLATE_PARM_P (decl);
3423 t = build_template_parm_index (TEMPLATE_PARM_IDX (index),
3424 TEMPLATE_PARM_LEVEL (index) - levels,
3425 TEMPLATE_PARM_ORIG_LEVEL (index),
3427 TEMPLATE_PARM_DESCENDANTS (index) = t;
3428 TEMPLATE_PARM_PARAMETER_PACK (t)
3429 = TEMPLATE_PARM_PARAMETER_PACK (index);
3431 /* Template template parameters need this. */
3432 if (TREE_CODE (decl) == TEMPLATE_DECL)
3433 DECL_TEMPLATE_PARMS (decl) = tsubst_template_parms
3434 (DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index)),
3438 return TEMPLATE_PARM_DESCENDANTS (index);
3441 /* Process information from new template parameter PARM and append it to the
3442 LIST being built. This new parameter is a non-type parameter iff
3443 IS_NON_TYPE is true. This new parameter is a parameter
3444 pack iff IS_PARAMETER_PACK is true. The location of PARM is in
3448 process_template_parm (tree list, location_t parm_loc, tree parm, bool is_non_type,
3449 bool is_parameter_pack)
3456 gcc_assert (TREE_CODE (parm) == TREE_LIST);
3457 defval = TREE_PURPOSE (parm);
3461 tree p = tree_last (list);
3463 if (p && TREE_VALUE (p) != error_mark_node)
3466 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
3467 idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
3469 idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
3479 parm = TREE_VALUE (parm);
3481 SET_DECL_TEMPLATE_PARM_P (parm);
3483 if (TREE_TYPE (parm) == error_mark_node)
3485 err_parm_list = build_tree_list (defval, parm);
3486 TREE_VALUE (err_parm_list) = error_mark_node;
3487 return chainon (list, err_parm_list);
3493 The top-level cv-qualifiers on the template-parameter are
3494 ignored when determining its type. */
3495 TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
3496 if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
3498 err_parm_list = build_tree_list (defval, parm);
3499 TREE_VALUE (err_parm_list) = error_mark_node;
3500 return chainon (list, err_parm_list);
3503 if (uses_parameter_packs (TREE_TYPE (parm)) && !is_parameter_pack)
3505 /* This template parameter is not a parameter pack, but it
3506 should be. Complain about "bare" parameter packs. */
3507 check_for_bare_parameter_packs (TREE_TYPE (parm));
3509 /* Recover by calling this a parameter pack. */
3510 is_parameter_pack = true;
3514 /* A template parameter is not modifiable. */
3515 TREE_CONSTANT (parm) = 1;
3516 TREE_READONLY (parm) = 1;
3517 decl = build_decl (parm_loc,
3518 CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
3519 TREE_CONSTANT (decl) = 1;
3520 TREE_READONLY (decl) = 1;
3521 DECL_INITIAL (parm) = DECL_INITIAL (decl)
3522 = build_template_parm_index (idx, processing_template_decl,
3523 processing_template_decl,
3524 decl, TREE_TYPE (parm));
3526 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm))
3527 = is_parameter_pack;
3532 parm = TREE_VALUE (TREE_VALUE (parm));
3534 if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
3536 t = cxx_make_type (TEMPLATE_TEMPLATE_PARM);
3537 /* This is for distinguishing between real templates and template
3538 template parameters */
3539 TREE_TYPE (parm) = t;
3540 TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t;
3545 t = cxx_make_type (TEMPLATE_TYPE_PARM);
3546 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3547 decl = build_decl (parm_loc,
3548 TYPE_DECL, parm, t);
3551 TYPE_NAME (t) = decl;
3552 TYPE_STUB_DECL (t) = decl;
3554 TEMPLATE_TYPE_PARM_INDEX (t)
3555 = build_template_parm_index (idx, processing_template_decl,
3556 processing_template_decl,
3557 decl, TREE_TYPE (parm));
3558 TEMPLATE_TYPE_PARAMETER_PACK (t) = is_parameter_pack;
3559 TYPE_CANONICAL (t) = canonical_type_parameter (t);
3561 DECL_ARTIFICIAL (decl) = 1;
3562 SET_DECL_TEMPLATE_PARM_P (decl);
3564 parm = build_tree_list (defval, parm);
3565 return chainon (list, parm);
3568 /* The end of a template parameter list has been reached. Process the
3569 tree list into a parameter vector, converting each parameter into a more
3570 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3574 end_template_parm_list (tree parms)
3578 tree saved_parmlist = make_tree_vec (list_length (parms));
3580 current_template_parms
3581 = tree_cons (size_int (processing_template_decl),
3582 saved_parmlist, current_template_parms);
3584 for (parm = parms, nparms = 0; parm; parm = next, nparms++)
3586 next = TREE_CHAIN (parm);
3587 TREE_VEC_ELT (saved_parmlist, nparms) = parm;
3588 TREE_CHAIN (parm) = NULL_TREE;
3589 if (TREE_CODE (TREE_VALUE (parm)) == TYPE_DECL)
3590 TEMPLATE_TYPE_PARM_SIBLING_PARMS (TREE_TYPE (TREE_VALUE (parm))) =
3591 current_template_parms;
3594 --processing_template_parmlist;
3596 return saved_parmlist;
3599 /* end_template_decl is called after a template declaration is seen. */
3602 end_template_decl (void)
3604 reset_specialization ();
3606 if (! processing_template_decl)
3609 /* This matches the pushlevel in begin_template_parm_list. */
3612 --processing_template_decl;
3613 current_template_parms = TREE_CHAIN (current_template_parms);
3616 /* Within the declaration of a template, return all levels of template
3617 parameters that apply. The template parameters are represented as
3618 a TREE_VEC, in the form documented in cp-tree.h for template
3622 current_template_args (void)
3625 tree args = NULL_TREE;
3626 int length = TMPL_PARMS_DEPTH (current_template_parms);
3629 /* If there is only one level of template parameters, we do not
3630 create a TREE_VEC of TREE_VECs. Instead, we return a single
3631 TREE_VEC containing the arguments. */
3633 args = make_tree_vec (length);
3635 for (header = current_template_parms; header; header = TREE_CHAIN (header))
3637 tree a = copy_node (TREE_VALUE (header));
3640 TREE_TYPE (a) = NULL_TREE;
3641 for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
3643 tree t = TREE_VEC_ELT (a, i);
3645 /* T will be a list if we are called from within a
3646 begin/end_template_parm_list pair, but a vector directly
3647 if within a begin/end_member_template_processing pair. */
3648 if (TREE_CODE (t) == TREE_LIST)
3652 if (!error_operand_p (t))
3654 if (TREE_CODE (t) == TYPE_DECL
3655 || TREE_CODE (t) == TEMPLATE_DECL)
3659 if (TEMPLATE_TYPE_PARAMETER_PACK (t))
3661 /* Turn this argument into a TYPE_ARGUMENT_PACK
3662 with a single element, which expands T. */
3663 tree vec = make_tree_vec (1);
3664 #ifdef ENABLE_CHECKING
3665 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3666 (vec, TREE_VEC_LENGTH (vec));
3668 TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
3670 t = cxx_make_type (TYPE_ARGUMENT_PACK);
3671 SET_ARGUMENT_PACK_ARGS (t, vec);
3676 t = DECL_INITIAL (t);
3678 if (TEMPLATE_PARM_PARAMETER_PACK (t))
3680 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3681 with a single element, which expands T. */
3682 tree vec = make_tree_vec (1);
3683 tree type = TREE_TYPE (TEMPLATE_PARM_DECL (t));
3684 #ifdef ENABLE_CHECKING
3685 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3686 (vec, TREE_VEC_LENGTH (vec));
3688 TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
3690 t = make_node (NONTYPE_ARGUMENT_PACK);
3691 SET_ARGUMENT_PACK_ARGS (t, vec);
3692 TREE_TYPE (t) = type;
3695 TREE_VEC_ELT (a, i) = t;
3700 #ifdef ENABLE_CHECKING
3701 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a, TREE_VEC_LENGTH (a));
3705 TREE_VEC_ELT (args, --l) = a;
3713 /* Update the declared TYPE by doing any lookups which were thought to be
3714 dependent, but are not now that we know the SCOPE of the declarator. */
3717 maybe_update_decl_type (tree orig_type, tree scope)
3719 tree type = orig_type;
3721 if (type == NULL_TREE)
3724 if (TREE_CODE (orig_type) == TYPE_DECL)
3725 type = TREE_TYPE (type);
3727 if (scope && TYPE_P (scope) && dependent_type_p (scope)
3728 && dependent_type_p (type)
3729 /* Don't bother building up the args in this case. */
3730 && TREE_CODE (type) != TEMPLATE_TYPE_PARM)
3732 /* tsubst in the args corresponding to the template parameters,
3733 including auto if present. Most things will be unchanged, but
3734 make_typename_type and tsubst_qualified_id will resolve
3735 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
3736 tree args = current_template_args ();
3737 tree auto_node = type_uses_auto (type);
3741 tree auto_vec = make_tree_vec (1);
3742 TREE_VEC_ELT (auto_vec, 0) = auto_node;
3743 args = add_to_template_args (args, auto_vec);
3745 pushed = push_scope (scope);
3746 type = tsubst (type, args, tf_warning_or_error, NULL_TREE);
3751 if (type == error_mark_node)
3754 if (TREE_CODE (orig_type) == TYPE_DECL)
3756 if (same_type_p (type, TREE_TYPE (orig_type)))
3759 type = TYPE_NAME (type);
3764 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
3765 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
3766 a member template. Used by push_template_decl below. */
3769 build_template_decl (tree decl, tree parms, bool member_template_p)
3771 tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
3772 DECL_TEMPLATE_PARMS (tmpl) = parms;
3773 DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
3774 DECL_MEMBER_TEMPLATE_P (tmpl) = member_template_p;
3779 struct template_parm_data
3781 /* The level of the template parameters we are currently
3785 /* The index of the specialization argument we are currently
3789 /* An array whose size is the number of template parameters. The
3790 elements are nonzero if the parameter has been used in any one
3791 of the arguments processed so far. */
3794 /* An array whose size is the number of template arguments. The
3795 elements are nonzero if the argument makes use of template
3796 parameters of this level. */
3797 int* arg_uses_template_parms;
3800 /* Subroutine of push_template_decl used to see if each template
3801 parameter in a partial specialization is used in the explicit
3802 argument list. If T is of the LEVEL given in DATA (which is
3803 treated as a template_parm_data*), then DATA->PARMS is marked
3807 mark_template_parm (tree t, void* data)
3811 struct template_parm_data* tpd = (struct template_parm_data*) data;
3813 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
3815 level = TEMPLATE_PARM_LEVEL (t);
3816 idx = TEMPLATE_PARM_IDX (t);
3820 level = TEMPLATE_TYPE_LEVEL (t);
3821 idx = TEMPLATE_TYPE_IDX (t);
3824 if (level == tpd->level)
3826 tpd->parms[idx] = 1;
3827 tpd->arg_uses_template_parms[tpd->current_arg] = 1;
3830 /* Return zero so that for_each_template_parm will continue the
3831 traversal of the tree; we want to mark *every* template parm. */
3835 /* Process the partial specialization DECL. */
3838 process_partial_specialization (tree decl)
3840 tree type = TREE_TYPE (decl);
3841 tree maintmpl = CLASSTYPE_TI_TEMPLATE (type);
3842 tree specargs = CLASSTYPE_TI_ARGS (type);
3843 tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
3844 tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
3847 int nargs = TREE_VEC_LENGTH (inner_args);
3850 bool did_error_intro = false;
3851 struct template_parm_data tpd;
3852 struct template_parm_data tpd2;
3854 gcc_assert (current_template_parms);
3856 inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
3857 ntparms = TREE_VEC_LENGTH (inner_parms);
3859 /* We check that each of the template parameters given in the
3860 partial specialization is used in the argument list to the
3861 specialization. For example:
3863 template <class T> struct S;
3864 template <class T> struct S<T*>;
3866 The second declaration is OK because `T*' uses the template
3867 parameter T, whereas
3869 template <class T> struct S<int>;
3871 is no good. Even trickier is:
3882 The S2<T> declaration is actually invalid; it is a
3883 full-specialization. Of course,
3886 struct S2<T (*)(U)>;
3888 or some such would have been OK. */
3889 tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
3890 tpd.parms = XALLOCAVEC (int, ntparms);
3891 memset (tpd.parms, 0, sizeof (int) * ntparms);
3893 tpd.arg_uses_template_parms = XALLOCAVEC (int, nargs);
3894 memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
3895 for (i = 0; i < nargs; ++i)
3897 tpd.current_arg = i;
3898 for_each_template_parm (TREE_VEC_ELT (inner_args, i),
3899 &mark_template_parm,
3902 /*include_nondeduced_p=*/false);
3904 for (i = 0; i < ntparms; ++i)
3905 if (tpd.parms[i] == 0)
3907 /* One of the template parms was not used in the
3909 if (!did_error_intro)
3911 error ("template parameters not used in partial specialization:");
3912 did_error_intro = true;
3915 error (" %qD", TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
3918 if (did_error_intro)
3919 return error_mark_node;
3921 /* [temp.class.spec]
3923 The argument list of the specialization shall not be identical to
3924 the implicit argument list of the primary template. */
3925 if (comp_template_args
3927 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
3929 error ("partial specialization %qT does not specialize any template arguments", type);
3931 /* [temp.class.spec]
3933 A partially specialized non-type argument expression shall not
3934 involve template parameters of the partial specialization except
3935 when the argument expression is a simple identifier.
3937 The type of a template parameter corresponding to a specialized
3938 non-type argument shall not be dependent on a parameter of the
3941 Also, we verify that pack expansions only occur at the
3942 end of the argument list. */
3943 gcc_assert (nargs == DECL_NTPARMS (maintmpl));
3945 for (i = 0; i < nargs; ++i)
3947 tree parm = TREE_VALUE (TREE_VEC_ELT (main_inner_parms, i));
3948 tree arg = TREE_VEC_ELT (inner_args, i);
3949 tree packed_args = NULL_TREE;
3952 if (ARGUMENT_PACK_P (arg))
3954 /* Extract the arguments from the argument pack. We'll be
3955 iterating over these in the following loop. */
3956 packed_args = ARGUMENT_PACK_ARGS (arg);
3957 len = TREE_VEC_LENGTH (packed_args);
3960 for (j = 0; j < len; j++)
3963 /* Get the Jth argument in the parameter pack. */
3964 arg = TREE_VEC_ELT (packed_args, j);
3966 if (PACK_EXPANSION_P (arg))
3968 /* Pack expansions must come at the end of the
3970 if ((packed_args && j < len - 1)
3971 || (!packed_args && i < nargs - 1))
3973 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
3974 error ("parameter pack argument %qE must be at the "
3975 "end of the template argument list", arg);
3977 error ("parameter pack argument %qT must be at the "
3978 "end of the template argument list", arg);
3982 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
3983 /* We only care about the pattern. */
3984 arg = PACK_EXPANSION_PATTERN (arg);
3986 if (/* These first two lines are the `non-type' bit. */
3988 && TREE_CODE (arg) != TEMPLATE_DECL
3989 /* This next line is the `argument expression is not just a
3990 simple identifier' condition and also the `specialized
3991 non-type argument' bit. */
3992 && TREE_CODE (arg) != TEMPLATE_PARM_INDEX)
3994 if ((!packed_args && tpd.arg_uses_template_parms[i])
3995 || (packed_args && uses_template_parms (arg)))
3996 error ("template argument %qE involves template parameter(s)",
4000 /* Look at the corresponding template parameter,
4001 marking which template parameters its type depends
4003 tree type = TREE_TYPE (parm);
4007 /* We haven't yet initialized TPD2. Do so now. */
4008 tpd2.arg_uses_template_parms = XALLOCAVEC (int, nargs);
4009 /* The number of parameters here is the number in the
4010 main template, which, as checked in the assertion
4012 tpd2.parms = XALLOCAVEC (int, nargs);
4014 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
4017 /* Mark the template parameters. But this time, we're
4018 looking for the template parameters of the main
4019 template, not in the specialization. */
4020 tpd2.current_arg = i;
4021 tpd2.arg_uses_template_parms[i] = 0;
4022 memset (tpd2.parms, 0, sizeof (int) * nargs);
4023 for_each_template_parm (type,
4024 &mark_template_parm,
4027 /*include_nondeduced_p=*/false);
4029 if (tpd2.arg_uses_template_parms [i])
4031 /* The type depended on some template parameters.
4032 If they are fully specialized in the
4033 specialization, that's OK. */
4036 for (j = 0; j < nargs; ++j)
4037 if (tpd2.parms[j] != 0
4038 && tpd.arg_uses_template_parms [j])
4041 error_n (input_location, count,
4042 "type %qT of template argument %qE depends "
4043 "on a template parameter",
4044 "type %qT of template argument %qE depends "
4045 "on template parameters",
4054 /* We should only get here once. */
4055 gcc_assert (!COMPLETE_TYPE_P (type));
4057 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
4058 = tree_cons (specargs, inner_parms,
4059 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
4060 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
4062 for (inst = DECL_TEMPLATE_INSTANTIATIONS (maintmpl); inst;
4063 inst = TREE_CHAIN (inst))
4065 tree inst_type = TREE_VALUE (inst);
4066 if (COMPLETE_TYPE_P (inst_type)
4067 && CLASSTYPE_IMPLICIT_INSTANTIATION (inst_type))
4069 tree spec = most_specialized_class (inst_type, maintmpl, tf_none);
4070 if (spec && TREE_TYPE (spec) == type)
4071 permerror (input_location,
4072 "partial specialization of %qT after instantiation "
4073 "of %qT", type, inst_type);
4080 /* Check that a template declaration's use of default arguments and
4081 parameter packs is not invalid. Here, PARMS are the template
4082 parameters. IS_PRIMARY is nonzero if DECL is the thing declared by
4083 a primary template. IS_PARTIAL is nonzero if DECL is a partial
4087 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4088 declaration (but not a definition); 1 indicates a declaration, 2
4089 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4090 emitted for extraneous default arguments.
4092 Returns TRUE if there were no errors found, FALSE otherwise. */
4095 check_default_tmpl_args (tree decl, tree parms, int is_primary,
4096 int is_partial, int is_friend_decl)
4099 int last_level_to_check;
4101 bool no_errors = true;
4105 A default template-argument shall not be specified in a
4106 function template declaration or a function template definition, nor
4107 in the template-parameter-list of the definition of a member of a
4110 if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
4111 /* You can't have a function template declaration in a local
4112 scope, nor you can you define a member of a class template in a
4116 if (current_class_type
4117 && !TYPE_BEING_DEFINED (current_class_type)
4118 && DECL_LANG_SPECIFIC (decl)
4119 && DECL_DECLARES_FUNCTION_P (decl)
4120 /* If this is either a friend defined in the scope of the class
4121 or a member function. */
4122 && (DECL_FUNCTION_MEMBER_P (decl)
4123 ? same_type_p (DECL_CONTEXT (decl), current_class_type)
4124 : DECL_FRIEND_CONTEXT (decl)
4125 ? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type)
4127 /* And, if it was a member function, it really was defined in
4128 the scope of the class. */
4129 && (!DECL_FUNCTION_MEMBER_P (decl)
4130 || DECL_INITIALIZED_IN_CLASS_P (decl)))
4131 /* We already checked these parameters when the template was
4132 declared, so there's no need to do it again now. This function
4133 was defined in class scope, but we're processing it's body now
4134 that the class is complete. */
4137 /* Core issue 226 (C++0x only): the following only applies to class
4139 if ((cxx_dialect == cxx98) || TREE_CODE (decl) != FUNCTION_DECL)
4143 If a template-parameter has a default template-argument, all
4144 subsequent template-parameters shall have a default
4145 template-argument supplied. */
4146 for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
4148 tree inner_parms = TREE_VALUE (parm_level);
4149 int ntparms = TREE_VEC_LENGTH (inner_parms);
4150 int seen_def_arg_p = 0;
4153 for (i = 0; i < ntparms; ++i)
4155 tree parm = TREE_VEC_ELT (inner_parms, i);
4157 if (parm == error_mark_node)
4160 if (TREE_PURPOSE (parm))
4162 else if (seen_def_arg_p
4163 && !template_parameter_pack_p (TREE_VALUE (parm)))
4165 error ("no default argument for %qD", TREE_VALUE (parm));
4166 /* For better subsequent error-recovery, we indicate that
4167 there should have been a default argument. */
4168 TREE_PURPOSE (parm) = error_mark_node;
4174 /* Don't complain about an enclosing partial
4176 && parm_level == parms
4177 && TREE_CODE (decl) == TYPE_DECL
4179 && template_parameter_pack_p (TREE_VALUE (parm)))
4181 /* A primary class template can only have one
4182 parameter pack, at the end of the template
4185 if (TREE_CODE (TREE_VALUE (parm)) == PARM_DECL)
4186 error ("parameter pack %qE must be at the end of the"
4187 " template parameter list", TREE_VALUE (parm));
4189 error ("parameter pack %qT must be at the end of the"
4190 " template parameter list",
4191 TREE_TYPE (TREE_VALUE (parm)));
4193 TREE_VALUE (TREE_VEC_ELT (inner_parms, i))
4201 if (((cxx_dialect == cxx98) && TREE_CODE (decl) != TYPE_DECL)
4205 /* For an ordinary class template, default template arguments are
4206 allowed at the innermost level, e.g.:
4207 template <class T = int>
4209 but, in a partial specialization, they're not allowed even
4210 there, as we have in [temp.class.spec]:
4212 The template parameter list of a specialization shall not
4213 contain default template argument values.
4215 So, for a partial specialization, or for a function template
4216 (in C++98/C++03), we look at all of them. */
4219 /* But, for a primary class template that is not a partial
4220 specialization we look at all template parameters except the
4222 parms = TREE_CHAIN (parms);
4224 /* Figure out what error message to issue. */
4225 if (is_friend_decl == 2)
4226 msg = G_("default template arguments may not be used in function template "
4227 "friend re-declaration");
4228 else if (is_friend_decl)
4229 msg = G_("default template arguments may not be used in function template "
4230 "friend declarations");
4231 else if (TREE_CODE (decl) == FUNCTION_DECL && (cxx_dialect == cxx98))
4232 msg = G_("default template arguments may not be used in function templates "
4233 "without -std=c++0x or -std=gnu++0x");
4234 else if (is_partial)
4235 msg = G_("default template arguments may not be used in "
4236 "partial specializations");
4238 msg = G_("default argument for template parameter for class enclosing %qD");
4240 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
4241 /* If we're inside a class definition, there's no need to
4242 examine the parameters to the class itself. On the one
4243 hand, they will be checked when the class is defined, and,
4244 on the other, default arguments are valid in things like:
4245 template <class T = double>
4246 struct S { template <class U> void f(U); };
4247 Here the default argument for `S' has no bearing on the
4248 declaration of `f'. */
4249 last_level_to_check = template_class_depth (current_class_type) + 1;
4251 /* Check everything. */
4252 last_level_to_check = 0;
4254 for (parm_level = parms;
4255 parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
4256 parm_level = TREE_CHAIN (parm_level))
4258 tree inner_parms = TREE_VALUE (parm_level);
4262 ntparms = TREE_VEC_LENGTH (inner_parms);
4263 for (i = 0; i < ntparms; ++i)
4265 if (TREE_VEC_ELT (inner_parms, i) == error_mark_node)
4268 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
4273 if (is_friend_decl == 2)
4280 /* Clear out the default argument so that we are not
4282 TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
4286 /* At this point, if we're still interested in issuing messages,
4287 they must apply to classes surrounding the object declared. */
4289 msg = G_("default argument for template parameter for class "
4296 /* Worker for push_template_decl_real, called via
4297 for_each_template_parm. DATA is really an int, indicating the
4298 level of the parameters we are interested in. If T is a template
4299 parameter of that level, return nonzero. */
4302 template_parm_this_level_p (tree t, void* data)
4304 int this_level = *(int *)data;
4307 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
4308 level = TEMPLATE_PARM_LEVEL (t);
4310 level = TEMPLATE_TYPE_LEVEL (t);
4311 return level == this_level;
4314 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
4315 parameters given by current_template_args, or reuses a
4316 previously existing one, if appropriate. Returns the DECL, or an
4317 equivalent one, if it is replaced via a call to duplicate_decls.
4319 If IS_FRIEND is true, DECL is a friend declaration. */
4322 push_template_decl_real (tree decl, bool is_friend)
4330 int new_template_p = 0;
4331 /* True if the template is a member template, in the sense of
4333 bool member_template_p = false;
4335 if (decl == error_mark_node || !current_template_parms)
4336 return error_mark_node;
4338 /* See if this is a partial specialization. */
4339 is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl)
4340 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
4341 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)));
4343 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl))
4347 /* For a friend, we want the context of the friend function, not
4348 the type of which it is a friend. */
4349 ctx = DECL_CONTEXT (decl);
4350 else if (CP_DECL_CONTEXT (decl)
4351 && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4352 /* In the case of a virtual function, we want the class in which
4354 ctx = CP_DECL_CONTEXT (decl);
4356 /* Otherwise, if we're currently defining some class, the DECL
4357 is assumed to be a member of the class. */
4358 ctx = current_scope ();
4360 if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
4363 if (!DECL_CONTEXT (decl))
4364 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
4366 /* See if this is a primary template. */
4367 if (is_friend && ctx)
4368 /* A friend template that specifies a class context, i.e.
4369 template <typename T> friend void A<T>::f();
4373 primary = template_parm_scope_p ();
4377 if (DECL_CLASS_SCOPE_P (decl))
4378 member_template_p = true;
4379 if (TREE_CODE (decl) == TYPE_DECL
4380 && ANON_AGGRNAME_P (DECL_NAME (decl)))
4382 error ("template class without a name");
4383 return error_mark_node;
4385 else if (TREE_CODE (decl) == FUNCTION_DECL)
4387 if (DECL_DESTRUCTOR_P (decl))
4391 A destructor shall not be a member template. */
4392 error ("destructor %qD declared as member template", decl);
4393 return error_mark_node;
4395 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl))
4396 && (!TYPE_ARG_TYPES (TREE_TYPE (decl))
4397 || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
4398 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
4399 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl))))
4400 == void_list_node)))
4402 /* [basic.stc.dynamic.allocation]
4404 An allocation function can be a function
4405 template. ... Template allocation functions shall
4406 have two or more parameters. */
4407 error ("invalid template declaration of %qD", decl);
4408 return error_mark_node;
4411 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
4412 && CLASS_TYPE_P (TREE_TYPE (decl)))
4416 error ("template declaration of %q#D", decl);
4417 return error_mark_node;
4421 /* Check to see that the rules regarding the use of default
4422 arguments are not being violated. */
4423 check_default_tmpl_args (decl, current_template_parms,
4424 primary, is_partial, /*is_friend_decl=*/0);
4426 /* Ensure that there are no parameter packs in the type of this
4427 declaration that have not been expanded. */
4428 if (TREE_CODE (decl) == FUNCTION_DECL)
4430 /* Check each of the arguments individually to see if there are
4431 any bare parameter packs. */
4432 tree type = TREE_TYPE (decl);
4433 tree arg = DECL_ARGUMENTS (decl);
4434 tree argtype = TYPE_ARG_TYPES (type);
4436 while (arg && argtype)
4438 if (!FUNCTION_PARAMETER_PACK_P (arg)
4439 && check_for_bare_parameter_packs (TREE_TYPE (arg)))
4441 /* This is a PARM_DECL that contains unexpanded parameter
4442 packs. We have already complained about this in the
4443 check_for_bare_parameter_packs call, so just replace
4444 these types with ERROR_MARK_NODE. */
4445 TREE_TYPE (arg) = error_mark_node;
4446 TREE_VALUE (argtype) = error_mark_node;
4449 arg = DECL_CHAIN (arg);
4450 argtype = TREE_CHAIN (argtype);
4453 /* Check for bare parameter packs in the return type and the
4454 exception specifiers. */
4455 if (check_for_bare_parameter_packs (TREE_TYPE (type)))
4456 /* Errors were already issued, set return type to int
4457 as the frontend doesn't expect error_mark_node as
4459 TREE_TYPE (type) = integer_type_node;
4460 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type)))
4461 TYPE_RAISES_EXCEPTIONS (type) = NULL_TREE;
4463 else if (check_for_bare_parameter_packs (TREE_TYPE (decl)))
4465 TREE_TYPE (decl) = error_mark_node;
4466 return error_mark_node;
4470 return process_partial_specialization (decl);
4472 args = current_template_args ();
4475 || TREE_CODE (ctx) == FUNCTION_DECL
4476 || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
4477 || (is_friend && !DECL_TEMPLATE_INFO (decl)))
4479 if (DECL_LANG_SPECIFIC (decl)
4480 && DECL_TEMPLATE_INFO (decl)
4481 && DECL_TI_TEMPLATE (decl))
4482 tmpl = DECL_TI_TEMPLATE (decl);
4483 /* If DECL is a TYPE_DECL for a class-template, then there won't
4484 be DECL_LANG_SPECIFIC. The information equivalent to
4485 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
4486 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
4487 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
4488 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
4490 /* Since a template declaration already existed for this
4491 class-type, we must be redeclaring it here. Make sure
4492 that the redeclaration is valid. */
4493 redeclare_class_template (TREE_TYPE (decl),
4494 current_template_parms);
4495 /* We don't need to create a new TEMPLATE_DECL; just use the
4496 one we already had. */
4497 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
4501 tmpl = build_template_decl (decl, current_template_parms,
4505 if (DECL_LANG_SPECIFIC (decl)
4506 && DECL_TEMPLATE_SPECIALIZATION (decl))
4508 /* A specialization of a member template of a template
4510 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
4511 DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
4512 DECL_TEMPLATE_INFO (decl) = NULL_TREE;
4518 tree a, t, current, parms;
4520 tree tinfo = get_template_info (decl);
4524 error ("template definition of non-template %q#D", decl);
4525 return error_mark_node;
4528 tmpl = TI_TEMPLATE (tinfo);
4530 if (DECL_FUNCTION_TEMPLATE_P (tmpl)
4531 && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
4532 && DECL_TEMPLATE_SPECIALIZATION (decl)
4533 && DECL_MEMBER_TEMPLATE_P (tmpl))
4537 /* The declaration is a specialization of a member
4538 template, declared outside the class. Therefore, the
4539 innermost template arguments will be NULL, so we
4540 replace them with the arguments determined by the
4541 earlier call to check_explicit_specialization. */
4542 args = DECL_TI_ARGS (decl);
4545 = build_template_decl (decl, current_template_parms,
4547 DECL_TEMPLATE_RESULT (new_tmpl) = decl;
4548 TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
4549 DECL_TI_TEMPLATE (decl) = new_tmpl;
4550 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
4551 DECL_TEMPLATE_INFO (new_tmpl)
4552 = build_template_info (tmpl, args);
4554 register_specialization (new_tmpl,
4555 most_general_template (tmpl),
4561 /* Make sure the template headers we got make sense. */
4563 parms = DECL_TEMPLATE_PARMS (tmpl);
4564 i = TMPL_PARMS_DEPTH (parms);
4565 if (TMPL_ARGS_DEPTH (args) != i)
4567 error ("expected %d levels of template parms for %q#D, got %d",
4568 i, decl, TMPL_ARGS_DEPTH (args));
4571 for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
4573 a = TMPL_ARGS_LEVEL (args, i);
4574 t = INNERMOST_TEMPLATE_PARMS (parms);
4576 if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
4578 if (current == decl)
4579 error ("got %d template parameters for %q#D",
4580 TREE_VEC_LENGTH (a), decl);
4582 error ("got %d template parameters for %q#T",
4583 TREE_VEC_LENGTH (a), current);
4584 error (" but %d required", TREE_VEC_LENGTH (t));
4585 return error_mark_node;
4588 if (current == decl)
4590 else if (current == NULL_TREE)
4591 /* Can happen in erroneous input. */
4594 current = (TYPE_P (current)
4595 ? TYPE_CONTEXT (current)
4596 : DECL_CONTEXT (current));
4599 /* Check that the parms are used in the appropriate qualifying scopes
4600 in the declarator. */
4601 if (!comp_template_args
4603 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl)))))
4606 template arguments to %qD do not match original template %qD",
4607 decl, DECL_TEMPLATE_RESULT (tmpl));
4608 if (!uses_template_parms (TI_ARGS (tinfo)))
4609 inform (input_location, "use template<> for an explicit specialization");
4610 /* Avoid crash in import_export_decl. */
4611 DECL_INTERFACE_KNOWN (decl) = 1;
4612 return error_mark_node;
4616 DECL_TEMPLATE_RESULT (tmpl) = decl;
4617 TREE_TYPE (tmpl) = TREE_TYPE (decl);
4619 /* Push template declarations for global functions and types. Note
4620 that we do not try to push a global template friend declared in a
4621 template class; such a thing may well depend on the template
4622 parameters of the class. */
4623 if (new_template_p && !ctx
4624 && !(is_friend && template_class_depth (current_class_type) > 0))
4626 tmpl = pushdecl_namespace_level (tmpl, is_friend);
4627 if (tmpl == error_mark_node)
4628 return error_mark_node;
4630 /* Hide template friend classes that haven't been declared yet. */
4631 if (is_friend && TREE_CODE (decl) == TYPE_DECL)
4633 DECL_ANTICIPATED (tmpl) = 1;
4634 DECL_FRIEND_P (tmpl) = 1;
4640 tree parms = DECL_TEMPLATE_PARMS (tmpl);
4643 DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
4644 if (DECL_CONV_FN_P (tmpl))
4646 int depth = TMPL_PARMS_DEPTH (parms);
4648 /* It is a conversion operator. See if the type converted to
4649 depends on innermost template operands. */
4651 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl)),
4653 DECL_TEMPLATE_CONV_FN_P (tmpl) = 1;
4656 /* Give template template parms a DECL_CONTEXT of the template
4657 for which they are a parameter. */
4658 parms = INNERMOST_TEMPLATE_PARMS (parms);
4659 for (i = TREE_VEC_LENGTH (parms) - 1; i >= 0; --i)
4661 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
4662 if (TREE_CODE (parm) == TEMPLATE_DECL)
4663 DECL_CONTEXT (parm) = tmpl;
4667 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
4668 back to its most general template. If TMPL is a specialization,
4669 ARGS may only have the innermost set of arguments. Add the missing
4670 argument levels if necessary. */
4671 if (DECL_TEMPLATE_INFO (tmpl))
4672 args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);
4674 info = build_template_info (tmpl, args);
4676 if (DECL_IMPLICIT_TYPEDEF_P (decl))
4677 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
4678 else if (DECL_LANG_SPECIFIC (decl))
4679 DECL_TEMPLATE_INFO (decl) = info;
4681 return DECL_TEMPLATE_RESULT (tmpl);
4685 push_template_decl (tree decl)
4687 return push_template_decl_real (decl, false);
4690 /* Called when a class template TYPE is redeclared with the indicated
4691 template PARMS, e.g.:
4693 template <class T> struct S;
4694 template <class T> struct S {}; */
4697 redeclare_class_template (tree type, tree parms)
4703 if (!TYPE_TEMPLATE_INFO (type))
4705 error ("%qT is not a template type", type);
4709 tmpl = TYPE_TI_TEMPLATE (type);
4710 if (!PRIMARY_TEMPLATE_P (tmpl))
4711 /* The type is nested in some template class. Nothing to worry
4712 about here; there are no new template parameters for the nested
4718 error ("template specifiers not specified in declaration of %qD",
4723 parms = INNERMOST_TEMPLATE_PARMS (parms);
4724 tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
4726 if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
4728 error_n (input_location, TREE_VEC_LENGTH (parms),
4729 "redeclared with %d template parameter",
4730 "redeclared with %d template parameters",
4731 TREE_VEC_LENGTH (parms));
4732 inform_n (input_location, TREE_VEC_LENGTH (tmpl_parms),
4733 "previous declaration %q+D used %d template parameter",
4734 "previous declaration %q+D used %d template parameters",
4735 tmpl, TREE_VEC_LENGTH (tmpl_parms));
4739 for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
4746 if (TREE_VEC_ELT (tmpl_parms, i) == error_mark_node
4747 || TREE_VEC_ELT (parms, i) == error_mark_node)
4750 tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
4751 if (tmpl_parm == error_mark_node)
4754 parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
4755 tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i));
4756 parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
4758 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
4760 if (TREE_CODE (tmpl_parm) != TREE_CODE (parm)
4761 || (TREE_CODE (tmpl_parm) != TYPE_DECL
4762 && !same_type_p (TREE_TYPE (tmpl_parm), TREE_TYPE (parm)))
4763 || (TREE_CODE (tmpl_parm) != PARM_DECL
4764 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm))
4765 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm))))
4766 || (TREE_CODE (tmpl_parm) == PARM_DECL
4767 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm))
4768 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))))
4770 error ("template parameter %q+#D", tmpl_parm);
4771 error ("redeclared here as %q#D", parm);
4775 if (tmpl_default != NULL_TREE && parm_default != NULL_TREE)
4777 /* We have in [temp.param]:
4779 A template-parameter may not be given default arguments
4780 by two different declarations in the same scope. */
4781 error_at (input_location, "redefinition of default argument for %q#D", parm);
4782 inform (DECL_SOURCE_LOCATION (tmpl_parm),
4783 "original definition appeared here");
4787 if (parm_default != NULL_TREE)
4788 /* Update the previous template parameters (which are the ones
4789 that will really count) with the new default value. */
4790 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default;
4791 else if (tmpl_default != NULL_TREE)
4792 /* Update the new parameters, too; they'll be used as the
4793 parameters for any members. */
4794 TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default;
4800 /* Simplify EXPR if it is a non-dependent expression. Returns the
4801 (possibly simplified) expression. */
4804 fold_non_dependent_expr (tree expr)
4806 if (expr == NULL_TREE)
4809 /* If we're in a template, but EXPR isn't value dependent, simplify
4810 it. We're supposed to treat:
4812 template <typename T> void f(T[1 + 1]);
4813 template <typename T> void f(T[2]);
4815 as two declarations of the same function, for example. */
4816 if (processing_template_decl
4817 && !type_dependent_expression_p (expr)
4818 && !value_dependent_expression_p (expr))
4820 HOST_WIDE_INT saved_processing_template_decl;
4822 saved_processing_template_decl = processing_template_decl;
4823 processing_template_decl = 0;
4824 expr = tsubst_copy_and_build (expr,
4827 /*in_decl=*/NULL_TREE,
4828 /*function_p=*/false,
4829 /*integral_constant_expression_p=*/true);
4830 processing_template_decl = saved_processing_template_decl;
4835 /* EXPR is an expression which is used in a constant-expression context.
4836 For instance, it could be a VAR_DECL with a constant initializer.
4837 Extract the innermost constant expression.
4839 This is basically a more powerful version of
4840 integral_constant_value, which can be used also in templates where
4841 initializers can maintain a syntactic rather than semantic form
4842 (even if they are non-dependent, for access-checking purposes). */
4845 fold_decl_constant_value (tree expr)
4847 tree const_expr = expr;
4850 expr = fold_non_dependent_expr (const_expr);
4851 const_expr = integral_constant_value (expr);
4853 while (expr != const_expr);
4858 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
4859 must be a function or a pointer-to-function type, as specified
4860 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
4861 and check that the resulting function has external linkage. */
4864 convert_nontype_argument_function (tree type, tree expr)
4869 fn = instantiate_type (type, fns, tf_none);
4870 if (fn == error_mark_node)
4871 return error_mark_node;
4874 if (TREE_CODE (fn_no_ptr) == ADDR_EXPR)
4875 fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0);
4876 if (TREE_CODE (fn_no_ptr) == BASELINK)
4877 fn_no_ptr = BASELINK_FUNCTIONS (fn_no_ptr);
4879 /* [temp.arg.nontype]/1
4881 A template-argument for a non-type, non-template template-parameter
4884 -- the address of an object or function with external linkage. */
4885 if (!DECL_EXTERNAL_LINKAGE_P (fn_no_ptr))
4887 error ("%qE is not a valid template argument for type %qT "
4888 "because function %qD has not external linkage",
4889 expr, type, fn_no_ptr);
4896 /* Subroutine of convert_nontype_argument.
4897 Check if EXPR of type TYPE is a valid pointer-to-member constant.
4898 Emit an error otherwise. */
4901 check_valid_ptrmem_cst_expr (tree type, tree expr)
4904 if (expr && (null_ptr_cst_p (expr) || TREE_CODE (expr) == PTRMEM_CST))
4906 error ("%qE is not a valid template argument for type %qT",
4908 error ("it must be a pointer-to-member of the form `&X::Y'");
4912 /* Returns TRUE iff the address of OP is value-dependent.
4914 14.6.2.4 [temp.dep.temp]:
4915 A non-integral non-type template-argument is dependent if its type is
4916 dependent or it has either of the following forms
4919 and contains a nested-name-specifier which specifies a class-name that
4920 names a dependent type.
4922 We generalize this to just say that the address of a member of a
4923 dependent class is value-dependent; the above doesn't cover the
4924 address of a static data member named with an unqualified-id. */
4927 has_value_dependent_address (tree op)
4929 /* We could use get_inner_reference here, but there's no need;
4930 this is only relevant for template non-type arguments, which
4931 can only be expressed as &id-expression. */
4934 tree ctx = CP_DECL_CONTEXT (op);
4935 if (TYPE_P (ctx) && dependent_type_p (ctx))
4942 /* Attempt to convert the non-type template parameter EXPR to the
4943 indicated TYPE. If the conversion is successful, return the
4944 converted value. If the conversion is unsuccessful, return
4945 NULL_TREE if we issued an error message, or error_mark_node if we
4946 did not. We issue error messages for out-and-out bad template
4947 parameters, but not simply because the conversion failed, since we
4948 might be just trying to do argument deduction. Both TYPE and EXPR
4949 must be non-dependent.
4951 The conversion follows the special rules described in
4952 [temp.arg.nontype], and it is much more strict than an implicit
4955 This function is called twice for each template argument (see
4956 lookup_template_class for a more accurate description of this
4957 problem). This means that we need to handle expressions which
4958 are not valid in a C++ source, but can be created from the
4959 first call (for instance, casts to perform conversions). These
4960 hacks can go away after we fix the double coercion problem. */
4963 convert_nontype_argument (tree type, tree expr)
4967 /* Detect immediately string literals as invalid non-type argument.
4968 This special-case is not needed for correctness (we would easily
4969 catch this later), but only to provide better diagnostic for this
4970 common user mistake. As suggested by DR 100, we do not mention
4971 linkage issues in the diagnostic as this is not the point. */
4972 if (TREE_CODE (expr) == STRING_CST)
4974 error ("%qE is not a valid template argument for type %qT "
4975 "because string literals can never be used in this context",
4980 /* Add the ADDR_EXPR now for the benefit of
4981 value_dependent_expression_p. */
4982 if (TYPE_PTROBV_P (type))
4983 expr = decay_conversion (expr);
4985 /* If we are in a template, EXPR may be non-dependent, but still
4986 have a syntactic, rather than semantic, form. For example, EXPR
4987 might be a SCOPE_REF, rather than the VAR_DECL to which the
4988 SCOPE_REF refers. Preserving the qualifying scope is necessary
4989 so that access checking can be performed when the template is
4990 instantiated -- but here we need the resolved form so that we can
4991 convert the argument. */
4992 if (TYPE_REF_OBJ_P (type)
4993 && has_value_dependent_address (expr))
4994 /* If we want the address and it's value-dependent, don't fold. */;
4996 expr = fold_non_dependent_expr (expr);
4997 if (error_operand_p (expr))
4998 return error_mark_node;
4999 expr_type = TREE_TYPE (expr);
5000 if (TREE_CODE (type) == REFERENCE_TYPE)
5001 expr = mark_lvalue_use (expr);
5003 expr = mark_rvalue_use (expr);
5005 /* HACK: Due to double coercion, we can get a
5006 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
5007 which is the tree that we built on the first call (see
5008 below when coercing to reference to object or to reference to
5009 function). We just strip everything and get to the arg.
5010 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
5012 if (TREE_CODE (expr) == NOP_EXPR)
5014 if (TYPE_REF_OBJ_P (type) || TYPE_REFFN_P (type))
5016 /* ??? Maybe we could use convert_from_reference here, but we
5017 would need to relax its constraints because the NOP_EXPR
5018 could actually change the type to something more cv-qualified,
5019 and this is not folded by convert_from_reference. */
5020 tree addr = TREE_OPERAND (expr, 0);
5021 gcc_assert (TREE_CODE (expr_type) == REFERENCE_TYPE);
5022 gcc_assert (TREE_CODE (addr) == ADDR_EXPR);
5023 gcc_assert (TREE_CODE (TREE_TYPE (addr)) == POINTER_TYPE);
5024 gcc_assert (same_type_ignoring_top_level_qualifiers_p
5025 (TREE_TYPE (expr_type),
5026 TREE_TYPE (TREE_TYPE (addr))));
5028 expr = TREE_OPERAND (addr, 0);
5029 expr_type = TREE_TYPE (expr);
5032 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
5033 parameter is a pointer to object, through decay and
5034 qualification conversion. Let's strip everything. */
5035 else if (TYPE_PTROBV_P (type))
5038 gcc_assert (TREE_CODE (expr) == ADDR_EXPR);
5039 gcc_assert (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE);
5040 /* Skip the ADDR_EXPR only if it is part of the decay for
5041 an array. Otherwise, it is part of the original argument
5042 in the source code. */
5043 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == ARRAY_TYPE)
5044 expr = TREE_OPERAND (expr, 0);
5045 expr_type = TREE_TYPE (expr);
5049 /* [temp.arg.nontype]/5, bullet 1
5051 For a non-type template-parameter of integral or enumeration type,
5052 integral promotions (_conv.prom_) and integral conversions
5053 (_conv.integral_) are applied. */
5054 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type))
5056 if (!INTEGRAL_OR_ENUMERATION_TYPE_P (expr_type))
5057 return error_mark_node;
5059 expr = fold_decl_constant_value (expr);
5060 /* Notice that there are constant expressions like '4 % 0' which
5061 do not fold into integer constants. */
5062 if (TREE_CODE (expr) != INTEGER_CST)
5064 error ("%qE is not a valid template argument for type %qT "
5065 "because it is a non-constant expression", expr, type);
5069 /* At this point, an implicit conversion does what we want,
5070 because we already know that the expression is of integral
5072 expr = ocp_convert (type, expr, CONV_IMPLICIT, LOOKUP_PROTECT);
5073 if (expr == error_mark_node)
5074 return error_mark_node;
5076 /* Conversion was allowed: fold it to a bare integer constant. */
5079 /* [temp.arg.nontype]/5, bullet 2
5081 For a non-type template-parameter of type pointer to object,
5082 qualification conversions (_conv.qual_) and the array-to-pointer
5083 conversion (_conv.array_) are applied. */
5084 else if (TYPE_PTROBV_P (type))
5086 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
5088 A template-argument for a non-type, non-template template-parameter
5089 shall be one of: [...]
5091 -- the name of a non-type template-parameter;
5092 -- the address of an object or function with external linkage, [...]
5093 expressed as "& id-expression" where the & is optional if the name
5094 refers to a function or array, or if the corresponding
5095 template-parameter is a reference.
5097 Here, we do not care about functions, as they are invalid anyway
5098 for a parameter of type pointer-to-object. */
5100 if (DECL_P (expr) && DECL_TEMPLATE_PARM_P (expr))
5101 /* Non-type template parameters are OK. */
5103 else if (TREE_CODE (expr) != ADDR_EXPR
5104 && TREE_CODE (expr_type) != ARRAY_TYPE)
5106 if (TREE_CODE (expr) == VAR_DECL)
5108 error ("%qD is not a valid template argument "
5109 "because %qD is a variable, not the address of "
5114 /* Other values, like integer constants, might be valid
5115 non-type arguments of some other type. */
5116 return error_mark_node;
5122 decl = ((TREE_CODE (expr) == ADDR_EXPR)
5123 ? TREE_OPERAND (expr, 0) : expr);
5124 if (TREE_CODE (decl) != VAR_DECL)
5126 error ("%qE is not a valid template argument of type %qT "
5127 "because %qE is not a variable",
5131 else if (!DECL_EXTERNAL_LINKAGE_P (decl))
5133 error ("%qE is not a valid template argument of type %qT "
5134 "because %qD does not have external linkage",
5140 expr = decay_conversion (expr);
5141 if (expr == error_mark_node)
5142 return error_mark_node;
5144 expr = perform_qualification_conversions (type, expr);
5145 if (expr == error_mark_node)
5146 return error_mark_node;
5148 /* [temp.arg.nontype]/5, bullet 3
5150 For a non-type template-parameter of type reference to object, no
5151 conversions apply. The type referred to by the reference may be more
5152 cv-qualified than the (otherwise identical) type of the
5153 template-argument. The template-parameter is bound directly to the
5154 template-argument, which must be an lvalue. */
5155 else if (TYPE_REF_OBJ_P (type))
5157 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type),
5159 return error_mark_node;
5161 if (!at_least_as_qualified_p (TREE_TYPE (type), expr_type))
5163 error ("%qE is not a valid template argument for type %qT "
5164 "because of conflicts in cv-qualification", expr, type);
5168 if (!real_lvalue_p (expr))
5170 error ("%qE is not a valid template argument for type %qT "
5171 "because it is not an lvalue", expr, type);
5175 /* [temp.arg.nontype]/1
5177 A template-argument for a non-type, non-template template-parameter
5178 shall be one of: [...]
5180 -- the address of an object or function with external linkage. */
5181 if (TREE_CODE (expr) == INDIRECT_REF
5182 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr, 0))))
5184 expr = TREE_OPERAND (expr, 0);
5187 error ("%q#D is not a valid template argument for type %qT "
5188 "because a reference variable does not have a constant "
5189 "address", expr, type);
5196 error ("%qE is not a valid template argument for type %qT "
5197 "because it is not an object with external linkage",
5202 if (!DECL_EXTERNAL_LINKAGE_P (expr))
5204 error ("%qE is not a valid template argument for type %qT "
5205 "because object %qD has not external linkage",
5210 expr = build_nop (type, build_address (expr));
5212 /* [temp.arg.nontype]/5, bullet 4
5214 For a non-type template-parameter of type pointer to function, only
5215 the function-to-pointer conversion (_conv.func_) is applied. If the
5216 template-argument represents a set of overloaded functions (or a
5217 pointer to such), the matching function is selected from the set
5219 else if (TYPE_PTRFN_P (type))
5221 /* If the argument is a template-id, we might not have enough
5222 context information to decay the pointer. */
5223 if (!type_unknown_p (expr_type))
5225 expr = decay_conversion (expr);
5226 if (expr == error_mark_node)
5227 return error_mark_node;
5230 expr = convert_nontype_argument_function (type, expr);
5231 if (!expr || expr == error_mark_node)
5234 if (TREE_CODE (expr) != ADDR_EXPR)
5236 error ("%qE is not a valid template argument for type %qT", expr, type);
5237 error ("it must be the address of a function with external linkage");
5241 /* [temp.arg.nontype]/5, bullet 5
5243 For a non-type template-parameter of type reference to function, no
5244 conversions apply. If the template-argument represents a set of
5245 overloaded functions, the matching function is selected from the set
5247 else if (TYPE_REFFN_P (type))
5249 if (TREE_CODE (expr) == ADDR_EXPR)
5251 error ("%qE is not a valid template argument for type %qT "
5252 "because it is a pointer", expr, type);
5253 inform (input_location, "try using %qE instead", TREE_OPERAND (expr, 0));
5257 expr = convert_nontype_argument_function (TREE_TYPE (type), expr);
5258 if (!expr || expr == error_mark_node)
5261 expr = build_nop (type, build_address (expr));
5263 /* [temp.arg.nontype]/5, bullet 6
5265 For a non-type template-parameter of type pointer to member function,
5266 no conversions apply. If the template-argument represents a set of
5267 overloaded member functions, the matching member function is selected
5268 from the set (_over.over_). */
5269 else if (TYPE_PTRMEMFUNC_P (type))
5271 expr = instantiate_type (type, expr, tf_none);
5272 if (expr == error_mark_node)
5273 return error_mark_node;
5275 /* [temp.arg.nontype] bullet 1 says the pointer to member
5276 expression must be a pointer-to-member constant. */
5277 if (!check_valid_ptrmem_cst_expr (type, expr))
5278 return error_mark_node;
5280 /* There is no way to disable standard conversions in
5281 resolve_address_of_overloaded_function (called by
5282 instantiate_type). It is possible that the call succeeded by
5283 converting &B::I to &D::I (where B is a base of D), so we need
5284 to reject this conversion here.
5286 Actually, even if there was a way to disable standard conversions,
5287 it would still be better to reject them here so that we can
5288 provide a superior diagnostic. */
5289 if (!same_type_p (TREE_TYPE (expr), type))
5291 error ("%qE is not a valid template argument for type %qT "
5292 "because it is of type %qT", expr, type,
5294 /* If we are just one standard conversion off, explain. */
5295 if (can_convert (type, TREE_TYPE (expr)))
5296 inform (input_location,
5297 "standard conversions are not allowed in this context");
5301 /* [temp.arg.nontype]/5, bullet 7
5303 For a non-type template-parameter of type pointer to data member,
5304 qualification conversions (_conv.qual_) are applied. */
5305 else if (TYPE_PTRMEM_P (type))
5307 /* [temp.arg.nontype] bullet 1 says the pointer to member
5308 expression must be a pointer-to-member constant. */
5309 if (!check_valid_ptrmem_cst_expr (type, expr))
5310 return error_mark_node;
5312 expr = perform_qualification_conversions (type, expr);
5313 if (expr == error_mark_node)
5316 /* A template non-type parameter must be one of the above. */
5320 /* Sanity check: did we actually convert the argument to the
5322 gcc_assert (same_type_p (type, TREE_TYPE (expr)));
5326 /* Subroutine of coerce_template_template_parms, which returns 1 if
5327 PARM_PARM and ARG_PARM match using the rule for the template
5328 parameters of template template parameters. Both PARM and ARG are
5329 template parameters; the rest of the arguments are the same as for
5330 coerce_template_template_parms.
5333 coerce_template_template_parm (tree parm,
5335 tsubst_flags_t complain,
5339 if (arg == NULL_TREE || arg == error_mark_node
5340 || parm == NULL_TREE || parm == error_mark_node)
5343 if (TREE_CODE (arg) != TREE_CODE (parm))
5346 switch (TREE_CODE (parm))
5349 /* We encounter instantiations of templates like
5350 template <template <template <class> class> class TT>
5353 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
5354 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
5356 if (!coerce_template_template_parms
5357 (parmparm, argparm, complain, in_decl, outer_args))
5363 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg))
5364 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm)))
5365 /* Argument is a parameter pack but parameter is not. */
5370 /* The tsubst call is used to handle cases such as
5372 template <int> class C {};
5373 template <class T, template <T> class TT> class D {};
5376 i.e. the parameter list of TT depends on earlier parameters. */
5377 if (!uses_template_parms (TREE_TYPE (arg))
5379 (tsubst (TREE_TYPE (parm), outer_args, complain, in_decl),
5383 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg))
5384 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))
5385 /* Argument is a parameter pack but parameter is not. */
5398 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
5399 template template parameters. Both PARM_PARMS and ARG_PARMS are
5400 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
5403 Consider the example:
5404 template <class T> class A;
5405 template<template <class U> class TT> class B;
5407 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
5408 the parameters to A, and OUTER_ARGS contains A. */
5411 coerce_template_template_parms (tree parm_parms,
5413 tsubst_flags_t complain,
5417 int nparms, nargs, i;
5421 gcc_assert (TREE_CODE (parm_parms) == TREE_VEC);
5422 gcc_assert (TREE_CODE (arg_parms) == TREE_VEC);
5424 nparms = TREE_VEC_LENGTH (parm_parms);
5425 nargs = TREE_VEC_LENGTH (arg_parms);
5427 /* Determine whether we have a parameter pack at the end of the
5428 template template parameter's template parameter list. */
5429 if (TREE_VEC_ELT (parm_parms, nparms - 1) != error_mark_node)
5431 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, nparms - 1));
5433 if (parm == error_mark_node)
5436 switch (TREE_CODE (parm))
5440 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm)))
5445 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))
5455 && !(variadic_p && nargs >= nparms - 1))
5458 /* Check all of the template parameters except the parameter pack at
5459 the end (if any). */
5460 for (i = 0; i < nparms - variadic_p; ++i)
5462 if (TREE_VEC_ELT (parm_parms, i) == error_mark_node
5463 || TREE_VEC_ELT (arg_parms, i) == error_mark_node)
5466 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
5467 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
5469 if (!coerce_template_template_parm (parm, arg, complain, in_decl,
5477 /* Check each of the template parameters in the template
5478 argument against the template parameter pack at the end of
5479 the template template parameter. */
5480 if (TREE_VEC_ELT (parm_parms, i) == error_mark_node)
5483 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
5485 for (; i < nargs; ++i)
5487 if (TREE_VEC_ELT (arg_parms, i) == error_mark_node)
5490 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
5492 if (!coerce_template_template_parm (parm, arg, complain, in_decl,
5501 /* Verifies that the deduced template arguments (in TARGS) for the
5502 template template parameters (in TPARMS) represent valid bindings,
5503 by comparing the template parameter list of each template argument
5504 to the template parameter list of its corresponding template
5505 template parameter, in accordance with DR150. This
5506 routine can only be called after all template arguments have been
5507 deduced. It will return TRUE if all of the template template
5508 parameter bindings are okay, FALSE otherwise. */
5510 template_template_parm_bindings_ok_p (tree tparms, tree targs)
5512 int i, ntparms = TREE_VEC_LENGTH (tparms);
5515 /* We're dealing with template parms in this process. */
5516 ++processing_template_decl;
5518 targs = INNERMOST_TEMPLATE_ARGS (targs);
5520 for (i = 0; i < ntparms; ++i)
5522 tree tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
5523 tree targ = TREE_VEC_ELT (targs, i);
5525 if (TREE_CODE (tparm) == TEMPLATE_DECL && targ)
5527 tree packed_args = NULL_TREE;
5530 if (ARGUMENT_PACK_P (targ))
5532 /* Look inside the argument pack. */
5533 packed_args = ARGUMENT_PACK_ARGS (targ);
5534 len = TREE_VEC_LENGTH (packed_args);
5537 for (idx = 0; idx < len; ++idx)
5539 tree targ_parms = NULL_TREE;
5542 /* Extract the next argument from the argument
5544 targ = TREE_VEC_ELT (packed_args, idx);
5546 if (PACK_EXPANSION_P (targ))
5547 /* Look at the pattern of the pack expansion. */
5548 targ = PACK_EXPANSION_PATTERN (targ);
5550 /* Extract the template parameters from the template
5552 if (TREE_CODE (targ) == TEMPLATE_DECL)
5553 targ_parms = DECL_INNERMOST_TEMPLATE_PARMS (targ);
5554 else if (TREE_CODE (targ) == TEMPLATE_TEMPLATE_PARM)
5555 targ_parms = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ));
5557 /* Verify that we can coerce the template template
5558 parameters from the template argument to the template
5559 parameter. This requires an exact match. */
5561 && !coerce_template_template_parms
5562 (DECL_INNERMOST_TEMPLATE_PARMS (tparm),
5577 --processing_template_decl;
5581 /* Convert the indicated template ARG as necessary to match the
5582 indicated template PARM. Returns the converted ARG, or
5583 error_mark_node if the conversion was unsuccessful. Error and
5584 warning messages are issued under control of COMPLAIN. This
5585 conversion is for the Ith parameter in the parameter list. ARGS is
5586 the full set of template arguments deduced so far. */
5589 convert_template_argument (tree parm,
5592 tsubst_flags_t complain,
5598 int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
5600 if (TREE_CODE (arg) == TREE_LIST
5601 && TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF)
5603 /* The template argument was the name of some
5604 member function. That's usually
5605 invalid, but static members are OK. In any
5606 case, grab the underlying fields/functions
5607 and issue an error later if required. */
5608 orig_arg = TREE_VALUE (arg);
5609 TREE_TYPE (arg) = unknown_type_node;
5614 requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
5615 requires_type = (TREE_CODE (parm) == TYPE_DECL
5616 || requires_tmpl_type);
5618 /* When determining whether an argument pack expansion is a template,
5619 look at the pattern. */
5620 if (TREE_CODE (arg) == TYPE_PACK_EXPANSION)
5621 arg = PACK_EXPANSION_PATTERN (arg);
5623 /* Deal with an injected-class-name used as a template template arg. */
5624 if (requires_tmpl_type && CLASS_TYPE_P (arg))
5626 tree t = maybe_get_template_decl_from_type_decl (TYPE_NAME (arg));
5627 if (TREE_CODE (t) == TEMPLATE_DECL)
5629 if (complain & tf_warning_or_error)
5630 pedwarn (input_location, OPT_pedantic, "injected-class-name %qD"
5631 " used as template template argument", TYPE_NAME (arg));
5632 else if (flag_pedantic_errors)
5640 ((TREE_CODE (arg) == TEMPLATE_DECL
5641 && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
5642 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
5643 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
5646 && (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
5647 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE))
5648 arg = TYPE_STUB_DECL (arg);
5650 is_type = TYPE_P (arg) || is_tmpl_type;
5652 if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
5653 && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
5655 permerror (input_location, "to refer to a type member of a template parameter, "
5656 "use %<typename %E%>", orig_arg);
5658 orig_arg = make_typename_type (TREE_OPERAND (arg, 0),
5659 TREE_OPERAND (arg, 1),
5661 complain & tf_error);
5665 if (is_type != requires_type)
5669 if (complain & tf_error)
5671 error ("type/value mismatch at argument %d in template "
5672 "parameter list for %qD",
5675 error (" expected a constant of type %qT, got %qT",
5677 (DECL_P (arg) ? DECL_NAME (arg) : orig_arg));
5678 else if (requires_tmpl_type)
5679 error (" expected a class template, got %qE", orig_arg);
5681 error (" expected a type, got %qE", orig_arg);
5684 return error_mark_node;
5686 if (is_tmpl_type ^ requires_tmpl_type)
5688 if (in_decl && (complain & tf_error))
5690 error ("type/value mismatch at argument %d in template "
5691 "parameter list for %qD",
5694 error (" expected a type, got %qT", DECL_NAME (arg));
5696 error (" expected a class template, got %qT", orig_arg);
5698 return error_mark_node;
5703 if (requires_tmpl_type)
5705 if (TREE_CODE (TREE_TYPE (arg)) == UNBOUND_CLASS_TEMPLATE)
5706 /* The number of argument required is not known yet.
5707 Just accept it for now. */
5708 val = TREE_TYPE (arg);
5711 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
5714 argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
5716 if (coerce_template_template_parms (parmparm, argparm,
5722 /* TEMPLATE_TEMPLATE_PARM node is preferred over
5724 if (val != error_mark_node)
5726 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val))
5727 val = TREE_TYPE (val);
5728 if (TREE_CODE (orig_arg) == TYPE_PACK_EXPANSION)
5729 val = make_pack_expansion (val);
5734 if (in_decl && (complain & tf_error))
5736 error ("type/value mismatch at argument %d in "
5737 "template parameter list for %qD",
5739 error (" expected a template of type %qD, got %qT",
5743 val = error_mark_node;
5749 /* We only form one instance of each template specialization.
5750 Therefore, if we use a non-canonical variant (i.e., a
5751 typedef), any future messages referring to the type will use
5752 the typedef, which is confusing if those future uses do not
5753 themselves also use the typedef. */
5755 val = strip_typedefs (val);
5759 tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl);
5761 if (invalid_nontype_parm_type_p (t, complain))
5762 return error_mark_node;
5764 if (template_parameter_pack_p (parm) && ARGUMENT_PACK_P (orig_arg))
5766 if (same_type_p (t, TREE_TYPE (orig_arg)))
5770 /* Not sure if this is reachable, but it doesn't hurt
5772 error ("type mismatch in nontype parameter pack");
5773 val = error_mark_node;
5776 else if (!uses_template_parms (orig_arg) && !uses_template_parms (t))
5777 /* We used to call digest_init here. However, digest_init
5778 will report errors, which we don't want when complain
5779 is zero. More importantly, digest_init will try too
5780 hard to convert things: for example, `0' should not be
5781 converted to pointer type at this point according to
5782 the standard. Accepting this is not merely an
5783 extension, since deciding whether or not these
5784 conversions can occur is part of determining which
5785 function template to call, or whether a given explicit
5786 argument specification is valid. */
5787 val = convert_nontype_argument (t, orig_arg);
5791 if (val == NULL_TREE)
5792 val = error_mark_node;
5793 else if (val == error_mark_node && (complain & tf_error))
5794 error ("could not convert template argument %qE to %qT", orig_arg, t);
5796 if (TREE_CODE (val) == SCOPE_REF)
5798 /* Strip typedefs from the SCOPE_REF. */
5799 tree type = strip_typedefs (TREE_TYPE (val));
5800 tree scope = strip_typedefs (TREE_OPERAND (val, 0));
5801 val = build_qualified_name (type, scope, TREE_OPERAND (val, 1),
5802 QUALIFIED_NAME_IS_TEMPLATE (val));
5809 /* Coerces the remaining template arguments in INNER_ARGS (from
5810 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
5811 Returns the coerced argument pack. PARM_IDX is the position of this
5812 parameter in the template parameter list. ARGS is the original
5813 template argument list. */
5815 coerce_template_parameter_pack (tree parms,
5823 tsubst_flags_t complain)
5825 tree parm = TREE_VEC_ELT (parms, parm_idx);
5826 int nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
5829 tree packed_types = NULL_TREE;
5831 if (arg_idx > nargs)
5834 packed_args = make_tree_vec (nargs - arg_idx);
5836 if (TREE_CODE (TREE_VALUE (parm)) == PARM_DECL
5837 && uses_parameter_packs (TREE_TYPE (TREE_VALUE (parm))))
5839 /* When the template parameter is a non-type template
5840 parameter pack whose type uses parameter packs, we need
5841 to look at each of the template arguments
5842 separately. Build a vector of the types for these
5843 non-type template parameters in PACKED_TYPES. */
5845 = make_pack_expansion (TREE_TYPE (TREE_VALUE (parm)));
5846 packed_types = tsubst_pack_expansion (expansion, args,
5849 if (packed_types == error_mark_node)
5850 return error_mark_node;
5852 /* Check that we have the right number of arguments. */
5854 && !PACK_EXPANSION_P (TREE_VEC_ELT (inner_args, arg_idx))
5855 && nargs - arg_idx != TREE_VEC_LENGTH (packed_types))
5858 = TREE_VEC_LENGTH (parms) - 1 + TREE_VEC_LENGTH (packed_types);
5859 error ("wrong number of template arguments (%d, should be %d)",
5860 nargs, needed_parms);
5861 return error_mark_node;
5864 /* If we aren't able to check the actual arguments now
5865 (because they haven't been expanded yet), we can at least
5866 verify that all of the types used for the non-type
5867 template parameter pack are, in fact, valid for non-type
5868 template parameters. */
5870 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args, arg_idx)))
5872 int j, len = TREE_VEC_LENGTH (packed_types);
5873 for (j = 0; j < len; ++j)
5875 tree t = TREE_VEC_ELT (packed_types, j);
5876 if (invalid_nontype_parm_type_p (t, complain))
5877 return error_mark_node;
5882 /* Convert the remaining arguments, which will be a part of the
5883 parameter pack "parm". */
5884 for (; arg_idx < nargs; ++arg_idx)
5886 tree arg = TREE_VEC_ELT (inner_args, arg_idx);
5887 tree actual_parm = TREE_VALUE (parm);
5889 if (packed_types && !PACK_EXPANSION_P (arg))
5891 /* When we have a vector of types (corresponding to the
5892 non-type template parameter pack that uses parameter
5893 packs in its type, as mention above), and the
5894 argument is not an expansion (which expands to a
5895 currently unknown number of arguments), clone the
5896 parm and give it the next type in PACKED_TYPES. */
5897 actual_parm = copy_node (actual_parm);
5898 TREE_TYPE (actual_parm) =
5899 TREE_VEC_ELT (packed_types, arg_idx - parm_idx);
5902 if (arg != error_mark_node)
5903 arg = convert_template_argument (actual_parm,
5904 arg, new_args, complain, parm_idx,
5906 if (arg == error_mark_node)
5908 TREE_VEC_ELT (packed_args, arg_idx - parm_idx) = arg;
5911 if (TREE_CODE (TREE_VALUE (parm)) == TYPE_DECL
5912 || TREE_CODE (TREE_VALUE (parm)) == TEMPLATE_DECL)
5913 argument_pack = cxx_make_type (TYPE_ARGUMENT_PACK);
5916 argument_pack = make_node (NONTYPE_ARGUMENT_PACK);
5917 TREE_TYPE (argument_pack)
5918 = tsubst (TREE_TYPE (TREE_VALUE (parm)), new_args, complain, in_decl);
5919 TREE_CONSTANT (argument_pack) = 1;
5922 SET_ARGUMENT_PACK_ARGS (argument_pack, packed_args);
5923 #ifdef ENABLE_CHECKING
5924 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args,
5925 TREE_VEC_LENGTH (packed_args));
5927 return argument_pack;
5930 /* Convert all template arguments to their appropriate types, and
5931 return a vector containing the innermost resulting template
5932 arguments. If any error occurs, return error_mark_node. Error and
5933 warning messages are issued under control of COMPLAIN.
5935 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
5936 for arguments not specified in ARGS. Otherwise, if
5937 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
5938 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
5939 USE_DEFAULT_ARGS is false, then all arguments must be specified in
5943 coerce_template_parms (tree parms,
5946 tsubst_flags_t complain,
5947 bool require_all_args,
5948 bool use_default_args)
5950 int nparms, nargs, parm_idx, arg_idx, lost = 0;
5953 tree new_inner_args;
5954 int saved_unevaluated_operand;
5955 int saved_inhibit_evaluation_warnings;
5957 /* When used as a boolean value, indicates whether this is a
5958 variadic template parameter list. Since it's an int, we can also
5959 subtract it from nparms to get the number of non-variadic
5963 nparms = TREE_VEC_LENGTH (parms);
5965 /* Determine if there are any parameter packs. */
5966 for (parm_idx = 0; parm_idx < nparms; ++parm_idx)
5968 tree tparm = TREE_VALUE (TREE_VEC_ELT (parms, parm_idx));
5969 if (template_parameter_pack_p (tparm))
5973 inner_args = INNERMOST_TEMPLATE_ARGS (args);
5974 /* If there are 0 or 1 parameter packs, we need to expand any argument
5975 packs so that we can deduce a parameter pack from some non-packed args
5976 followed by an argument pack, as in variadic85.C. If there are more
5977 than that, we need to leave argument packs intact so the arguments are
5978 assigned to the right parameter packs. This should only happen when
5979 dealing with a nested class inside a partial specialization of a class
5980 template, as in variadic92.C. */
5981 if (variadic_p <= 1)
5982 inner_args = expand_template_argument_pack (inner_args);
5984 nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
5985 if ((nargs > nparms && !variadic_p)
5986 || (nargs < nparms - variadic_p
5988 && (!use_default_args
5989 || (TREE_VEC_ELT (parms, nargs) != error_mark_node
5990 && !TREE_PURPOSE (TREE_VEC_ELT (parms, nargs))))))
5992 if (complain & tf_error)
5997 error ("wrong number of template arguments "
5998 "(%d, should be %d or more)", nargs, nparms);
6001 error ("wrong number of template arguments "
6002 "(%d, should be %d)", nargs, nparms);
6005 error ("provided for %q+D", in_decl);
6008 return error_mark_node;
6011 /* We need to evaluate the template arguments, even though this
6012 template-id may be nested within a "sizeof". */
6013 saved_unevaluated_operand = cp_unevaluated_operand;
6014 cp_unevaluated_operand = 0;
6015 saved_inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
6016 c_inhibit_evaluation_warnings = 0;
6017 new_inner_args = make_tree_vec (nparms);
6018 new_args = add_outermost_template_args (args, new_inner_args);
6019 for (parm_idx = 0, arg_idx = 0; parm_idx < nparms; parm_idx++, arg_idx++)
6024 /* Get the Ith template parameter. */
6025 parm = TREE_VEC_ELT (parms, parm_idx);
6027 if (parm == error_mark_node)
6029 TREE_VEC_ELT (new_inner_args, arg_idx) = error_mark_node;
6033 /* Calculate the next argument. */
6034 if (arg_idx < nargs)
6035 arg = TREE_VEC_ELT (inner_args, arg_idx);
6039 if (template_parameter_pack_p (TREE_VALUE (parm))
6040 && !(arg && ARGUMENT_PACK_P (arg)))
6042 /* All remaining arguments will be placed in the
6043 template parameter pack PARM. */
6044 arg = coerce_template_parameter_pack (parms, parm_idx, args,
6045 inner_args, arg_idx,
6049 /* Store this argument. */
6050 if (arg == error_mark_node)
6052 TREE_VEC_ELT (new_inner_args, parm_idx) = arg;
6054 /* We are done with all of the arguments. */
6061 if (PACK_EXPANSION_P (arg))
6063 if (complain & tf_error)
6065 /* FIXME this restriction was removed by N2555; see
6067 /* If ARG is a pack expansion, but PARM is not a
6068 template parameter pack (if it were, we would have
6069 handled it above), we're trying to expand into a
6070 fixed-length argument list. */
6071 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
6072 sorry ("cannot expand %<%E%> into a fixed-length "
6073 "argument list", arg);
6075 sorry ("cannot expand %<%T%> into a fixed-length "
6076 "argument list", arg);
6078 return error_mark_node;
6081 else if (require_all_args)
6083 /* There must be a default arg in this case. */
6084 arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
6086 /* The position of the first default template argument,
6087 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
6089 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args))
6090 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args, arg_idx);
6095 if (arg == error_mark_node)
6097 if (complain & tf_error)
6098 error ("template argument %d is invalid", arg_idx + 1);
6101 /* This only occurs if there was an error in the template
6102 parameter list itself (which we would already have
6103 reported) that we are trying to recover from, e.g., a class
6104 template with a parameter list such as
6105 template<typename..., typename>. */
6106 return error_mark_node;
6108 arg = convert_template_argument (TREE_VALUE (parm),
6109 arg, new_args, complain,
6112 if (arg == error_mark_node)
6114 TREE_VEC_ELT (new_inner_args, arg_idx) = arg;
6116 cp_unevaluated_operand = saved_unevaluated_operand;
6117 c_inhibit_evaluation_warnings = saved_inhibit_evaluation_warnings;
6120 return error_mark_node;
6122 #ifdef ENABLE_CHECKING
6123 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args))
6124 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args,
6125 TREE_VEC_LENGTH (new_inner_args));
6128 return new_inner_args;
6131 /* Returns 1 if template args OT and NT are equivalent. */
6134 template_args_equal (tree ot, tree nt)
6139 if (TREE_CODE (nt) == TREE_VEC)
6140 /* For member templates */
6141 return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt);
6142 else if (PACK_EXPANSION_P (ot))
6143 return PACK_EXPANSION_P (nt)
6144 && template_args_equal (PACK_EXPANSION_PATTERN (ot),
6145 PACK_EXPANSION_PATTERN (nt));
6146 else if (ARGUMENT_PACK_P (ot))
6151 if (!ARGUMENT_PACK_P (nt))
6154 opack = ARGUMENT_PACK_ARGS (ot);
6155 npack = ARGUMENT_PACK_ARGS (nt);
6156 len = TREE_VEC_LENGTH (opack);
6157 if (TREE_VEC_LENGTH (npack) != len)
6159 for (i = 0; i < len; ++i)
6160 if (!template_args_equal (TREE_VEC_ELT (opack, i),
6161 TREE_VEC_ELT (npack, i)))
6165 else if (ot && TREE_CODE (ot) == ARGUMENT_PACK_SELECT)
6167 /* We get here probably because we are in the middle of substituting
6168 into the pattern of a pack expansion. In that case the
6169 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
6170 interested in. So we want to use the initial pack argument for
6172 ot = ARGUMENT_PACK_SELECT_FROM_PACK (ot);
6173 if (nt && TREE_CODE (nt) == ARGUMENT_PACK_SELECT)
6174 nt = ARGUMENT_PACK_SELECT_FROM_PACK (nt);
6175 return template_args_equal (ot, nt);
6177 else if (TYPE_P (nt))
6178 return TYPE_P (ot) && same_type_p (ot, nt);
6179 else if (TREE_CODE (ot) == TREE_VEC || TYPE_P (ot))
6182 return cp_tree_equal (ot, nt);
6185 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
6186 of template arguments. Returns 0 otherwise. */
6189 comp_template_args (tree oldargs, tree newargs)
6193 if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
6196 for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
6198 tree nt = TREE_VEC_ELT (newargs, i);
6199 tree ot = TREE_VEC_ELT (oldargs, i);
6201 if (! template_args_equal (ot, nt))
6208 add_pending_template (tree d)
6210 tree ti = (TYPE_P (d)
6211 ? CLASSTYPE_TEMPLATE_INFO (d)
6212 : DECL_TEMPLATE_INFO (d));
6213 struct pending_template *pt;
6216 if (TI_PENDING_TEMPLATE_FLAG (ti))
6219 /* We are called both from instantiate_decl, where we've already had a
6220 tinst_level pushed, and instantiate_template, where we haven't.
6222 level = !current_tinst_level || current_tinst_level->decl != d;
6225 push_tinst_level (d);
6227 pt = ggc_alloc_pending_template ();
6229 pt->tinst = current_tinst_level;
6230 if (last_pending_template)
6231 last_pending_template->next = pt;
6233 pending_templates = pt;
6235 last_pending_template = pt;
6237 TI_PENDING_TEMPLATE_FLAG (ti) = 1;
6244 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
6245 ARGLIST. Valid choices for FNS are given in the cp-tree.def
6246 documentation for TEMPLATE_ID_EXPR. */
6249 lookup_template_function (tree fns, tree arglist)
6253 if (fns == error_mark_node || arglist == error_mark_node)
6254 return error_mark_node;
6256 gcc_assert (!arglist || TREE_CODE (arglist) == TREE_VEC);
6257 gcc_assert (fns && (is_overloaded_fn (fns)
6258 || TREE_CODE (fns) == IDENTIFIER_NODE));
6260 if (BASELINK_P (fns))
6262 BASELINK_FUNCTIONS (fns) = build2 (TEMPLATE_ID_EXPR,
6264 BASELINK_FUNCTIONS (fns),
6269 type = TREE_TYPE (fns);
6270 if (TREE_CODE (fns) == OVERLOAD || !type)
6271 type = unknown_type_node;
6273 return build2 (TEMPLATE_ID_EXPR, type, fns, arglist);
6276 /* Within the scope of a template class S<T>, the name S gets bound
6277 (in build_self_reference) to a TYPE_DECL for the class, not a
6278 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
6279 or one of its enclosing classes, and that type is a template,
6280 return the associated TEMPLATE_DECL. Otherwise, the original
6283 Also handle the case when DECL is a TREE_LIST of ambiguous
6284 injected-class-names from different bases. */
6287 maybe_get_template_decl_from_type_decl (tree decl)
6289 if (decl == NULL_TREE)
6292 /* DR 176: A lookup that finds an injected-class-name (10.2
6293 [class.member.lookup]) can result in an ambiguity in certain cases
6294 (for example, if it is found in more than one base class). If all of
6295 the injected-class-names that are found refer to specializations of
6296 the same class template, and if the name is followed by a
6297 template-argument-list, the reference refers to the class template
6298 itself and not a specialization thereof, and is not ambiguous. */
6299 if (TREE_CODE (decl) == TREE_LIST)
6301 tree t, tmpl = NULL_TREE;
6302 for (t = decl; t; t = TREE_CHAIN (t))
6304 tree elt = maybe_get_template_decl_from_type_decl (TREE_VALUE (t));
6307 else if (tmpl != elt)
6310 if (tmpl && t == NULL_TREE)
6316 return (decl != NULL_TREE
6317 && DECL_SELF_REFERENCE_P (decl)
6318 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
6319 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl;
6322 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
6323 parameters, find the desired type.
6325 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
6327 IN_DECL, if non-NULL, is the template declaration we are trying to
6330 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
6331 the class we are looking up.
6333 Issue error and warning messages under control of COMPLAIN.
6335 If the template class is really a local class in a template
6336 function, then the FUNCTION_CONTEXT is the function in which it is
6339 ??? Note that this function is currently called *twice* for each
6340 template-id: the first time from the parser, while creating the
6341 incomplete type (finish_template_type), and the second type during the
6342 real instantiation (instantiate_template_class). This is surely something
6343 that we want to avoid. It also causes some problems with argument
6344 coercion (see convert_nontype_argument for more information on this). */
6347 lookup_template_class (tree d1,
6352 tsubst_flags_t complain)
6354 tree templ = NULL_TREE, parmlist;
6361 timevar_push (TV_NAME_LOOKUP);
6363 if (TREE_CODE (d1) == IDENTIFIER_NODE)
6365 tree value = innermost_non_namespace_value (d1);
6366 if (value && DECL_TEMPLATE_TEMPLATE_PARM_P (value))
6371 push_decl_namespace (context);
6372 templ = lookup_name (d1);
6373 templ = maybe_get_template_decl_from_type_decl (templ);
6375 pop_decl_namespace ();
6378 context = DECL_CONTEXT (templ);
6380 else if (TREE_CODE (d1) == TYPE_DECL && MAYBE_CLASS_TYPE_P (TREE_TYPE (d1)))
6382 tree type = TREE_TYPE (d1);
6384 /* If we are declaring a constructor, say A<T>::A<T>, we will get
6385 an implicit typename for the second A. Deal with it. */
6386 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
6387 type = TREE_TYPE (type);
6389 if (CLASSTYPE_TEMPLATE_INFO (type))
6391 templ = CLASSTYPE_TI_TEMPLATE (type);
6392 d1 = DECL_NAME (templ);
6395 else if (TREE_CODE (d1) == ENUMERAL_TYPE
6396 || (TYPE_P (d1) && MAYBE_CLASS_TYPE_P (d1)))
6398 templ = TYPE_TI_TEMPLATE (d1);
6399 d1 = DECL_NAME (templ);
6401 else if (TREE_CODE (d1) == TEMPLATE_DECL
6402 && DECL_TEMPLATE_RESULT (d1)
6403 && TREE_CODE (DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL)
6406 d1 = DECL_NAME (templ);
6407 context = DECL_CONTEXT (templ);
6410 /* Issue an error message if we didn't find a template. */
6413 if (complain & tf_error)
6414 error ("%qT is not a template", d1);
6415 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
6418 if (TREE_CODE (templ) != TEMPLATE_DECL
6419 /* Make sure it's a user visible template, if it was named by
6421 || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (templ)
6422 && !PRIMARY_TEMPLATE_P (templ)))
6424 if (complain & tf_error)
6426 error ("non-template type %qT used as a template", d1);
6428 error ("for template declaration %q+D", in_decl);
6430 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
6433 complain &= ~tf_user;
6435 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ))
6437 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
6438 template arguments */
6444 parmlist = DECL_INNERMOST_TEMPLATE_PARMS (templ);
6446 /* Consider an example where a template template parameter declared as
6448 template <class T, class U = std::allocator<T> > class TT
6450 The template parameter level of T and U are one level larger than
6451 of TT. To proper process the default argument of U, say when an
6452 instantiation `TT<int>' is seen, we need to build the full
6453 arguments containing {int} as the innermost level. Outer levels,
6454 available when not appearing as default template argument, can be
6455 obtained from the arguments of the enclosing template.
6457 Suppose that TT is later substituted with std::vector. The above
6458 instantiation is `TT<int, std::allocator<T> >' with TT at
6459 level 1, and T at level 2, while the template arguments at level 1
6460 becomes {std::vector} and the inner level 2 is {int}. */
6462 outer = DECL_CONTEXT (templ);
6464 outer = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer)));
6465 else if (current_template_parms)
6466 /* This is an argument of the current template, so we haven't set
6467 DECL_CONTEXT yet. */
6468 outer = current_template_args ();
6471 arglist = add_to_template_args (outer, arglist);
6473 arglist2 = coerce_template_parms (parmlist, arglist, templ,
6475 /*require_all_args=*/true,
6476 /*use_default_args=*/true);
6477 if (arglist2 == error_mark_node
6478 || (!uses_template_parms (arglist2)
6479 && check_instantiated_args (templ, arglist2, complain)))
6480 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
6482 parm = bind_template_template_parm (TREE_TYPE (templ), arglist2);
6483 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, parm);
6487 tree template_type = TREE_TYPE (templ);
6490 tree found = NULL_TREE;
6493 int is_dependent_type;
6494 int use_partial_inst_tmpl = false;
6496 gen_tmpl = most_general_template (templ);
6497 parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
6498 parm_depth = TMPL_PARMS_DEPTH (parmlist);
6499 arg_depth = TMPL_ARGS_DEPTH (arglist);
6501 if (arg_depth == 1 && parm_depth > 1)
6503 /* We've been given an incomplete set of template arguments.
6506 template <class T> struct S1 {
6507 template <class U> struct S2 {};
6508 template <class U> struct S2<U*> {};
6511 we will be called with an ARGLIST of `U*', but the
6512 TEMPLATE will be `template <class T> template
6513 <class U> struct S1<T>::S2'. We must fill in the missing
6516 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (templ)),
6518 arg_depth = TMPL_ARGS_DEPTH (arglist);
6521 /* Now we should have enough arguments. */
6522 gcc_assert (parm_depth == arg_depth);
6524 /* From here on, we're only interested in the most general
6527 /* Calculate the BOUND_ARGS. These will be the args that are
6528 actually tsubst'd into the definition to create the
6532 /* We have multiple levels of arguments to coerce, at once. */
6534 int saved_depth = TMPL_ARGS_DEPTH (arglist);
6536 tree bound_args = make_tree_vec (parm_depth);
6538 for (i = saved_depth,
6539 t = DECL_TEMPLATE_PARMS (gen_tmpl);
6540 i > 0 && t != NULL_TREE;
6541 --i, t = TREE_CHAIN (t))
6544 if (i == saved_depth)
6545 a = coerce_template_parms (TREE_VALUE (t),
6548 /*require_all_args=*/true,
6549 /*use_default_args=*/true);
6551 /* Outer levels should have already been coerced. */
6552 a = TMPL_ARGS_LEVEL (arglist, i);
6554 /* Don't process further if one of the levels fails. */
6555 if (a == error_mark_node)
6557 /* Restore the ARGLIST to its full size. */
6558 TREE_VEC_LENGTH (arglist) = saved_depth;
6559 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
6562 SET_TMPL_ARGS_LEVEL (bound_args, i, a);
6564 /* We temporarily reduce the length of the ARGLIST so
6565 that coerce_template_parms will see only the arguments
6566 corresponding to the template parameters it is
6568 TREE_VEC_LENGTH (arglist)--;
6571 /* Restore the ARGLIST to its full size. */
6572 TREE_VEC_LENGTH (arglist) = saved_depth;
6574 arglist = bound_args;
6578 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist),
6579 INNERMOST_TEMPLATE_ARGS (arglist),
6582 /*require_all_args=*/true,
6583 /*use_default_args=*/true);
6585 if (arglist == error_mark_node)
6586 /* We were unable to bind the arguments. */
6587 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
6589 /* In the scope of a template class, explicit references to the
6590 template class refer to the type of the template, not any
6591 instantiation of it. For example, in:
6593 template <class T> class C { void f(C<T>); }
6595 the `C<T>' is just the same as `C'. Outside of the
6596 class, however, such a reference is an instantiation. */
6598 || !PRIMARY_TEMPLATE_P (gen_tmpl)
6599 || currently_open_class (template_type))
6600 /* comp_template_args is expensive, check it last. */
6601 && comp_template_args (TYPE_TI_ARGS (template_type),
6603 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, template_type);
6605 /* If we already have this specialization, return it. */
6606 elt.tmpl = gen_tmpl;
6608 hash = hash_specialization (&elt);
6609 entry = (spec_entry *) htab_find_with_hash (type_specializations,
6613 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, entry->spec);
6615 is_dependent_type = uses_template_parms (arglist);
6617 /* If the deduced arguments are invalid, then the binding
6619 if (!is_dependent_type
6620 && check_instantiated_args (gen_tmpl,
6621 INNERMOST_TEMPLATE_ARGS (arglist),
6623 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
6625 if (!is_dependent_type
6626 && !PRIMARY_TEMPLATE_P (gen_tmpl)
6627 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl))
6628 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl)) == NAMESPACE_DECL)
6630 found = xref_tag_from_type (TREE_TYPE (gen_tmpl),
6631 DECL_NAME (gen_tmpl),
6632 /*tag_scope=*/ts_global);
6633 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
6636 context = tsubst (DECL_CONTEXT (gen_tmpl), arglist,
6639 context = global_namespace;
6641 /* Create the type. */
6642 if (TREE_CODE (template_type) == ENUMERAL_TYPE)
6644 if (!is_dependent_type)
6646 set_current_access_from_decl (TYPE_NAME (template_type));
6647 t = start_enum (TYPE_IDENTIFIER (template_type),
6648 tsubst (ENUM_UNDERLYING_TYPE (template_type),
6649 arglist, complain, in_decl),
6650 SCOPED_ENUM_P (template_type));
6654 /* We don't want to call start_enum for this type, since
6655 the values for the enumeration constants may involve
6656 template parameters. And, no one should be interested
6657 in the enumeration constants for such a type. */
6658 t = cxx_make_type (ENUMERAL_TYPE);
6659 SET_SCOPED_ENUM_P (t, SCOPED_ENUM_P (template_type));
6664 t = make_class_type (TREE_CODE (template_type));
6665 CLASSTYPE_DECLARED_CLASS (t)
6666 = CLASSTYPE_DECLARED_CLASS (template_type);
6667 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
6668 TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);
6670 /* A local class. Make sure the decl gets registered properly. */
6671 if (context == current_function_decl)
6672 pushtag (DECL_NAME (gen_tmpl), t, /*tag_scope=*/ts_current);
6674 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type), arglist))
6675 /* This instantiation is another name for the primary
6676 template type. Set the TYPE_CANONICAL field
6678 TYPE_CANONICAL (t) = template_type;
6679 else if (any_template_arguments_need_structural_equality_p (arglist))
6680 /* Some of the template arguments require structural
6681 equality testing, so this template class requires
6682 structural equality testing. */
6683 SET_TYPE_STRUCTURAL_EQUALITY (t);
6686 /* If we called start_enum or pushtag above, this information
6687 will already be set up. */
6690 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
6692 type_decl = create_implicit_typedef (DECL_NAME (gen_tmpl), t);
6693 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
6694 DECL_SOURCE_LOCATION (type_decl)
6695 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type));
6698 type_decl = TYPE_NAME (t);
6700 TREE_PRIVATE (type_decl)
6701 = TREE_PRIVATE (TYPE_STUB_DECL (template_type));
6702 TREE_PROTECTED (type_decl)
6703 = TREE_PROTECTED (TYPE_STUB_DECL (template_type));
6704 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type))
6706 DECL_VISIBILITY_SPECIFIED (type_decl) = 1;
6707 DECL_VISIBILITY (type_decl) = CLASSTYPE_VISIBILITY (template_type);
6710 /* Let's consider the explicit specialization of a member
6711 of a class template specialization that is implicitely instantiated,
6716 template<class U> struct M {}; //#0
6721 struct S<int>::M<char> //#1
6725 [temp.expl.spec]/4 says this is valid.
6727 In this case, when we write:
6730 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
6733 When we encounter #1, we want to store the partial instantiation
6734 of M (template<class T> S<int>::M<T>) in it's CLASSTYPE_TI_TEMPLATE.
6736 For all cases other than this "explicit specialization of member of a
6737 class template", we just want to store the most general template into
6738 the CLASSTYPE_TI_TEMPLATE of M.
6740 This case of "explicit specialization of member of a class template"
6742 1/ the enclosing class is an instantiation of, and therefore not
6743 the same as, the context of the most general template, and
6744 2/ we aren't looking at the partial instantiation itself, i.e.
6745 the innermost arguments are not the same as the innermost parms of
6746 the most general template.
6748 So it's only when 1/ and 2/ happens that we want to use the partial
6749 instantiation of the member template in lieu of its most general
6752 if (PRIMARY_TEMPLATE_P (gen_tmpl)
6753 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist)
6754 /* the enclosing class must be an instantiation... */
6755 && CLASS_TYPE_P (context)
6756 && !same_type_p (context, DECL_CONTEXT (gen_tmpl)))
6758 tree partial_inst_args;
6759 TREE_VEC_LENGTH (arglist)--;
6760 ++processing_template_decl;
6762 tsubst (INNERMOST_TEMPLATE_ARGS
6763 (CLASSTYPE_TI_ARGS (TREE_TYPE (gen_tmpl))),
6764 arglist, complain, NULL_TREE);
6765 --processing_template_decl;
6766 TREE_VEC_LENGTH (arglist)++;
6767 use_partial_inst_tmpl =
6768 /*...and we must not be looking at the partial instantiation
6770 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist),
6774 if (!use_partial_inst_tmpl)
6775 /* This case is easy; there are no member templates involved. */
6779 /* This is a full instantiation of a member template. Find
6780 the partial instantiation of which this is an instance. */
6782 /* Temporarily reduce by one the number of levels in the ARGLIST
6783 so as to avoid comparing the last set of arguments. */
6784 TREE_VEC_LENGTH (arglist)--;
6785 found = tsubst (gen_tmpl, arglist, complain, NULL_TREE);
6786 TREE_VEC_LENGTH (arglist)++;
6787 found = CLASSTYPE_TI_TEMPLATE (found);
6790 SET_TYPE_TEMPLATE_INFO (t, build_template_info (found, arglist));
6793 slot = (spec_entry **) htab_find_slot_with_hash (type_specializations,
6794 &elt, hash, INSERT);
6795 *slot = ggc_alloc_spec_entry ();
6798 /* Note this use of the partial instantiation so we can check it
6799 later in maybe_process_partial_specialization. */
6800 DECL_TEMPLATE_INSTANTIATIONS (templ)
6801 = tree_cons (arglist, t,
6802 DECL_TEMPLATE_INSTANTIATIONS (templ));
6804 if (TREE_CODE (t) == ENUMERAL_TYPE && !is_dependent_type)
6805 /* Now that the type has been registered on the instantiations
6806 list, we set up the enumerators. Because the enumeration
6807 constants may involve the enumeration type itself, we make
6808 sure to register the type first, and then create the
6809 constants. That way, doing tsubst_expr for the enumeration
6810 constants won't result in recursive calls here; we'll find
6811 the instantiation and exit above. */
6812 tsubst_enum (template_type, t, arglist);
6814 if (is_dependent_type)
6815 /* If the type makes use of template parameters, the
6816 code that generates debugging information will crash. */
6817 DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1;
6819 /* Possibly limit visibility based on template args. */
6820 TREE_PUBLIC (type_decl) = 1;
6821 determine_visibility (type_decl);
6823 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
6825 timevar_pop (TV_NAME_LOOKUP);
6832 /* True when we should also visit template parameters that occur in
6833 non-deduced contexts. */
6834 bool include_nondeduced_p;
6835 struct pointer_set_t *visited;
6838 /* Called from for_each_template_parm via walk_tree. */
6841 for_each_template_parm_r (tree *tp, int *walk_subtrees, void *d)
6844 struct pair_fn_data *pfd = (struct pair_fn_data *) d;
6845 tree_fn_t fn = pfd->fn;
6846 void *data = pfd->data;
6849 && (pfd->include_nondeduced_p || TREE_CODE (t) != TYPENAME_TYPE)
6850 && for_each_template_parm (TYPE_CONTEXT (t), fn, data, pfd->visited,
6851 pfd->include_nondeduced_p))
6852 return error_mark_node;
6854 switch (TREE_CODE (t))
6857 if (TYPE_PTRMEMFUNC_P (t))
6863 if (!TYPE_TEMPLATE_INFO (t))
6865 else if (for_each_template_parm (TI_ARGS (TYPE_TEMPLATE_INFO (t)),
6866 fn, data, pfd->visited,
6867 pfd->include_nondeduced_p))
6868 return error_mark_node;
6872 if (for_each_template_parm (TYPE_MIN_VALUE (t),
6873 fn, data, pfd->visited,
6874 pfd->include_nondeduced_p)
6875 || for_each_template_parm (TYPE_MAX_VALUE (t),
6876 fn, data, pfd->visited,
6877 pfd->include_nondeduced_p))
6878 return error_mark_node;
6882 /* Since we're not going to walk subtrees, we have to do this
6884 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data,
6885 pfd->visited, pfd->include_nondeduced_p))
6886 return error_mark_node;
6890 /* Check the return type. */
6891 if (for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited,
6892 pfd->include_nondeduced_p))
6893 return error_mark_node;
6895 /* Check the parameter types. Since default arguments are not
6896 instantiated until they are needed, the TYPE_ARG_TYPES may
6897 contain expressions that involve template parameters. But,
6898 no-one should be looking at them yet. And, once they're
6899 instantiated, they don't contain template parameters, so
6900 there's no point in looking at them then, either. */
6904 for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm))
6905 if (for_each_template_parm (TREE_VALUE (parm), fn, data,
6906 pfd->visited, pfd->include_nondeduced_p))
6907 return error_mark_node;
6909 /* Since we've already handled the TYPE_ARG_TYPES, we don't
6910 want walk_tree walking into them itself. */
6916 if (pfd->include_nondeduced_p
6917 && for_each_template_parm (TYPE_FIELDS (t), fn, data,
6919 pfd->include_nondeduced_p))
6920 return error_mark_node;
6925 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
6926 && for_each_template_parm (DECL_TI_ARGS (t), fn, data,
6927 pfd->visited, pfd->include_nondeduced_p))
6928 return error_mark_node;
6933 if (TREE_CODE (t) == CONST_DECL && DECL_TEMPLATE_PARM_P (t)
6934 && for_each_template_parm (DECL_INITIAL (t), fn, data,
6935 pfd->visited, pfd->include_nondeduced_p))
6936 return error_mark_node;
6937 if (DECL_CONTEXT (t)
6938 && pfd->include_nondeduced_p
6939 && for_each_template_parm (DECL_CONTEXT (t), fn, data,
6940 pfd->visited, pfd->include_nondeduced_p))
6941 return error_mark_node;
6944 case BOUND_TEMPLATE_TEMPLATE_PARM:
6945 /* Record template parameters such as `T' inside `TT<T>'. */
6946 if (for_each_template_parm (TYPE_TI_ARGS (t), fn, data, pfd->visited,
6947 pfd->include_nondeduced_p))
6948 return error_mark_node;
6951 case TEMPLATE_TEMPLATE_PARM:
6952 case TEMPLATE_TYPE_PARM:
6953 case TEMPLATE_PARM_INDEX:
6954 if (fn && (*fn)(t, data))
6955 return error_mark_node;
6957 return error_mark_node;
6961 /* A template template parameter is encountered. */
6962 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)
6963 && for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited,
6964 pfd->include_nondeduced_p))
6965 return error_mark_node;
6967 /* Already substituted template template parameter */
6973 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t), fn,
6975 pfd->include_nondeduced_p))
6976 return error_mark_node;
6980 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))
6981 && pfd->include_nondeduced_p
6982 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
6983 (TREE_TYPE (t)), fn, data,
6984 pfd->visited, pfd->include_nondeduced_p))
6985 return error_mark_node;
6990 /* If there's no type, then this thing must be some expression
6991 involving template parameters. */
6992 if (!fn && !TREE_TYPE (t))
6993 return error_mark_node;
6998 case REINTERPRET_CAST_EXPR:
6999 case CONST_CAST_EXPR:
7000 case STATIC_CAST_EXPR:
7001 case DYNAMIC_CAST_EXPR:
7005 case PSEUDO_DTOR_EXPR:
7007 return error_mark_node;
7014 /* We didn't find any template parameters we liked. */
7018 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
7019 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
7020 call FN with the parameter and the DATA.
7021 If FN returns nonzero, the iteration is terminated, and
7022 for_each_template_parm returns 1. Otherwise, the iteration
7023 continues. If FN never returns a nonzero value, the value
7024 returned by for_each_template_parm is 0. If FN is NULL, it is
7025 considered to be the function which always returns 1.
7027 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
7028 parameters that occur in non-deduced contexts. When false, only
7029 visits those template parameters that can be deduced. */
7032 for_each_template_parm (tree t, tree_fn_t fn, void* data,
7033 struct pointer_set_t *visited,
7034 bool include_nondeduced_p)
7036 struct pair_fn_data pfd;
7042 pfd.include_nondeduced_p = include_nondeduced_p;
7044 /* Walk the tree. (Conceptually, we would like to walk without
7045 duplicates, but for_each_template_parm_r recursively calls
7046 for_each_template_parm, so we would need to reorganize a fair
7047 bit to use walk_tree_without_duplicates, so we keep our own
7050 pfd.visited = visited;
7052 pfd.visited = pointer_set_create ();
7053 result = cp_walk_tree (&t,
7054 for_each_template_parm_r,
7056 pfd.visited) != NULL_TREE;
7061 pointer_set_destroy (pfd.visited);
7068 /* Returns true if T depends on any template parameter. */
7071 uses_template_parms (tree t)
7074 int saved_processing_template_decl;
7076 saved_processing_template_decl = processing_template_decl;
7077 if (!saved_processing_template_decl)
7078 processing_template_decl = 1;
7080 dependent_p = dependent_type_p (t);
7081 else if (TREE_CODE (t) == TREE_VEC)
7082 dependent_p = any_dependent_template_arguments_p (t);
7083 else if (TREE_CODE (t) == TREE_LIST)
7084 dependent_p = (uses_template_parms (TREE_VALUE (t))
7085 || uses_template_parms (TREE_CHAIN (t)));
7086 else if (TREE_CODE (t) == TYPE_DECL)
7087 dependent_p = dependent_type_p (TREE_TYPE (t));
7090 || TREE_CODE (t) == TEMPLATE_PARM_INDEX
7091 || TREE_CODE (t) == OVERLOAD
7092 || TREE_CODE (t) == BASELINK
7093 || TREE_CODE (t) == IDENTIFIER_NODE
7094 || TREE_CODE (t) == TRAIT_EXPR
7095 || TREE_CODE (t) == CONSTRUCTOR
7096 || CONSTANT_CLASS_P (t))
7097 dependent_p = (type_dependent_expression_p (t)
7098 || value_dependent_expression_p (t));
7101 gcc_assert (t == error_mark_node);
7102 dependent_p = false;
7105 processing_template_decl = saved_processing_template_decl;
7110 /* Returns true if T depends on any template parameter with level LEVEL. */
7113 uses_template_parms_level (tree t, int level)
7115 return for_each_template_parm (t, template_parm_this_level_p, &level, NULL,
7116 /*include_nondeduced_p=*/true);
7119 static int tinst_depth;
7120 extern int max_tinst_depth;
7121 #ifdef GATHER_STATISTICS
7124 static int tinst_level_tick;
7125 static int last_template_error_tick;
7127 /* We're starting to instantiate D; record the template instantiation context
7128 for diagnostics and to restore it later. */
7131 push_tinst_level (tree d)
7133 struct tinst_level *new_level;
7135 if (tinst_depth >= max_tinst_depth)
7137 /* If the instantiation in question still has unbound template parms,
7138 we don't really care if we can't instantiate it, so just return.
7139 This happens with base instantiation for implicit `typename'. */
7140 if (uses_template_parms (d))
7143 last_template_error_tick = tinst_level_tick;
7144 error ("template instantiation depth exceeds maximum of %d (use "
7145 "-ftemplate-depth= to increase the maximum) instantiating %qD",
7146 max_tinst_depth, d);
7148 print_instantiation_context ();
7153 new_level = ggc_alloc_tinst_level ();
7154 new_level->decl = d;
7155 new_level->locus = input_location;
7156 new_level->in_system_header_p = in_system_header;
7157 new_level->next = current_tinst_level;
7158 current_tinst_level = new_level;
7161 #ifdef GATHER_STATISTICS
7162 if (tinst_depth > depth_reached)
7163 depth_reached = tinst_depth;
7170 /* We're done instantiating this template; return to the instantiation
7174 pop_tinst_level (void)
7176 /* Restore the filename and line number stashed away when we started
7177 this instantiation. */
7178 input_location = current_tinst_level->locus;
7179 current_tinst_level = current_tinst_level->next;
7184 /* We're instantiating a deferred template; restore the template
7185 instantiation context in which the instantiation was requested, which
7186 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
7189 reopen_tinst_level (struct tinst_level *level)
7191 struct tinst_level *t;
7194 for (t = level; t; t = t->next)
7197 current_tinst_level = level;
7202 /* Returns the TINST_LEVEL which gives the original instantiation
7205 struct tinst_level *
7206 outermost_tinst_level (void)
7208 struct tinst_level *level = current_tinst_level;
7211 level = level->next;
7215 /* Returns TRUE if PARM is a parameter of the template TEMPL. */
7218 parameter_of_template_p (tree parm, tree templ)
7223 if (!parm || !templ)
7226 gcc_assert (DECL_TEMPLATE_PARM_P (parm));
7227 gcc_assert (TREE_CODE (templ) == TEMPLATE_DECL);
7229 parms = DECL_TEMPLATE_PARMS (templ);
7230 parms = INNERMOST_TEMPLATE_PARMS (parms);
7232 for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
7233 if (parm == TREE_VALUE (TREE_VEC_ELT (parms, i)))
7239 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
7240 vector of template arguments, as for tsubst.
7242 Returns an appropriate tsubst'd friend declaration. */
7245 tsubst_friend_function (tree decl, tree args)
7249 if (TREE_CODE (decl) == FUNCTION_DECL
7250 && DECL_TEMPLATE_INSTANTIATION (decl)
7251 && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
7252 /* This was a friend declared with an explicit template
7253 argument list, e.g.:
7257 to indicate that f was a template instantiation, not a new
7258 function declaration. Now, we have to figure out what
7259 instantiation of what template. */
7261 tree template_id, arglist, fns;
7264 tree ns = decl_namespace_context (TYPE_MAIN_DECL (current_class_type));
7266 /* Friend functions are looked up in the containing namespace scope.
7267 We must enter that scope, to avoid finding member functions of the
7268 current class with same name. */
7269 push_nested_namespace (ns);
7270 fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args,
7271 tf_warning_or_error, NULL_TREE,
7272 /*integral_constant_expression_p=*/false);
7273 pop_nested_namespace (ns);
7274 arglist = tsubst (DECL_TI_ARGS (decl), args,
7275 tf_warning_or_error, NULL_TREE);
7276 template_id = lookup_template_function (fns, arglist);
7278 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
7279 tmpl = determine_specialization (template_id, new_friend,
7281 /*need_member_template=*/0,
7282 TREE_VEC_LENGTH (args),
7284 return instantiate_template (tmpl, new_args, tf_error);
7287 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
7289 /* The NEW_FRIEND will look like an instantiation, to the
7290 compiler, but is not an instantiation from the point of view of
7291 the language. For example, we might have had:
7293 template <class T> struct S {
7294 template <class U> friend void f(T, U);
7297 Then, in S<int>, template <class U> void f(int, U) is not an
7298 instantiation of anything. */
7299 if (new_friend == error_mark_node)
7300 return error_mark_node;
7302 DECL_USE_TEMPLATE (new_friend) = 0;
7303 if (TREE_CODE (decl) == TEMPLATE_DECL)
7305 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0;
7306 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend))
7307 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
7310 /* The mangled name for the NEW_FRIEND is incorrect. The function
7311 is not a template instantiation and should not be mangled like
7312 one. Therefore, we forget the mangling here; we'll recompute it
7313 later if we need it. */
7314 if (TREE_CODE (new_friend) != TEMPLATE_DECL)
7316 SET_DECL_RTL (new_friend, NULL);
7317 SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE);
7320 if (DECL_NAMESPACE_SCOPE_P (new_friend))
7323 tree new_friend_template_info;
7324 tree new_friend_result_template_info;
7326 int new_friend_is_defn;
7328 /* We must save some information from NEW_FRIEND before calling
7329 duplicate decls since that function will free NEW_FRIEND if
7331 new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
7332 new_friend_is_defn =
7333 (DECL_INITIAL (DECL_TEMPLATE_RESULT
7334 (template_for_substitution (new_friend)))
7336 if (TREE_CODE (new_friend) == TEMPLATE_DECL)
7338 /* This declaration is a `primary' template. */
7339 DECL_PRIMARY_TEMPLATE (new_friend) = new_friend;
7341 new_friend_result_template_info
7342 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend));
7345 new_friend_result_template_info = NULL_TREE;
7347 /* Make the init_value nonzero so pushdecl knows this is a defn. */
7348 if (new_friend_is_defn)
7349 DECL_INITIAL (new_friend) = error_mark_node;
7351 /* Inside pushdecl_namespace_level, we will push into the
7352 current namespace. However, the friend function should go
7353 into the namespace of the template. */
7354 ns = decl_namespace_context (new_friend);
7355 push_nested_namespace (ns);
7356 old_decl = pushdecl_namespace_level (new_friend, /*is_friend=*/true);
7357 pop_nested_namespace (ns);
7359 if (old_decl == error_mark_node)
7360 return error_mark_node;
7362 if (old_decl != new_friend)
7364 /* This new friend declaration matched an existing
7365 declaration. For example, given:
7367 template <class T> void f(T);
7368 template <class U> class C {
7369 template <class T> friend void f(T) {}
7372 the friend declaration actually provides the definition
7373 of `f', once C has been instantiated for some type. So,
7374 old_decl will be the out-of-class template declaration,
7375 while new_friend is the in-class definition.
7377 But, if `f' was called before this point, the
7378 instantiation of `f' will have DECL_TI_ARGS corresponding
7379 to `T' but not to `U', references to which might appear
7380 in the definition of `f'. Previously, the most general
7381 template for an instantiation of `f' was the out-of-class
7382 version; now it is the in-class version. Therefore, we
7383 run through all specialization of `f', adding to their
7384 DECL_TI_ARGS appropriately. In particular, they need a
7385 new set of outer arguments, corresponding to the
7386 arguments for this class instantiation.
7388 The same situation can arise with something like this:
7391 template <class T> class C {
7395 when `C<int>' is instantiated. Now, `f(int)' is defined
7398 if (!new_friend_is_defn)
7399 /* On the other hand, if the in-class declaration does
7400 *not* provide a definition, then we don't want to alter
7401 existing definitions. We can just leave everything
7406 tree new_template = TI_TEMPLATE (new_friend_template_info);
7407 tree new_args = TI_ARGS (new_friend_template_info);
7409 /* Overwrite whatever template info was there before, if
7410 any, with the new template information pertaining to
7412 DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
7414 if (TREE_CODE (old_decl) != TEMPLATE_DECL)
7416 /* We should have called reregister_specialization in
7418 gcc_assert (retrieve_specialization (new_template,
7422 /* Instantiate it if the global has already been used. */
7423 if (DECL_ODR_USED (old_decl))
7424 instantiate_decl (old_decl, /*defer_ok=*/true,
7425 /*expl_inst_class_mem_p=*/false);
7431 /* Indicate that the old function template is a partial
7433 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl))
7434 = new_friend_result_template_info;
7436 gcc_assert (new_template
7437 == most_general_template (new_template));
7438 gcc_assert (new_template != old_decl);
7440 /* Reassign any specializations already in the hash table
7441 to the new more general template, and add the
7442 additional template args. */
7443 for (t = DECL_TEMPLATE_INSTANTIATIONS (old_decl);
7447 tree spec = TREE_VALUE (t);
7450 elt.tmpl = old_decl;
7451 elt.args = DECL_TI_ARGS (spec);
7452 elt.spec = NULL_TREE;
7454 htab_remove_elt (decl_specializations, &elt);
7457 = add_outermost_template_args (new_args,
7458 DECL_TI_ARGS (spec));
7460 register_specialization
7461 (spec, new_template, DECL_TI_ARGS (spec), true, 0);
7464 DECL_TEMPLATE_INSTANTIATIONS (old_decl) = NULL_TREE;
7468 /* The information from NEW_FRIEND has been merged into OLD_DECL
7469 by duplicate_decls. */
7470 new_friend = old_decl;
7475 tree context = DECL_CONTEXT (new_friend);
7479 template <class T> class C {
7480 template <class U> friend void C1<U>::f (); // case 1
7481 friend void C2<T>::f (); // case 2
7483 we only need to make sure CONTEXT is a complete type for
7484 case 2. To distinguish between the two cases, we note that
7485 CONTEXT of case 1 remains dependent type after tsubst while
7486 this isn't true for case 2. */
7487 ++processing_template_decl;
7488 dependent_p = dependent_type_p (context);
7489 --processing_template_decl;
7492 && !complete_type_or_else (context, NULL_TREE))
7493 return error_mark_node;
7495 if (COMPLETE_TYPE_P (context))
7497 /* Check to see that the declaration is really present, and,
7498 possibly obtain an improved declaration. */
7499 tree fn = check_classfn (context,
7500 new_friend, NULL_TREE);
7510 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
7511 template arguments, as for tsubst.
7513 Returns an appropriate tsubst'd friend type or error_mark_node on
7517 tsubst_friend_class (tree friend_tmpl, tree args)
7523 context = DECL_CONTEXT (friend_tmpl);
7527 if (TREE_CODE (context) == NAMESPACE_DECL)
7528 push_nested_namespace (context);
7530 push_nested_class (tsubst (context, args, tf_none, NULL_TREE));
7533 /* Look for a class template declaration. We look for hidden names
7534 because two friend declarations of the same template are the
7535 same. For example, in:
7538 template <typename> friend class F;
7540 template <typename> struct B {
7541 template <typename> friend class F;
7544 both F templates are the same. */
7545 tmpl = lookup_name_real (DECL_NAME (friend_tmpl), 0, 0,
7546 /*block_p=*/true, 0,
7547 LOOKUP_COMPLAIN | LOOKUP_HIDDEN);
7549 /* But, if we don't find one, it might be because we're in a
7550 situation like this:
7558 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
7559 for `S<int>', not the TEMPLATE_DECL. */
7560 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
7562 tmpl = lookup_name_prefer_type (DECL_NAME (friend_tmpl), 1);
7563 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
7566 if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
7568 /* The friend template has already been declared. Just
7569 check to see that the declarations match, and install any new
7570 default parameters. We must tsubst the default parameters,
7571 of course. We only need the innermost template parameters
7572 because that is all that redeclare_class_template will look
7574 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl))
7575 > TMPL_ARGS_DEPTH (args))
7578 location_t saved_input_location;
7579 parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
7580 args, tf_warning_or_error);
7582 saved_input_location = input_location;
7583 input_location = DECL_SOURCE_LOCATION (friend_tmpl);
7584 redeclare_class_template (TREE_TYPE (tmpl), parms);
7585 input_location = saved_input_location;
7589 friend_type = TREE_TYPE (tmpl);
7593 /* The friend template has not already been declared. In this
7594 case, the instantiation of the template class will cause the
7595 injection of this template into the global scope. */
7596 tmpl = tsubst (friend_tmpl, args, tf_warning_or_error, NULL_TREE);
7597 if (tmpl == error_mark_node)
7598 return error_mark_node;
7600 /* The new TMPL is not an instantiation of anything, so we
7601 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
7602 the new type because that is supposed to be the corresponding
7603 template decl, i.e., TMPL. */
7604 DECL_USE_TEMPLATE (tmpl) = 0;
7605 DECL_TEMPLATE_INFO (tmpl) = NULL_TREE;
7606 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0;
7607 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl))
7608 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)));
7610 /* Inject this template into the global scope. */
7611 friend_type = TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl, true));
7616 if (TREE_CODE (context) == NAMESPACE_DECL)
7617 pop_nested_namespace (context);
7619 pop_nested_class ();
7625 /* Returns zero if TYPE cannot be completed later due to circularity.
7626 Otherwise returns one. */
7629 can_complete_type_without_circularity (tree type)
7631 if (type == NULL_TREE || type == error_mark_node)
7633 else if (COMPLETE_TYPE_P (type))
7635 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
7636 return can_complete_type_without_circularity (TREE_TYPE (type));
7637 else if (CLASS_TYPE_P (type)
7638 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type)))
7644 /* Apply any attributes which had to be deferred until instantiation
7645 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
7646 ARGS, COMPLAIN, IN_DECL are as tsubst. */
7649 apply_late_template_attributes (tree *decl_p, tree attributes, int attr_flags,
7650 tree args, tsubst_flags_t complain, tree in_decl)
7652 tree last_dep = NULL_TREE;
7656 for (t = attributes; t; t = TREE_CHAIN (t))
7657 if (ATTR_IS_DEPENDENT (t))
7660 attributes = copy_list (attributes);
7664 if (DECL_P (*decl_p))
7666 if (TREE_TYPE (*decl_p) == error_mark_node)
7668 p = &DECL_ATTRIBUTES (*decl_p);
7671 p = &TYPE_ATTRIBUTES (*decl_p);
7675 tree late_attrs = NULL_TREE;
7676 tree *q = &late_attrs;
7678 for (*p = attributes; *p; )
7681 if (ATTR_IS_DEPENDENT (t))
7683 *p = TREE_CHAIN (t);
7684 TREE_CHAIN (t) = NULL_TREE;
7685 /* If the first attribute argument is an identifier, don't
7686 pass it through tsubst. Attributes like mode, format,
7687 cleanup and several target specific attributes expect it
7690 && TREE_CODE (TREE_VALUE (t)) == TREE_LIST
7691 && TREE_VALUE (TREE_VALUE (t))
7692 && (TREE_CODE (TREE_VALUE (TREE_VALUE (t)))
7693 == IDENTIFIER_NODE))
7696 = tsubst_expr (TREE_CHAIN (TREE_VALUE (t)), args, complain,
7698 /*integral_constant_expression_p=*/false);
7699 if (chain != TREE_CHAIN (TREE_VALUE (t)))
7701 = tree_cons (NULL_TREE, TREE_VALUE (TREE_VALUE (t)),
7706 = tsubst_expr (TREE_VALUE (t), args, complain, in_decl,
7707 /*integral_constant_expression_p=*/false);
7709 q = &TREE_CHAIN (t);
7712 p = &TREE_CHAIN (t);
7715 cplus_decl_attributes (decl_p, late_attrs, attr_flags);
7719 /* Perform (or defer) access check for typedefs that were referenced
7720 from within the template TMPL code.
7721 This is a subroutine of instantiate_template and instantiate_class_template.
7722 TMPL is the template to consider and TARGS is the list of arguments of
7726 perform_typedefs_access_check (tree tmpl, tree targs)
7728 location_t saved_location;
7730 qualified_typedef_usage_t *iter;
7733 || (!CLASS_TYPE_P (tmpl)
7734 && TREE_CODE (tmpl) != FUNCTION_DECL))
7737 saved_location = input_location;
7739 VEC_iterate (qualified_typedef_usage_t,
7740 get_types_needing_access_check (tmpl),
7744 tree type_decl = iter->typedef_decl;
7745 tree type_scope = iter->context;
7747 if (!type_decl || !type_scope || !CLASS_TYPE_P (type_scope))
7750 if (uses_template_parms (type_decl))
7751 type_decl = tsubst (type_decl, targs, tf_error, NULL_TREE);
7752 if (uses_template_parms (type_scope))
7753 type_scope = tsubst (type_scope, targs, tf_error, NULL_TREE);
7755 /* Make access check error messages point to the location
7756 of the use of the typedef. */
7757 input_location = iter->locus;
7758 perform_or_defer_access_check (TYPE_BINFO (type_scope),
7759 type_decl, type_decl);
7761 input_location = saved_location;
7765 instantiate_class_template (tree type)
7767 tree templ, args, pattern, t, member;
7771 unsigned int saved_maximum_field_alignment;
7773 if (type == error_mark_node)
7774 return error_mark_node;
7776 if (COMPLETE_OR_OPEN_TYPE_P (type)
7777 || uses_template_parms (type))
7780 /* Figure out which template is being instantiated. */
7781 templ = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
7782 gcc_assert (TREE_CODE (templ) == TEMPLATE_DECL);
7784 /* Determine what specialization of the original template to
7786 t = most_specialized_class (type, templ, tf_warning_or_error);
7787 if (t == error_mark_node)
7789 TYPE_BEING_DEFINED (type) = 1;
7790 return error_mark_node;
7794 /* This TYPE is actually an instantiation of a partial
7795 specialization. We replace the innermost set of ARGS with
7796 the arguments appropriate for substitution. For example,
7799 template <class T> struct S {};
7800 template <class T> struct S<T*> {};
7802 and supposing that we are instantiating S<int*>, ARGS will
7803 presently be {int*} -- but we need {int}. */
7804 pattern = TREE_TYPE (t);
7805 args = TREE_PURPOSE (t);
7809 pattern = TREE_TYPE (templ);
7810 args = CLASSTYPE_TI_ARGS (type);
7813 /* If the template we're instantiating is incomplete, then clearly
7814 there's nothing we can do. */
7815 if (!COMPLETE_TYPE_P (pattern))
7818 /* If we've recursively instantiated too many templates, stop. */
7819 if (! push_tinst_level (type))
7822 /* Now we're really doing the instantiation. Mark the type as in
7823 the process of being defined. */
7824 TYPE_BEING_DEFINED (type) = 1;
7826 /* We may be in the middle of deferred access check. Disable
7828 push_deferring_access_checks (dk_no_deferred);
7830 push_to_top_level ();
7831 /* Use #pragma pack from the template context. */
7832 saved_maximum_field_alignment = maximum_field_alignment;
7833 maximum_field_alignment = TYPE_PRECISION (pattern);
7835 SET_CLASSTYPE_INTERFACE_UNKNOWN (type);
7837 /* Set the input location to the most specialized template definition.
7838 This is needed if tsubsting causes an error. */
7839 typedecl = TYPE_MAIN_DECL (pattern);
7840 input_location = DECL_SOURCE_LOCATION (TYPE_NAME (type)) =
7841 DECL_SOURCE_LOCATION (typedecl);
7843 TYPE_HAS_USER_CONSTRUCTOR (type) = TYPE_HAS_USER_CONSTRUCTOR (pattern);
7844 TYPE_HAS_NEW_OPERATOR (type) = TYPE_HAS_NEW_OPERATOR (pattern);
7845 TYPE_HAS_ARRAY_NEW_OPERATOR (type) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern);
7846 TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern);
7847 TYPE_HAS_COPY_ASSIGN (type) = TYPE_HAS_COPY_ASSIGN (pattern);
7848 TYPE_HAS_CONST_COPY_ASSIGN (type) = TYPE_HAS_CONST_COPY_ASSIGN (pattern);
7849 TYPE_HAS_COPY_CTOR (type) = TYPE_HAS_COPY_CTOR (pattern);
7850 TYPE_HAS_CONST_COPY_CTOR (type) = TYPE_HAS_CONST_COPY_CTOR (pattern);
7851 TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern);
7852 TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern);
7853 TYPE_PACKED (type) = TYPE_PACKED (pattern);
7854 TYPE_ALIGN (type) = TYPE_ALIGN (pattern);
7855 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);
7856 TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */
7857 if (ANON_AGGR_TYPE_P (pattern))
7858 SET_ANON_AGGR_TYPE_P (type);
7859 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern))
7861 CLASSTYPE_VISIBILITY_SPECIFIED (type) = 1;
7862 CLASSTYPE_VISIBILITY (type) = CLASSTYPE_VISIBILITY (pattern);
7865 pbinfo = TYPE_BINFO (pattern);
7867 /* We should never instantiate a nested class before its enclosing
7868 class; we need to look up the nested class by name before we can
7869 instantiate it, and that lookup should instantiate the enclosing
7871 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))
7872 || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type)));
7874 base_list = NULL_TREE;
7875 if (BINFO_N_BASE_BINFOS (pbinfo))
7878 tree context = TYPE_CONTEXT (type);
7882 /* We must enter the scope containing the type, as that is where
7883 the accessibility of types named in dependent bases are
7885 pushed_scope = push_scope (context ? context : global_namespace);
7887 /* Substitute into each of the bases to determine the actual
7889 for (i = 0; BINFO_BASE_ITERATE (pbinfo, i, pbase_binfo); i++)
7892 tree access = BINFO_BASE_ACCESS (pbinfo, i);
7893 tree expanded_bases = NULL_TREE;
7896 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo)))
7899 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo),
7900 args, tf_error, NULL_TREE);
7901 if (expanded_bases == error_mark_node)
7904 len = TREE_VEC_LENGTH (expanded_bases);
7907 for (idx = 0; idx < len; idx++)
7910 /* Extract the already-expanded base class. */
7911 base = TREE_VEC_ELT (expanded_bases, idx);
7913 /* Substitute to figure out the base class. */
7914 base = tsubst (BINFO_TYPE (pbase_binfo), args, tf_error,
7917 if (base == error_mark_node)
7920 base_list = tree_cons (access, base, base_list);
7921 if (BINFO_VIRTUAL_P (pbase_binfo))
7922 TREE_TYPE (base_list) = integer_type_node;
7926 /* The list is now in reverse order; correct that. */
7927 base_list = nreverse (base_list);
7930 pop_scope (pushed_scope);
7932 /* Now call xref_basetypes to set up all the base-class
7934 xref_basetypes (type, base_list);
7936 apply_late_template_attributes (&type, TYPE_ATTRIBUTES (pattern),
7937 (int) ATTR_FLAG_TYPE_IN_PLACE,
7938 args, tf_error, NULL_TREE);
7940 /* Now that our base classes are set up, enter the scope of the
7941 class, so that name lookups into base classes, etc. will work
7942 correctly. This is precisely analogous to what we do in
7943 begin_class_definition when defining an ordinary non-template
7944 class, except we also need to push the enclosing classes. */
7945 push_nested_class (type);
7947 /* Now members are processed in the order of declaration. */
7948 for (member = CLASSTYPE_DECL_LIST (pattern);
7949 member; member = TREE_CHAIN (member))
7951 tree t = TREE_VALUE (member);
7953 if (TREE_PURPOSE (member))
7957 /* Build new CLASSTYPE_NESTED_UTDS. */
7960 bool class_template_p;
7962 class_template_p = (TREE_CODE (t) != ENUMERAL_TYPE
7963 && TYPE_LANG_SPECIFIC (t)
7964 && CLASSTYPE_IS_TEMPLATE (t));
7965 /* If the member is a class template, then -- even after
7966 substitution -- there may be dependent types in the
7967 template argument list for the class. We increment
7968 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
7969 that function will assume that no types are dependent
7970 when outside of a template. */
7971 if (class_template_p)
7972 ++processing_template_decl;
7973 newtag = tsubst (t, args, tf_error, NULL_TREE);
7974 if (class_template_p)
7975 --processing_template_decl;
7976 if (newtag == error_mark_node)
7979 if (TREE_CODE (newtag) != ENUMERAL_TYPE)
7981 tree name = TYPE_IDENTIFIER (t);
7983 if (class_template_p)
7984 /* Unfortunately, lookup_template_class sets
7985 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
7986 instantiation (i.e., for the type of a member
7987 template class nested within a template class.)
7988 This behavior is required for
7989 maybe_process_partial_specialization to work
7990 correctly, but is not accurate in this case;
7991 the TAG is not an instantiation of anything.
7992 (The corresponding TEMPLATE_DECL is an
7993 instantiation, but the TYPE is not.) */
7994 CLASSTYPE_USE_TEMPLATE (newtag) = 0;
7996 /* Now, we call pushtag to put this NEWTAG into the scope of
7997 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
7998 pushtag calling push_template_decl. We don't have to do
7999 this for enums because it will already have been done in
8002 SET_IDENTIFIER_TYPE_VALUE (name, newtag);
8003 pushtag (name, newtag, /*tag_scope=*/ts_current);
8006 else if (TREE_CODE (t) == FUNCTION_DECL
8007 || DECL_FUNCTION_TEMPLATE_P (t))
8009 /* Build new TYPE_METHODS. */
8012 if (TREE_CODE (t) == TEMPLATE_DECL)
8013 ++processing_template_decl;
8014 r = tsubst (t, args, tf_error, NULL_TREE);
8015 if (TREE_CODE (t) == TEMPLATE_DECL)
8016 --processing_template_decl;
8017 set_current_access_from_decl (r);
8018 finish_member_declaration (r);
8022 /* Build new TYPE_FIELDS. */
8023 if (TREE_CODE (t) == STATIC_ASSERT)
8026 tsubst_expr (STATIC_ASSERT_CONDITION (t), args,
8027 tf_warning_or_error, NULL_TREE,
8028 /*integral_constant_expression_p=*/true);
8029 finish_static_assert (condition,
8030 STATIC_ASSERT_MESSAGE (t),
8031 STATIC_ASSERT_SOURCE_LOCATION (t),
8034 else if (TREE_CODE (t) != CONST_DECL)
8038 /* The file and line for this declaration, to
8039 assist in error message reporting. Since we
8040 called push_tinst_level above, we don't need to
8042 input_location = DECL_SOURCE_LOCATION (t);
8044 if (TREE_CODE (t) == TEMPLATE_DECL)
8045 ++processing_template_decl;
8046 r = tsubst (t, args, tf_warning_or_error, NULL_TREE);
8047 if (TREE_CODE (t) == TEMPLATE_DECL)
8048 --processing_template_decl;
8049 if (TREE_CODE (r) == VAR_DECL)
8053 [t]he initialization (and any associated
8054 side-effects) of a static data member does
8055 not occur unless the static data member is
8056 itself used in a way that requires the
8057 definition of the static data member to
8060 Therefore, we do not substitute into the
8061 initialized for the static data member here. */
8062 finish_static_data_member_decl
8065 /*init_const_expr_p=*/false,
8066 /*asmspec_tree=*/NULL_TREE,
8068 if (DECL_INITIALIZED_IN_CLASS_P (r))
8069 check_static_variable_definition (r, TREE_TYPE (r));
8071 else if (TREE_CODE (r) == FIELD_DECL)
8073 /* Determine whether R has a valid type and can be
8074 completed later. If R is invalid, then it is
8075 replaced by error_mark_node so that it will not be
8076 added to TYPE_FIELDS. */
8077 tree rtype = TREE_TYPE (r);
8078 if (can_complete_type_without_circularity (rtype))
8079 complete_type (rtype);
8081 if (!COMPLETE_TYPE_P (rtype))
8083 cxx_incomplete_type_error (r, rtype);
8084 r = error_mark_node;
8088 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
8089 such a thing will already have been added to the field
8090 list by tsubst_enum in finish_member_declaration in the
8091 CLASSTYPE_NESTED_UTDS case above. */
8092 if (!(TREE_CODE (r) == TYPE_DECL
8093 && TREE_CODE (TREE_TYPE (r)) == ENUMERAL_TYPE
8094 && DECL_ARTIFICIAL (r)))
8096 set_current_access_from_decl (r);
8097 finish_member_declaration (r);
8104 if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t))
8106 /* Build new CLASSTYPE_FRIEND_CLASSES. */
8108 tree friend_type = t;
8109 bool adjust_processing_template_decl = false;
8111 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
8113 /* template <class T> friend class C; */
8114 friend_type = tsubst_friend_class (friend_type, args);
8115 adjust_processing_template_decl = true;
8117 else if (TREE_CODE (friend_type) == UNBOUND_CLASS_TEMPLATE)
8119 /* template <class T> friend class C::D; */
8120 friend_type = tsubst (friend_type, args,
8121 tf_warning_or_error, NULL_TREE);
8122 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
8123 friend_type = TREE_TYPE (friend_type);
8124 adjust_processing_template_decl = true;
8126 else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
8128 /* This could be either
8132 when dependent_type_p is false or
8134 template <class U> friend class T::C;
8137 friend_type = tsubst (friend_type, args,
8138 tf_warning_or_error, NULL_TREE);
8139 /* Bump processing_template_decl for correct
8140 dependent_type_p calculation. */
8141 ++processing_template_decl;
8142 if (dependent_type_p (friend_type))
8143 adjust_processing_template_decl = true;
8144 --processing_template_decl;
8146 else if (!CLASSTYPE_USE_TEMPLATE (friend_type)
8147 && hidden_name_p (TYPE_NAME (friend_type)))
8151 where C hasn't been declared yet. Let's lookup name
8152 from namespace scope directly, bypassing any name that
8153 come from dependent base class. */
8154 tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type));
8156 /* The call to xref_tag_from_type does injection for friend
8158 push_nested_namespace (ns);
8160 xref_tag_from_type (friend_type, NULL_TREE,
8161 /*tag_scope=*/ts_current);
8162 pop_nested_namespace (ns);
8164 else if (uses_template_parms (friend_type))
8165 /* friend class C<T>; */
8166 friend_type = tsubst (friend_type, args,
8167 tf_warning_or_error, NULL_TREE);
8172 where C is already declared or
8174 friend class C<int>;
8176 We don't have to do anything in these cases. */
8178 if (adjust_processing_template_decl)
8179 /* Trick make_friend_class into realizing that the friend
8180 we're adding is a template, not an ordinary class. It's
8181 important that we use make_friend_class since it will
8182 perform some error-checking and output cross-reference
8184 ++processing_template_decl;
8186 if (friend_type != error_mark_node)
8187 make_friend_class (type, friend_type, /*complain=*/false);
8189 if (adjust_processing_template_decl)
8190 --processing_template_decl;
8194 /* Build new DECL_FRIENDLIST. */
8197 /* The file and line for this declaration, to
8198 assist in error message reporting. Since we
8199 called push_tinst_level above, we don't need to
8201 input_location = DECL_SOURCE_LOCATION (t);
8203 if (TREE_CODE (t) == TEMPLATE_DECL)
8205 ++processing_template_decl;
8206 push_deferring_access_checks (dk_no_check);
8209 r = tsubst_friend_function (t, args);
8210 add_friend (type, r, /*complain=*/false);
8211 if (TREE_CODE (t) == TEMPLATE_DECL)
8213 pop_deferring_access_checks ();
8214 --processing_template_decl;
8220 /* Set the file and line number information to whatever is given for
8221 the class itself. This puts error messages involving generated
8222 implicit functions at a predictable point, and the same point
8223 that would be used for non-template classes. */
8224 input_location = DECL_SOURCE_LOCATION (typedecl);
8226 unreverse_member_declarations (type);
8227 finish_struct_1 (type);
8228 TYPE_BEING_DEFINED (type) = 0;
8230 /* Now that the class is complete, instantiate default arguments for
8231 any member functions. We don't do this earlier because the
8232 default arguments may reference members of the class. */
8233 if (!PRIMARY_TEMPLATE_P (templ))
8234 for (t = TYPE_METHODS (type); t; t = DECL_CHAIN (t))
8235 if (TREE_CODE (t) == FUNCTION_DECL
8236 /* Implicitly generated member functions will not have template
8237 information; they are not instantiations, but instead are
8238 created "fresh" for each instantiation. */
8239 && DECL_TEMPLATE_INFO (t))
8240 tsubst_default_arguments (t);
8242 /* Some typedefs referenced from within the template code need to be access
8243 checked at template instantiation time, i.e now. These types were
8244 added to the template at parsing time. Let's get those and perform
8245 the access checks then. */
8246 perform_typedefs_access_check (pattern, args);
8247 perform_deferred_access_checks ();
8248 pop_nested_class ();
8249 maximum_field_alignment = saved_maximum_field_alignment;
8250 pop_from_top_level ();
8251 pop_deferring_access_checks ();
8254 /* The vtable for a template class can be emitted in any translation
8255 unit in which the class is instantiated. When there is no key
8256 method, however, finish_struct_1 will already have added TYPE to
8257 the keyed_classes list. */
8258 if (TYPE_CONTAINS_VPTR_P (type) && CLASSTYPE_KEY_METHOD (type))
8259 keyed_classes = tree_cons (NULL_TREE, type, keyed_classes);
8265 tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl)
8271 else if (TYPE_P (t))
8272 r = tsubst (t, args, complain, in_decl);
8275 r = tsubst_expr (t, args, complain, in_decl,
8276 /*integral_constant_expression_p=*/true);
8277 r = fold_non_dependent_expr (r);
8282 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
8283 NONTYPE_ARGUMENT_PACK. */
8286 make_fnparm_pack (tree spec_parm)
8288 /* Collect all of the extra "packed" parameters into an
8292 tree argpack = make_node (NONTYPE_ARGUMENT_PACK);
8293 tree argtypepack = cxx_make_type (TYPE_ARGUMENT_PACK);
8294 int i, len = list_length (spec_parm);
8296 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
8297 parmvec = make_tree_vec (len);
8298 parmtypevec = make_tree_vec (len);
8299 for (i = 0; i < len; i++, spec_parm = DECL_CHAIN (spec_parm))
8301 TREE_VEC_ELT (parmvec, i) = spec_parm;
8302 TREE_VEC_ELT (parmtypevec, i) = TREE_TYPE (spec_parm);
8305 /* Build the argument packs. */
8306 SET_ARGUMENT_PACK_ARGS (argpack, parmvec);
8307 SET_ARGUMENT_PACK_ARGS (argtypepack, parmtypevec);
8308 TREE_TYPE (argpack) = argtypepack;
8313 /* Substitute ARGS into T, which is an pack expansion
8314 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
8315 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
8316 (if only a partial substitution could be performed) or
8317 ERROR_MARK_NODE if there was an error. */
8319 tsubst_pack_expansion (tree t, tree args, tsubst_flags_t complain,
8323 tree pack, packs = NULL_TREE, unsubstituted_packs = NULL_TREE;
8327 htab_t saved_local_specializations = NULL;
8329 gcc_assert (PACK_EXPANSION_P (t));
8330 pattern = PACK_EXPANSION_PATTERN (t);
8332 /* Determine the argument packs that will instantiate the parameter
8333 packs used in the expansion expression. While we're at it,
8334 compute the number of arguments to be expanded and make sure it
8336 for (pack = PACK_EXPANSION_PARAMETER_PACKS (t); pack;
8337 pack = TREE_CHAIN (pack))
8339 tree parm_pack = TREE_VALUE (pack);
8340 tree arg_pack = NULL_TREE;
8341 tree orig_arg = NULL_TREE;
8343 if (TREE_CODE (parm_pack) == PARM_DECL)
8345 if (!cp_unevaluated_operand)
8346 arg_pack = retrieve_local_specialization (parm_pack);
8349 /* We can't rely on local_specializations for a parameter
8350 name used later in a function declaration (such as in a
8351 late-specified return type). Even if it exists, it might
8352 have the wrong value for a recursive call. Just make a
8353 dummy decl, since it's only used for its type. */
8354 arg_pack = tsubst_decl (parm_pack, args, complain);
8355 arg_pack = make_fnparm_pack (arg_pack);
8360 int level, idx, levels;
8361 template_parm_level_and_index (parm_pack, &level, &idx);
8363 levels = TMPL_ARGS_DEPTH (args);
8364 if (level <= levels)
8365 arg_pack = TMPL_ARG (args, level, idx);
8368 orig_arg = arg_pack;
8369 if (arg_pack && TREE_CODE (arg_pack) == ARGUMENT_PACK_SELECT)
8370 arg_pack = ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack);
8372 if (arg_pack && !ARGUMENT_PACK_P (arg_pack))
8373 /* This can only happen if we forget to expand an argument
8374 pack somewhere else. Just return an error, silently. */
8376 result = make_tree_vec (1);
8377 TREE_VEC_ELT (result, 0) = error_mark_node;
8382 && TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack)) == 1
8383 && PACK_EXPANSION_P (TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg_pack), 0)))
8385 tree expansion = TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg_pack), 0);
8386 tree pattern = PACK_EXPANSION_PATTERN (expansion);
8387 if ((TYPE_P (pattern) && same_type_p (pattern, parm_pack))
8388 || (!TYPE_P (pattern) && cp_tree_equal (parm_pack, pattern)))
8389 /* The argument pack that the parameter maps to is just an
8390 expansion of the parameter itself, such as one would
8391 find in the implicit typedef of a class inside the
8392 class itself. Consider this parameter "unsubstituted",
8393 so that we will maintain the outer pack expansion. */
8394 arg_pack = NULL_TREE;
8400 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack));
8402 /* It's all-or-nothing with incomplete argument packs. */
8403 if (incomplete && !ARGUMENT_PACK_INCOMPLETE_P (arg_pack))
8404 return error_mark_node;
8406 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack))
8411 else if (len != my_len)
8414 /* We got explicit args for some packs but not others;
8415 do nothing now and try again after deduction. */
8417 if (TREE_CODE (t) == TYPE_PACK_EXPANSION)
8418 error ("mismatched argument pack lengths while expanding "
8422 error ("mismatched argument pack lengths while expanding "
8425 return error_mark_node;
8428 /* Keep track of the parameter packs and their corresponding
8430 packs = tree_cons (parm_pack, arg_pack, packs);
8431 TREE_TYPE (packs) = orig_arg;
8434 /* We can't substitute for this parameter pack. */
8435 unsubstituted_packs = tree_cons (TREE_PURPOSE (pack),
8437 unsubstituted_packs);
8440 /* We cannot expand this expansion expression, because we don't have
8441 all of the argument packs we need. Substitute into the pattern
8442 and return a PACK_EXPANSION_*. The caller will need to deal with
8444 if (unsubstituted_packs)
8447 if (TREE_CODE (t) == EXPR_PACK_EXPANSION)
8448 new_pat = tsubst_expr (pattern, args, complain, in_decl,
8449 /*integral_constant_expression_p=*/false);
8451 new_pat = tsubst (pattern, args, complain, in_decl);
8452 return make_pack_expansion (new_pat);
8455 /* We could not find any argument packs that work. */
8457 return error_mark_node;
8459 if (cp_unevaluated_operand)
8461 /* We're in a late-specified return type, so create our own local
8462 specializations table; the current table is either NULL or (in the
8463 case of recursive unification) might have bindings that we don't
8464 want to use or alter. */
8465 saved_local_specializations = local_specializations;
8466 local_specializations = htab_create (37,
8467 hash_local_specialization,
8468 eq_local_specializations,
8472 /* For each argument in each argument pack, substitute into the
8474 result = make_tree_vec (len + incomplete);
8475 for (i = 0; i < len + incomplete; ++i)
8477 /* For parameter pack, change the substitution of the parameter
8478 pack to the ith argument in its argument pack, then expand
8480 for (pack = packs; pack; pack = TREE_CHAIN (pack))
8482 tree parm = TREE_PURPOSE (pack);
8484 if (TREE_CODE (parm) == PARM_DECL)
8486 /* Select the Ith argument from the pack. */
8487 tree arg = make_node (ARGUMENT_PACK_SELECT);
8488 ARGUMENT_PACK_SELECT_FROM_PACK (arg) = TREE_VALUE (pack);
8489 ARGUMENT_PACK_SELECT_INDEX (arg) = i;
8491 register_local_specialization (arg, parm);
8497 template_parm_level_and_index (parm, &level, &idx);
8501 /* Select the Ith argument from the pack. */
8502 value = make_node (ARGUMENT_PACK_SELECT);
8503 ARGUMENT_PACK_SELECT_FROM_PACK (value) = TREE_VALUE (pack);
8504 ARGUMENT_PACK_SELECT_INDEX (value) = i;
8507 /* Update the corresponding argument. */
8508 TMPL_ARG (args, level, idx) = value;
8512 /* Substitute into the PATTERN with the altered arguments. */
8513 if (TREE_CODE (t) == EXPR_PACK_EXPANSION)
8514 TREE_VEC_ELT (result, i) =
8515 tsubst_expr (pattern, args, complain, in_decl,
8516 /*integral_constant_expression_p=*/false);
8518 TREE_VEC_ELT (result, i) = tsubst (pattern, args, complain, in_decl);
8521 /* When we have incomplete argument packs, the last "expanded"
8522 result is itself a pack expansion, which allows us
8523 to deduce more arguments. */
8524 TREE_VEC_ELT (result, i) =
8525 make_pack_expansion (TREE_VEC_ELT (result, i));
8527 if (TREE_VEC_ELT (result, i) == error_mark_node)
8529 result = error_mark_node;
8534 /* Update ARGS to restore the substitution from parameter packs to
8535 their argument packs. */
8536 for (pack = packs; pack; pack = TREE_CHAIN (pack))
8538 tree parm = TREE_PURPOSE (pack);
8540 if (TREE_CODE (parm) == PARM_DECL)
8541 register_local_specialization (TREE_TYPE (pack), parm);
8545 template_parm_level_and_index (parm, &level, &idx);
8547 /* Update the corresponding argument. */
8548 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
8549 TREE_VEC_ELT (TREE_VEC_ELT (args, level -1 ), idx) =
8552 TREE_VEC_ELT (args, idx) = TREE_TYPE (pack);
8556 if (saved_local_specializations)
8558 htab_delete (local_specializations);
8559 local_specializations = saved_local_specializations;
8565 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
8566 TMPL. We do this using DECL_PARM_INDEX, which should work even with
8567 parameter packs; all parms generated from a function parameter pack will
8568 have the same DECL_PARM_INDEX. */
8571 get_pattern_parm (tree parm, tree tmpl)
8573 tree pattern = DECL_TEMPLATE_RESULT (tmpl);
8576 if (DECL_ARTIFICIAL (parm))
8578 for (patparm = DECL_ARGUMENTS (pattern);
8579 patparm; patparm = DECL_CHAIN (patparm))
8580 if (DECL_ARTIFICIAL (patparm)
8581 && DECL_NAME (parm) == DECL_NAME (patparm))
8586 patparm = FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl));
8587 patparm = chain_index (DECL_PARM_INDEX (parm)-1, patparm);
8588 gcc_assert (DECL_PARM_INDEX (patparm)
8589 == DECL_PARM_INDEX (parm));
8595 /* Substitute ARGS into the vector or list of template arguments T. */
8598 tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl)
8601 int len = TREE_VEC_LENGTH (t);
8602 int need_new = 0, i, expanded_len_adjust = 0, out;
8603 tree *elts = XALLOCAVEC (tree, len);
8605 for (i = 0; i < len; i++)
8607 tree orig_arg = TREE_VEC_ELT (t, i);
8610 if (TREE_CODE (orig_arg) == TREE_VEC)
8611 new_arg = tsubst_template_args (orig_arg, args, complain, in_decl);
8612 else if (PACK_EXPANSION_P (orig_arg))
8614 /* Substitute into an expansion expression. */
8615 new_arg = tsubst_pack_expansion (orig_arg, args, complain, in_decl);
8617 if (TREE_CODE (new_arg) == TREE_VEC)
8618 /* Add to the expanded length adjustment the number of
8619 expanded arguments. We subtract one from this
8620 measurement, because the argument pack expression
8621 itself is already counted as 1 in
8622 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
8623 the argument pack is empty. */
8624 expanded_len_adjust += TREE_VEC_LENGTH (new_arg) - 1;
8626 else if (ARGUMENT_PACK_P (orig_arg))
8628 /* Substitute into each of the arguments. */
8629 new_arg = TYPE_P (orig_arg)
8630 ? cxx_make_type (TREE_CODE (orig_arg))
8631 : make_node (TREE_CODE (orig_arg));
8633 SET_ARGUMENT_PACK_ARGS (
8635 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg),
8636 args, complain, in_decl));
8638 if (ARGUMENT_PACK_ARGS (new_arg) == error_mark_node)
8639 new_arg = error_mark_node;
8641 if (TREE_CODE (new_arg) == NONTYPE_ARGUMENT_PACK) {
8642 TREE_TYPE (new_arg) = tsubst (TREE_TYPE (orig_arg), args,
8644 TREE_CONSTANT (new_arg) = TREE_CONSTANT (orig_arg);
8646 if (TREE_TYPE (new_arg) == error_mark_node)
8647 new_arg = error_mark_node;
8651 new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl);
8653 if (new_arg == error_mark_node)
8654 return error_mark_node;
8657 if (new_arg != orig_arg)
8664 /* Make space for the expanded arguments coming from template
8666 t = make_tree_vec (len + expanded_len_adjust);
8667 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
8668 arguments for a member template.
8669 In that case each TREE_VEC in ORIG_T represents a level of template
8670 arguments, and ORIG_T won't carry any non defaulted argument count.
8671 It will rather be the nested TREE_VECs that will carry one.
8672 In other words, ORIG_T carries a non defaulted argument count only
8673 if it doesn't contain any nested TREE_VEC. */
8674 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t))
8676 int count = GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t);
8677 count += expanded_len_adjust;
8678 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t, count);
8680 for (i = 0, out = 0; i < len; i++)
8682 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t, i))
8683 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t, i)))
8684 && TREE_CODE (elts[i]) == TREE_VEC)
8688 /* Now expand the template argument pack "in place". */
8689 for (idx = 0; idx < TREE_VEC_LENGTH (elts[i]); idx++, out++)
8690 TREE_VEC_ELT (t, out) = TREE_VEC_ELT (elts[i], idx);
8694 TREE_VEC_ELT (t, out) = elts[i];
8702 /* Return the result of substituting ARGS into the template parameters
8703 given by PARMS. If there are m levels of ARGS and m + n levels of
8704 PARMS, then the result will contain n levels of PARMS. For
8705 example, if PARMS is `template <class T> template <class U>
8706 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
8707 result will be `template <int*, double, class V>'. */
8710 tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain)
8715 /* When substituting into a template, we must set
8716 PROCESSING_TEMPLATE_DECL as the template parameters may be
8717 dependent if they are based on one-another, and the dependency
8718 predicates are short-circuit outside of templates. */
8719 ++processing_template_decl;
8721 for (new_parms = &r;
8722 TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args);
8723 new_parms = &(TREE_CHAIN (*new_parms)),
8724 parms = TREE_CHAIN (parms))
8727 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms)));
8730 for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i)
8736 if (parms == error_mark_node)
8739 tuple = TREE_VEC_ELT (TREE_VALUE (parms), i);
8741 if (tuple == error_mark_node)
8744 default_value = TREE_PURPOSE (tuple);
8745 parm_decl = TREE_VALUE (tuple);
8747 parm_decl = tsubst (parm_decl, args, complain, NULL_TREE);
8748 if (TREE_CODE (parm_decl) == PARM_DECL
8749 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl), complain))
8750 parm_decl = error_mark_node;
8751 default_value = tsubst_template_arg (default_value, args,
8752 complain, NULL_TREE);
8754 tuple = build_tree_list (default_value, parm_decl);
8755 TREE_VEC_ELT (new_vec, i) = tuple;
8759 tree_cons (size_int (TMPL_PARMS_DEPTH (parms)
8760 - TMPL_ARGS_DEPTH (args)),
8761 new_vec, NULL_TREE);
8764 --processing_template_decl;
8769 /* Substitute the ARGS into the indicated aggregate (or enumeration)
8770 type T. If T is not an aggregate or enumeration type, it is
8771 handled as if by tsubst. IN_DECL is as for tsubst. If
8772 ENTERING_SCOPE is nonzero, T is the context for a template which
8773 we are presently tsubst'ing. Return the substituted value. */
8776 tsubst_aggr_type (tree t,
8778 tsubst_flags_t complain,
8785 switch (TREE_CODE (t))
8788 if (TYPE_PTRMEMFUNC_P (t))
8789 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl);
8791 /* Else fall through. */
8794 if (TYPE_TEMPLATE_INFO (t) && uses_template_parms (t))
8799 int saved_unevaluated_operand;
8800 int saved_inhibit_evaluation_warnings;
8802 /* In "sizeof(X<I>)" we need to evaluate "I". */
8803 saved_unevaluated_operand = cp_unevaluated_operand;
8804 cp_unevaluated_operand = 0;
8805 saved_inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
8806 c_inhibit_evaluation_warnings = 0;
8808 /* First, determine the context for the type we are looking
8810 context = TYPE_CONTEXT (t);
8813 context = tsubst_aggr_type (context, args, complain,
8814 in_decl, /*entering_scope=*/1);
8815 /* If context is a nested class inside a class template,
8816 it may still need to be instantiated (c++/33959). */
8817 if (TYPE_P (context))
8818 context = complete_type (context);
8821 /* Then, figure out what arguments are appropriate for the
8822 type we are trying to find. For example, given:
8824 template <class T> struct S;
8825 template <class T, class U> void f(T, U) { S<U> su; }
8827 and supposing that we are instantiating f<int, double>,
8828 then our ARGS will be {int, double}, but, when looking up
8829 S we only want {double}. */
8830 argvec = tsubst_template_args (TYPE_TI_ARGS (t), args,
8832 if (argvec == error_mark_node)
8833 r = error_mark_node;
8836 r = lookup_template_class (t, argvec, in_decl, context,
8837 entering_scope, complain);
8838 r = cp_build_qualified_type_real (r, cp_type_quals (t), complain);
8841 cp_unevaluated_operand = saved_unevaluated_operand;
8842 c_inhibit_evaluation_warnings = saved_inhibit_evaluation_warnings;
8847 /* This is not a template type, so there's nothing to do. */
8851 return tsubst (t, args, complain, in_decl);
8855 /* Substitute into the default argument ARG (a default argument for
8856 FN), which has the indicated TYPE. */
8859 tsubst_default_argument (tree fn, tree type, tree arg)
8861 tree saved_class_ptr = NULL_TREE;
8862 tree saved_class_ref = NULL_TREE;
8864 /* This default argument came from a template. Instantiate the
8865 default argument here, not in tsubst. In the case of
8874 we must be careful to do name lookup in the scope of S<T>,
8875 rather than in the current class. */
8876 push_access_scope (fn);
8877 /* The "this" pointer is not valid in a default argument. */
8880 saved_class_ptr = current_class_ptr;
8881 cp_function_chain->x_current_class_ptr = NULL_TREE;
8882 saved_class_ref = current_class_ref;
8883 cp_function_chain->x_current_class_ref = NULL_TREE;
8886 push_deferring_access_checks(dk_no_deferred);
8887 /* The default argument expression may cause implicitly defined
8888 member functions to be synthesized, which will result in garbage
8889 collection. We must treat this situation as if we were within
8890 the body of function so as to avoid collecting live data on the
8893 arg = tsubst_expr (arg, DECL_TI_ARGS (fn),
8894 tf_warning_or_error, NULL_TREE,
8895 /*integral_constant_expression_p=*/false);
8897 pop_deferring_access_checks();
8899 /* Restore the "this" pointer. */
8902 cp_function_chain->x_current_class_ptr = saved_class_ptr;
8903 cp_function_chain->x_current_class_ref = saved_class_ref;
8906 /* Make sure the default argument is reasonable. */
8907 arg = check_default_argument (type, arg);
8909 pop_access_scope (fn);
8914 /* Substitute into all the default arguments for FN. */
8917 tsubst_default_arguments (tree fn)
8922 tmpl_args = DECL_TI_ARGS (fn);
8924 /* If this function is not yet instantiated, we certainly don't need
8925 its default arguments. */
8926 if (uses_template_parms (tmpl_args))
8929 for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
8931 arg = TREE_CHAIN (arg))
8932 if (TREE_PURPOSE (arg))
8933 TREE_PURPOSE (arg) = tsubst_default_argument (fn,
8935 TREE_PURPOSE (arg));
8938 /* Substitute the ARGS into the T, which is a _DECL. Return the
8939 result of the substitution. Issue error and warning messages under
8940 control of COMPLAIN. */
8943 tsubst_decl (tree t, tree args, tsubst_flags_t complain)
8945 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
8946 location_t saved_loc;
8951 /* Set the filename and linenumber to improve error-reporting. */
8952 saved_loc = input_location;
8953 input_location = DECL_SOURCE_LOCATION (t);
8955 switch (TREE_CODE (t))
8959 /* We can get here when processing a member function template,
8960 member class template, or template template parameter. */
8961 tree decl = DECL_TEMPLATE_RESULT (t);
8966 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
8968 /* Template template parameter is treated here. */
8969 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8970 if (new_type == error_mark_node)
8971 RETURN (error_mark_node);
8974 DECL_CHAIN (r) = NULL_TREE;
8975 TREE_TYPE (r) = new_type;
8976 DECL_TEMPLATE_RESULT (r)
8977 = build_decl (DECL_SOURCE_LOCATION (decl),
8978 TYPE_DECL, DECL_NAME (decl), new_type);
8979 DECL_TEMPLATE_PARMS (r)
8980 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
8982 TYPE_NAME (new_type) = r;
8986 /* We might already have an instance of this template.
8987 The ARGS are for the surrounding class type, so the
8988 full args contain the tsubst'd args for the context,
8989 plus the innermost args from the template decl. */
8990 tmpl_args = DECL_CLASS_TEMPLATE_P (t)
8991 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t))
8992 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t));
8993 /* Because this is a template, the arguments will still be
8994 dependent, even after substitution. If
8995 PROCESSING_TEMPLATE_DECL is not set, the dependency
8996 predicates will short-circuit. */
8997 ++processing_template_decl;
8998 full_args = tsubst_template_args (tmpl_args, args,
9000 --processing_template_decl;
9001 if (full_args == error_mark_node)
9002 RETURN (error_mark_node);
9004 /* If this is a default template template argument,
9005 tsubst might not have changed anything. */
9006 if (full_args == tmpl_args)
9009 hash = hash_tmpl_and_args (t, full_args);
9010 spec = retrieve_specialization (t, full_args, hash);
9011 if (spec != NULL_TREE)
9017 /* Make a new template decl. It will be similar to the
9018 original, but will record the current template arguments.
9019 We also create a new function declaration, which is just
9020 like the old one, but points to this new template, rather
9021 than the old one. */
9023 gcc_assert (DECL_LANG_SPECIFIC (r) != 0);
9024 DECL_CHAIN (r) = NULL_TREE;
9026 DECL_TEMPLATE_INFO (r) = build_template_info (t, args);
9028 if (TREE_CODE (decl) == TYPE_DECL)
9031 ++processing_template_decl;
9032 new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
9033 --processing_template_decl;
9034 if (new_type == error_mark_node)
9035 RETURN (error_mark_node);
9037 TREE_TYPE (r) = new_type;
9038 CLASSTYPE_TI_TEMPLATE (new_type) = r;
9039 DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type);
9040 DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type);
9041 DECL_CONTEXT (r) = TYPE_CONTEXT (new_type);
9046 ++processing_template_decl;
9047 new_decl = tsubst (decl, args, complain, in_decl);
9048 --processing_template_decl;
9049 if (new_decl == error_mark_node)
9050 RETURN (error_mark_node);
9052 DECL_TEMPLATE_RESULT (r) = new_decl;
9053 DECL_TI_TEMPLATE (new_decl) = r;
9054 TREE_TYPE (r) = TREE_TYPE (new_decl);
9055 DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl);
9056 DECL_CONTEXT (r) = DECL_CONTEXT (new_decl);
9059 SET_DECL_IMPLICIT_INSTANTIATION (r);
9060 DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE;
9061 DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE;
9063 /* The template parameters for this new template are all the
9064 template parameters for the old template, except the
9065 outermost level of parameters. */
9066 DECL_TEMPLATE_PARMS (r)
9067 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
9070 if (PRIMARY_TEMPLATE_P (t))
9071 DECL_PRIMARY_TEMPLATE (r) = r;
9073 if (TREE_CODE (decl) != TYPE_DECL)
9074 /* Record this non-type partial instantiation. */
9075 register_specialization (r, t,
9076 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r)),
9084 tree argvec = NULL_TREE;
9092 /* Nobody should be tsubst'ing into non-template functions. */
9093 gcc_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE);
9095 if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL)
9100 /* If T is not dependent, just return it. We have to
9101 increment PROCESSING_TEMPLATE_DECL because
9102 value_dependent_expression_p assumes that nothing is
9103 dependent when PROCESSING_TEMPLATE_DECL is zero. */
9104 ++processing_template_decl;
9105 dependent_p = value_dependent_expression_p (t);
9106 --processing_template_decl;
9110 /* Calculate the most general template of which R is a
9111 specialization, and the complete set of arguments used to
9113 gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
9114 argvec = tsubst_template_args (DECL_TI_ARGS
9115 (DECL_TEMPLATE_RESULT
9116 (DECL_TI_TEMPLATE (t))),
9117 args, complain, in_decl);
9119 /* Check to see if we already have this specialization. */
9120 hash = hash_tmpl_and_args (gen_tmpl, argvec);
9121 spec = retrieve_specialization (gen_tmpl, argvec, hash);
9129 /* We can see more levels of arguments than parameters if
9130 there was a specialization of a member template, like
9133 template <class T> struct S { template <class U> void f(); }
9134 template <> template <class U> void S<int>::f(U);
9136 Here, we'll be substituting into the specialization,
9137 because that's where we can find the code we actually
9138 want to generate, but we'll have enough arguments for
9139 the most general template.
9141 We also deal with the peculiar case:
9143 template <class T> struct S {
9144 template <class U> friend void f();
9146 template <class U> void f() {}
9148 template void f<double>();
9150 Here, the ARGS for the instantiation of will be {int,
9151 double}. But, we only need as many ARGS as there are
9152 levels of template parameters in CODE_PATTERN. We are
9153 careful not to get fooled into reducing the ARGS in
9156 template <class T> struct S { template <class U> void f(U); }
9157 template <class T> template <> void S<T>::f(int) {}
9159 which we can spot because the pattern will be a
9160 specialization in this case. */
9161 args_depth = TMPL_ARGS_DEPTH (args);
9163 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t)));
9164 if (args_depth > parms_depth
9165 && !DECL_TEMPLATE_SPECIALIZATION (t))
9166 args = get_innermost_template_args (args, parms_depth);
9170 /* This special case arises when we have something like this:
9172 template <class T> struct S {
9173 friend void f<int>(int, double);
9176 Here, the DECL_TI_TEMPLATE for the friend declaration
9177 will be an IDENTIFIER_NODE. We are being called from
9178 tsubst_friend_function, and we want only to create a
9179 new decl (R) with appropriate types so that we can call
9180 determine_specialization. */
9181 gen_tmpl = NULL_TREE;
9184 if (DECL_CLASS_SCOPE_P (t))
9186 if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t)))
9190 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
9191 complain, t, /*entering_scope=*/1);
9196 ctx = DECL_CONTEXT (t);
9198 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
9199 if (type == error_mark_node)
9200 RETURN (error_mark_node);
9202 /* We do NOT check for matching decls pushed separately at this
9203 point, as they may not represent instantiations of this
9204 template, and in any case are considered separate under the
9207 DECL_USE_TEMPLATE (r) = 0;
9208 TREE_TYPE (r) = type;
9209 /* Clear out the mangled name and RTL for the instantiation. */
9210 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
9211 SET_DECL_RTL (r, NULL);
9212 /* Leave DECL_INITIAL set on deleted instantiations. */
9213 if (!DECL_DELETED_FN (r))
9214 DECL_INITIAL (r) = NULL_TREE;
9215 DECL_CONTEXT (r) = ctx;
9217 if (member && DECL_CONV_FN_P (r))
9218 /* Type-conversion operator. Reconstruct the name, in
9219 case it's the name of one of the template's parameters. */
9220 DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type));
9222 DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args,
9224 DECL_RESULT (r) = NULL_TREE;
9226 TREE_STATIC (r) = 0;
9227 TREE_PUBLIC (r) = TREE_PUBLIC (t);
9228 DECL_EXTERNAL (r) = 1;
9229 /* If this is an instantiation of a function with internal
9230 linkage, we already know what object file linkage will be
9231 assigned to the instantiation. */
9232 DECL_INTERFACE_KNOWN (r) = !TREE_PUBLIC (r);
9233 DECL_DEFER_OUTPUT (r) = 0;
9234 DECL_CHAIN (r) = NULL_TREE;
9235 DECL_PENDING_INLINE_INFO (r) = 0;
9236 DECL_PENDING_INLINE_P (r) = 0;
9237 DECL_SAVED_TREE (r) = NULL_TREE;
9238 DECL_STRUCT_FUNCTION (r) = NULL;
9240 /* We'll re-clone as appropriate in instantiate_template. */
9241 DECL_CLONED_FUNCTION (r) = NULL_TREE;
9243 /* If we aren't complaining now, return on error before we register
9244 the specialization so that we'll complain eventually. */
9245 if ((complain & tf_error) == 0
9246 && IDENTIFIER_OPNAME_P (DECL_NAME (r))
9247 && !grok_op_properties (r, /*complain=*/false))
9248 RETURN (error_mark_node);
9250 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
9251 this in the special friend case mentioned above where
9252 GEN_TMPL is NULL. */
9255 DECL_TEMPLATE_INFO (r)
9256 = build_template_info (gen_tmpl, argvec);
9257 SET_DECL_IMPLICIT_INSTANTIATION (r);
9258 register_specialization (r, gen_tmpl, argvec, false, hash);
9260 /* We're not supposed to instantiate default arguments
9261 until they are called, for a template. But, for a
9264 template <class T> void f ()
9265 { extern void g(int i = T()); }
9267 we should do the substitution when the template is
9268 instantiated. We handle the member function case in
9269 instantiate_class_template since the default arguments
9270 might refer to other members of the class. */
9272 && !PRIMARY_TEMPLATE_P (gen_tmpl)
9273 && !uses_template_parms (argvec))
9274 tsubst_default_arguments (r);
9277 DECL_TEMPLATE_INFO (r) = NULL_TREE;
9279 /* Copy the list of befriending classes. */
9280 for (friends = &DECL_BEFRIENDING_CLASSES (r);
9282 friends = &TREE_CHAIN (*friends))
9284 *friends = copy_node (*friends);
9285 TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends),
9290 if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r))
9292 maybe_retrofit_in_chrg (r);
9293 if (DECL_CONSTRUCTOR_P (r))
9294 grok_ctor_properties (ctx, r);
9295 /* If this is an instantiation of a member template, clone it.
9296 If it isn't, that'll be handled by
9297 clone_constructors_and_destructors. */
9298 if (PRIMARY_TEMPLATE_P (gen_tmpl))
9299 clone_function_decl (r, /*update_method_vec_p=*/0);
9301 else if ((complain & tf_error) != 0
9302 && IDENTIFIER_OPNAME_P (DECL_NAME (r))
9303 && !grok_op_properties (r, /*complain=*/true))
9304 RETURN (error_mark_node);
9306 if (DECL_FRIEND_P (t) && DECL_FRIEND_CONTEXT (t))
9307 SET_DECL_FRIEND_CONTEXT (r,
9308 tsubst (DECL_FRIEND_CONTEXT (t),
9309 args, complain, in_decl));
9311 /* Possibly limit visibility based on template args. */
9312 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
9313 if (DECL_VISIBILITY_SPECIFIED (t))
9315 DECL_VISIBILITY_SPECIFIED (r) = 0;
9317 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
9319 determine_visibility (r);
9320 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r)
9321 && !processing_template_decl)
9322 defaulted_late_check (r);
9324 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
9325 args, complain, in_decl);
9331 tree type = NULL_TREE;
9333 tree expanded_types = NULL_TREE;
9334 tree prev_r = NULL_TREE;
9335 tree first_r = NULL_TREE;
9337 if (FUNCTION_PARAMETER_PACK_P (t))
9339 /* If there is a local specialization that isn't a
9340 parameter pack, it means that we're doing a "simple"
9341 substitution from inside tsubst_pack_expansion. Just
9342 return the local specialization (which will be a single
9344 tree spec = retrieve_local_specialization (t);
9346 && TREE_CODE (spec) == PARM_DECL
9347 && TREE_CODE (TREE_TYPE (spec)) != TYPE_PACK_EXPANSION)
9350 /* Expand the TYPE_PACK_EXPANSION that provides the types for
9351 the parameters in this function parameter pack. */
9352 expanded_types = tsubst_pack_expansion (TREE_TYPE (t), args,
9354 if (TREE_CODE (expanded_types) == TREE_VEC)
9356 len = TREE_VEC_LENGTH (expanded_types);
9358 /* Zero-length parameter packs are boring. Just substitute
9361 RETURN (tsubst (TREE_CHAIN (t), args, complain,
9366 /* All we did was update the type. Make a note of that. */
9367 type = expanded_types;
9368 expanded_types = NULL_TREE;
9372 /* Loop through all of the parameter's we'll build. When T is
9373 a function parameter pack, LEN is the number of expanded
9374 types in EXPANDED_TYPES; otherwise, LEN is 1. */
9376 for (i = 0; i < len; ++i)
9380 if (DECL_TEMPLATE_PARM_P (t))
9381 SET_DECL_TEMPLATE_PARM_P (r);
9383 /* An argument of a function parameter pack is not a parameter
9385 FUNCTION_PARAMETER_PACK_P (r) = false;
9388 /* We're on the Ith parameter of the function parameter
9391 /* Get the Ith type. */
9392 type = TREE_VEC_ELT (expanded_types, i);
9395 /* Rename the parameter to include the index. */
9397 make_ith_pack_parameter_name (DECL_NAME (r), i);
9400 /* We're dealing with a normal parameter. */
9401 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
9403 type = type_decays_to (type);
9404 TREE_TYPE (r) = type;
9405 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
9407 if (DECL_INITIAL (r))
9409 if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
9410 DECL_INITIAL (r) = TREE_TYPE (r);
9412 DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
9416 DECL_CONTEXT (r) = NULL_TREE;
9418 if (!DECL_TEMPLATE_PARM_P (r))
9419 DECL_ARG_TYPE (r) = type_passed_as (type);
9421 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
9422 args, complain, in_decl);
9424 /* Keep track of the first new parameter we
9425 generate. That's what will be returned to the
9430 /* Build a proper chain of parameters when substituting
9431 into a function parameter pack. */
9433 DECL_CHAIN (prev_r) = r;
9437 DECL_CHAIN (r) = tsubst (DECL_CHAIN (t), args,
9438 complain, DECL_CHAIN (t));
9440 /* FIRST_R contains the start of the chain we've built. */
9450 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
9451 if (type == error_mark_node)
9452 RETURN (error_mark_node);
9453 TREE_TYPE (r) = type;
9454 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
9456 /* DECL_INITIAL gives the number of bits in a bit-field. */
9458 = tsubst_expr (DECL_INITIAL (t), args,
9460 /*integral_constant_expression_p=*/true);
9461 /* We don't have to set DECL_CONTEXT here; it is set by
9462 finish_member_declaration. */
9463 DECL_CHAIN (r) = NULL_TREE;
9464 if (VOID_TYPE_P (type))
9465 error ("instantiation of %q+D as type %qT", r, type);
9467 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
9468 args, complain, in_decl);
9473 /* We reach here only for member using decls. */
9474 if (DECL_DEPENDENT_P (t))
9476 r = do_class_using_decl
9477 (tsubst_copy (USING_DECL_SCOPE (t), args, complain, in_decl),
9478 tsubst_copy (DECL_NAME (t), args, complain, in_decl));
9480 r = error_mark_node;
9483 TREE_PROTECTED (r) = TREE_PROTECTED (t);
9484 TREE_PRIVATE (r) = TREE_PRIVATE (t);
9490 DECL_CHAIN (r) = NULL_TREE;
9497 tree argvec = NULL_TREE;
9498 tree gen_tmpl = NULL_TREE;
9500 tree tmpl = NULL_TREE;
9502 tree type = NULL_TREE;
9505 if (TREE_CODE (t) == TYPE_DECL
9506 && t == TYPE_MAIN_DECL (TREE_TYPE (t)))
9508 /* If this is the canonical decl, we don't have to
9509 mess with instantiations, and often we can't (for
9510 typename, template type parms and such). Note that
9511 TYPE_NAME is not correct for the above test if
9512 we've copied the type for a typedef. */
9513 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
9514 if (type == error_mark_node)
9515 RETURN (error_mark_node);
9516 r = TYPE_NAME (type);
9520 /* Check to see if we already have the specialization we
9523 if (DECL_CLASS_SCOPE_P (t) || DECL_NAMESPACE_SCOPE_P (t))
9525 /* T is a static data member or namespace-scope entity.
9526 We have to substitute into namespace-scope variables
9527 (even though such entities are never templates) because
9530 template <class T> void f() { extern T t; }
9532 where the entity referenced is not known until
9533 instantiation time. */
9535 ctx = DECL_CONTEXT (t);
9536 if (DECL_CLASS_SCOPE_P (t))
9538 ctx = tsubst_aggr_type (ctx, args,
9540 in_decl, /*entering_scope=*/1);
9541 /* If CTX is unchanged, then T is in fact the
9542 specialization we want. That situation occurs when
9543 referencing a static data member within in its own
9544 class. We can use pointer equality, rather than
9545 same_type_p, because DECL_CONTEXT is always
9547 if (ctx == DECL_CONTEXT (t))
9553 tmpl = DECL_TI_TEMPLATE (t);
9554 gen_tmpl = most_general_template (tmpl);
9555 argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl);
9556 hash = hash_tmpl_and_args (gen_tmpl, argvec);
9557 spec = retrieve_specialization (gen_tmpl, argvec, hash);
9562 /* A local variable. */
9564 /* Subsequent calls to pushdecl will fill this in. */
9566 spec = retrieve_local_specialization (t);
9568 /* If we already have the specialization we need, there is
9569 nothing more to do. */
9576 /* Create a new node for the specialization we need. */
9578 if (type == NULL_TREE)
9580 if (is_typedef_decl (t))
9581 type = DECL_ORIGINAL_TYPE (t);
9583 type = TREE_TYPE (t);
9584 if (TREE_CODE (t) == VAR_DECL && VAR_HAD_UNKNOWN_BOUND (t))
9585 type = strip_array_domain (type);
9586 type = tsubst (type, args, complain, in_decl);
9588 if (TREE_CODE (r) == VAR_DECL)
9590 /* Even if the original location is out of scope, the
9591 newly substituted one is not. */
9592 DECL_DEAD_FOR_LOCAL (r) = 0;
9593 DECL_INITIALIZED_P (r) = 0;
9594 DECL_TEMPLATE_INSTANTIATED (r) = 0;
9595 if (type == error_mark_node)
9596 RETURN (error_mark_node);
9597 if (TREE_CODE (type) == FUNCTION_TYPE)
9599 /* It may seem that this case cannot occur, since:
9604 declares a function, not a variable. However:
9607 template <typename T> void g() { T t; }
9608 template void g<f>();
9610 is an attempt to declare a variable with function
9612 error ("variable %qD has function type",
9613 /* R is not yet sufficiently initialized, so we
9614 just use its name. */
9616 RETURN (error_mark_node);
9618 type = complete_type (type);
9619 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
9620 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t);
9621 type = check_var_type (DECL_NAME (r), type);
9623 if (DECL_HAS_VALUE_EXPR_P (t))
9625 tree ve = DECL_VALUE_EXPR (t);
9626 ve = tsubst_expr (ve, args, complain, in_decl,
9627 /*constant_expression_p=*/false);
9628 SET_DECL_VALUE_EXPR (r, ve);
9631 else if (DECL_SELF_REFERENCE_P (t))
9632 SET_DECL_SELF_REFERENCE_P (r);
9633 TREE_TYPE (r) = type;
9634 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
9635 DECL_CONTEXT (r) = ctx;
9636 /* Clear out the mangled name and RTL for the instantiation. */
9637 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
9638 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
9639 SET_DECL_RTL (r, NULL);
9640 /* The initializer must not be expanded until it is required;
9642 DECL_INITIAL (r) = NULL_TREE;
9643 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
9644 SET_DECL_RTL (r, NULL);
9645 DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0;
9646 if (TREE_CODE (r) == VAR_DECL)
9648 /* Possibly limit visibility based on template args. */
9649 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
9650 if (DECL_VISIBILITY_SPECIFIED (t))
9652 DECL_VISIBILITY_SPECIFIED (r) = 0;
9654 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
9656 determine_visibility (r);
9661 /* A static data member declaration is always marked
9662 external when it is declared in-class, even if an
9663 initializer is present. We mimic the non-template
9665 DECL_EXTERNAL (r) = 1;
9667 register_specialization (r, gen_tmpl, argvec, false, hash);
9668 DECL_TEMPLATE_INFO (r) = build_template_info (tmpl, argvec);
9669 SET_DECL_IMPLICIT_INSTANTIATION (r);
9671 else if (cp_unevaluated_operand)
9673 /* We're substituting this var in a decltype outside of its
9674 scope, such as for a lambda return type. Don't add it to
9675 local_specializations, do perform auto deduction. */
9676 tree auto_node = type_uses_auto (type);
9678 = tsubst_expr (DECL_INITIAL (t), args, complain, in_decl,
9679 /*constant_expression_p=*/false);
9681 if (auto_node && init && describable_type (init))
9683 type = do_auto_deduction (type, init, auto_node);
9684 TREE_TYPE (r) = type;
9688 register_local_specialization (r, t);
9690 DECL_CHAIN (r) = NULL_TREE;
9692 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r),
9694 args, complain, in_decl);
9696 /* Preserve a typedef that names a type. */
9697 if (is_typedef_decl (r))
9699 DECL_ORIGINAL_TYPE (r) = NULL_TREE;
9700 set_underlying_type (r);
9713 /* Restore the file and line information. */
9714 input_location = saved_loc;
9719 /* Substitute into the ARG_TYPES of a function type. */
9722 tsubst_arg_types (tree arg_types,
9724 tsubst_flags_t complain,
9727 tree remaining_arg_types;
9728 tree type = NULL_TREE;
9730 tree expanded_args = NULL_TREE;
9733 if (!arg_types || arg_types == void_list_node)
9736 remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types),
9737 args, complain, in_decl);
9738 if (remaining_arg_types == error_mark_node)
9739 return error_mark_node;
9741 if (PACK_EXPANSION_P (TREE_VALUE (arg_types)))
9743 /* For a pack expansion, perform substitution on the
9744 entire expression. Later on, we'll handle the arguments
9746 expanded_args = tsubst_pack_expansion (TREE_VALUE (arg_types),
9747 args, complain, in_decl);
9749 if (TREE_CODE (expanded_args) == TREE_VEC)
9750 /* So that we'll spin through the parameters, one by one. */
9751 i = TREE_VEC_LENGTH (expanded_args);
9754 /* We only partially substituted into the parameter
9755 pack. Our type is TYPE_PACK_EXPANSION. */
9756 type = expanded_args;
9757 expanded_args = NULL_TREE;
9765 type = TREE_VEC_ELT (expanded_args, i);
9767 type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
9769 if (type == error_mark_node)
9770 return error_mark_node;
9771 if (VOID_TYPE_P (type))
9773 if (complain & tf_error)
9775 error ("invalid parameter type %qT", type);
9777 error ("in declaration %q+D", in_decl);
9779 return error_mark_node;
9782 /* Do array-to-pointer, function-to-pointer conversion, and ignore
9783 top-level qualifiers as required. */
9784 type = TYPE_MAIN_VARIANT (type_decays_to (type));
9786 /* We do not substitute into default arguments here. The standard
9787 mandates that they be instantiated only when needed, which is
9788 done in build_over_call. */
9789 default_arg = TREE_PURPOSE (arg_types);
9791 if (default_arg && TREE_CODE (default_arg) == DEFAULT_ARG)
9793 /* We've instantiated a template before its default arguments
9794 have been parsed. This can happen for a nested template
9795 class, and is not an error unless we require the default
9796 argument in a call of this function. */
9797 remaining_arg_types =
9798 tree_cons (default_arg, type, remaining_arg_types);
9799 VEC_safe_push (tree, gc, DEFARG_INSTANTIATIONS (default_arg),
9800 remaining_arg_types);
9803 remaining_arg_types =
9804 hash_tree_cons (default_arg, type, remaining_arg_types);
9807 return remaining_arg_types;
9810 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
9811 *not* handle the exception-specification for FNTYPE, because the
9812 initial substitution of explicitly provided template parameters
9813 during argument deduction forbids substitution into the
9814 exception-specification:
9818 All references in the function type of the function template to the
9819 corresponding template parameters are replaced by the specified tem-
9820 plate argument values. If a substitution in a template parameter or
9821 in the function type of the function template results in an invalid
9822 type, type deduction fails. [Note: The equivalent substitution in
9823 exception specifications is done only when the function is instanti-
9824 ated, at which point a program is ill-formed if the substitution
9825 results in an invalid type.] */
9828 tsubst_function_type (tree t,
9830 tsubst_flags_t complain,
9837 /* The TYPE_CONTEXT is not used for function/method types. */
9838 gcc_assert (TYPE_CONTEXT (t) == NULL_TREE);
9840 /* Substitute the return type. */
9841 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
9842 if (return_type == error_mark_node)
9843 return error_mark_node;
9844 /* The standard does not presently indicate that creation of a
9845 function type with an invalid return type is a deduction failure.
9846 However, that is clearly analogous to creating an array of "void"
9847 or a reference to a reference. This is core issue #486. */
9848 if (TREE_CODE (return_type) == ARRAY_TYPE
9849 || TREE_CODE (return_type) == FUNCTION_TYPE)
9851 if (complain & tf_error)
9853 if (TREE_CODE (return_type) == ARRAY_TYPE)
9854 error ("function returning an array");
9856 error ("function returning a function");
9858 return error_mark_node;
9861 /* Substitute the argument types. */
9862 arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args,
9864 if (arg_types == error_mark_node)
9865 return error_mark_node;
9867 /* Construct a new type node and return it. */
9868 if (TREE_CODE (t) == FUNCTION_TYPE)
9870 fntype = build_function_type (return_type, arg_types);
9871 fntype = apply_memfn_quals (fntype, type_memfn_quals (t));
9875 tree r = TREE_TYPE (TREE_VALUE (arg_types));
9876 if (! MAYBE_CLASS_TYPE_P (r))
9880 Type deduction may fail for any of the following
9883 -- Attempting to create "pointer to member of T" when T
9884 is not a class type. */
9885 if (complain & tf_error)
9886 error ("creating pointer to member function of non-class type %qT",
9888 return error_mark_node;
9891 fntype = build_method_type_directly (r, return_type,
9892 TREE_CHAIN (arg_types));
9894 fntype = cp_build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t));
9899 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
9900 ARGS into that specification, and return the substituted
9901 specification. If there is no specification, return NULL_TREE. */
9904 tsubst_exception_specification (tree fntype,
9906 tsubst_flags_t complain,
9912 specs = TYPE_RAISES_EXCEPTIONS (fntype);
9913 new_specs = NULL_TREE;
9914 if (specs && TREE_PURPOSE (specs))
9916 /* A noexcept-specifier. */
9917 new_specs = tsubst_copy_and_build
9918 (TREE_PURPOSE (specs), args, complain, in_decl, /*function_p=*/false,
9919 /*integral_constant_expression_p=*/true);
9920 new_specs = build_noexcept_spec (new_specs, complain);
9924 if (! TREE_VALUE (specs))
9931 tree expanded_specs = NULL_TREE;
9933 if (PACK_EXPANSION_P (TREE_VALUE (specs)))
9935 /* Expand the pack expansion type. */
9936 expanded_specs = tsubst_pack_expansion (TREE_VALUE (specs),
9940 if (expanded_specs == error_mark_node)
9941 return error_mark_node;
9942 else if (TREE_CODE (expanded_specs) == TREE_VEC)
9943 len = TREE_VEC_LENGTH (expanded_specs);
9946 /* We're substituting into a member template, so
9947 we got a TYPE_PACK_EXPANSION back. Add that
9948 expansion and move on. */
9949 gcc_assert (TREE_CODE (expanded_specs)
9950 == TYPE_PACK_EXPANSION);
9951 new_specs = add_exception_specifier (new_specs,
9954 specs = TREE_CHAIN (specs);
9959 for (i = 0; i < len; ++i)
9962 spec = TREE_VEC_ELT (expanded_specs, i);
9964 spec = tsubst (TREE_VALUE (specs), args, complain, in_decl);
9965 if (spec == error_mark_node)
9967 new_specs = add_exception_specifier (new_specs, spec,
9971 specs = TREE_CHAIN (specs);
9977 /* Take the tree structure T and replace template parameters used
9978 therein with the argument vector ARGS. IN_DECL is an associated
9979 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
9980 Issue error and warning messages under control of COMPLAIN. Note
9981 that we must be relatively non-tolerant of extensions here, in
9982 order to preserve conformance; if we allow substitutions that
9983 should not be allowed, we may allow argument deductions that should
9984 not succeed, and therefore report ambiguous overload situations
9985 where there are none. In theory, we could allow the substitution,
9986 but indicate that it should have failed, and allow our caller to
9987 make sure that the right thing happens, but we don't try to do this
9990 This function is used for dealing with types, decls and the like;
9991 for expressions, use tsubst_expr or tsubst_copy. */
9994 tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
9996 enum tree_code code;
9999 if (t == NULL_TREE || t == error_mark_node
10000 || t == integer_type_node
10001 || t == void_type_node
10002 || t == char_type_node
10003 || t == unknown_type_node
10004 || TREE_CODE (t) == NAMESPACE_DECL)
10008 return tsubst_decl (t, args, complain);
10010 if (args == NULL_TREE)
10013 code = TREE_CODE (t);
10015 if (code == IDENTIFIER_NODE)
10016 type = IDENTIFIER_TYPE_VALUE (t);
10018 type = TREE_TYPE (t);
10020 gcc_assert (type != unknown_type_node);
10022 /* Reuse typedefs. We need to do this to handle dependent attributes,
10023 such as attribute aligned. */
10026 && TYPE_NAME (t) != TYPE_MAIN_DECL (t))
10028 tree decl = TYPE_NAME (t);
10030 if (DECL_CLASS_SCOPE_P (decl)
10031 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl))
10032 && uses_template_parms (DECL_CONTEXT (decl)))
10034 tree tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
10035 tree gen_args = tsubst (DECL_TI_ARGS (decl), args, complain, in_decl);
10036 r = retrieve_specialization (tmpl, gen_args, 0);
10038 else if (DECL_FUNCTION_SCOPE_P (decl)
10039 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl))
10040 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl))))
10041 r = retrieve_local_specialization (decl);
10043 /* The typedef is from a non-template context. */
10049 r = cp_build_qualified_type_real
10050 (r, cp_type_quals (t) | cp_type_quals (r),
10051 complain | tf_ignore_bad_quals);
10054 /* Else we must be instantiating the typedef, so fall through. */
10058 && code != TYPENAME_TYPE
10059 && code != TEMPLATE_TYPE_PARM
10060 && code != IDENTIFIER_NODE
10061 && code != FUNCTION_TYPE
10062 && code != METHOD_TYPE)
10063 type = tsubst (type, args, complain, in_decl);
10064 if (type == error_mark_node)
10065 return error_mark_node;
10071 case ENUMERAL_TYPE:
10072 return tsubst_aggr_type (t, args, complain, in_decl,
10073 /*entering_scope=*/0);
10076 case IDENTIFIER_NODE:
10088 if (t == integer_type_node)
10091 if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
10092 && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
10096 tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);
10098 max = tsubst_expr (omax, args, complain, in_decl,
10099 /*integral_constant_expression_p=*/false);
10101 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
10103 if (TREE_CODE (max) == NOP_EXPR
10104 && TREE_SIDE_EFFECTS (omax)
10105 && !TREE_TYPE (max))
10106 TREE_TYPE (max) = TREE_TYPE (TREE_OPERAND (max, 0));
10108 max = fold_decl_constant_value (max);
10110 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
10111 with TREE_SIDE_EFFECTS that indicates this is not an integral
10112 constant expression. */
10113 if (processing_template_decl
10114 && TREE_SIDE_EFFECTS (omax) && TREE_CODE (omax) == NOP_EXPR)
10116 gcc_assert (TREE_CODE (max) == NOP_EXPR);
10117 TREE_SIDE_EFFECTS (max) = 1;
10120 if (TREE_CODE (max) != INTEGER_CST
10121 && !at_function_scope_p ()
10122 && !TREE_SIDE_EFFECTS (max)
10123 && !value_dependent_expression_p (max))
10125 if (complain & tf_error)
10126 error ("array bound is not an integer constant");
10127 return error_mark_node;
10132 Type deduction may fail for any of the following
10135 Attempting to create an array with a size that is
10136 zero or negative. */
10137 if (integer_zerop (max) && !(complain & tf_error))
10138 /* We must fail if performing argument deduction (as
10139 indicated by the state of complain), so that
10140 another substitution can be found. */
10141 return error_mark_node;
10142 else if (TREE_CODE (max) == INTEGER_CST
10143 && INT_CST_LT (max, integer_zero_node))
10145 if (complain & tf_error)
10146 error ("creating array with negative size (%qE)", max);
10148 return error_mark_node;
10151 return compute_array_index_type (NULL_TREE, max);
10154 case TEMPLATE_TYPE_PARM:
10155 case TEMPLATE_TEMPLATE_PARM:
10156 case BOUND_TEMPLATE_TEMPLATE_PARM:
10157 case TEMPLATE_PARM_INDEX:
10162 tree arg = NULL_TREE;
10166 gcc_assert (TREE_VEC_LENGTH (args) > 0);
10167 template_parm_level_and_index (t, &level, &idx);
10169 levels = TMPL_ARGS_DEPTH (args);
10170 if (level <= levels)
10172 arg = TMPL_ARG (args, level, idx);
10174 if (arg && TREE_CODE (arg) == ARGUMENT_PACK_SELECT)
10175 /* See through ARGUMENT_PACK_SELECT arguments. */
10176 arg = ARGUMENT_PACK_SELECT_ARG (arg);
10179 if (arg == error_mark_node)
10180 return error_mark_node;
10181 else if (arg != NULL_TREE)
10183 if (ARGUMENT_PACK_P (arg))
10184 /* If ARG is an argument pack, we don't actually want to
10185 perform a substitution here, because substitutions
10186 for argument packs are only done
10187 element-by-element. We can get to this point when
10188 substituting the type of a non-type template
10189 parameter pack, when that type actually contains
10190 template parameter packs from an outer template, e.g.,
10192 template<typename... Types> struct A {
10193 template<Types... Values> struct B { };
10197 if (code == TEMPLATE_TYPE_PARM)
10200 gcc_assert (TYPE_P (arg));
10202 quals = cp_type_quals (arg) | cp_type_quals (t);
10204 return cp_build_qualified_type_real
10205 (arg, quals, complain | tf_ignore_bad_quals);
10207 else if (code == BOUND_TEMPLATE_TEMPLATE_PARM)
10209 /* We are processing a type constructed from a
10210 template template parameter. */
10211 tree argvec = tsubst (TYPE_TI_ARGS (t),
10212 args, complain, in_decl);
10213 if (argvec == error_mark_node)
10214 return error_mark_node;
10216 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
10217 are resolving nested-types in the signature of a
10218 member function templates. Otherwise ARG is a
10219 TEMPLATE_DECL and is the real template to be
10221 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
10222 arg = TYPE_NAME (arg);
10224 r = lookup_template_class (arg,
10226 DECL_CONTEXT (arg),
10227 /*entering_scope=*/0,
10229 return cp_build_qualified_type_real
10230 (r, cp_type_quals (t), complain);
10233 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
10234 return unshare_expr (arg);
10238 /* This can happen during the attempted tsubst'ing in
10239 unify. This means that we don't yet have any information
10240 about the template parameter in question. */
10243 /* If we get here, we must have been looking at a parm for a
10244 more deeply nested template. Make a new version of this
10245 template parameter, but with a lower level. */
10248 case TEMPLATE_TYPE_PARM:
10249 case TEMPLATE_TEMPLATE_PARM:
10250 case BOUND_TEMPLATE_TEMPLATE_PARM:
10251 if (cp_type_quals (t))
10253 r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
10254 r = cp_build_qualified_type_real
10255 (r, cp_type_quals (t),
10256 complain | (code == TEMPLATE_TYPE_PARM
10257 ? tf_ignore_bad_quals : 0));
10262 TEMPLATE_TYPE_PARM_INDEX (r)
10263 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t),
10264 r, levels, args, complain);
10265 TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r);
10266 TYPE_MAIN_VARIANT (r) = r;
10267 TYPE_POINTER_TO (r) = NULL_TREE;
10268 TYPE_REFERENCE_TO (r) = NULL_TREE;
10270 if (TREE_CODE (r) == TEMPLATE_TEMPLATE_PARM)
10271 /* We have reduced the level of the template
10272 template parameter, but not the levels of its
10273 template parameters, so canonical_type_parameter
10274 will not be able to find the canonical template
10275 template parameter for this level. Thus, we
10276 require structural equality checking to compare
10277 TEMPLATE_TEMPLATE_PARMs. */
10278 SET_TYPE_STRUCTURAL_EQUALITY (r);
10279 else if (TYPE_STRUCTURAL_EQUALITY_P (t))
10280 SET_TYPE_STRUCTURAL_EQUALITY (r);
10282 TYPE_CANONICAL (r) = canonical_type_parameter (r);
10284 if (code == BOUND_TEMPLATE_TEMPLATE_PARM)
10286 tree argvec = tsubst (TYPE_TI_ARGS (t), args,
10287 complain, in_decl);
10288 if (argvec == error_mark_node)
10289 return error_mark_node;
10291 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r)
10292 = build_template_info (TYPE_TI_TEMPLATE (t), argvec);
10297 case TEMPLATE_PARM_INDEX:
10298 r = reduce_template_parm_level (t, type, levels, args, complain);
10302 gcc_unreachable ();
10310 tree purpose, value, chain;
10312 if (t == void_list_node)
10315 purpose = TREE_PURPOSE (t);
10318 purpose = tsubst (purpose, args, complain, in_decl);
10319 if (purpose == error_mark_node)
10320 return error_mark_node;
10322 value = TREE_VALUE (t);
10325 value = tsubst (value, args, complain, in_decl);
10326 if (value == error_mark_node)
10327 return error_mark_node;
10329 chain = TREE_CHAIN (t);
10330 if (chain && chain != void_type_node)
10332 chain = tsubst (chain, args, complain, in_decl);
10333 if (chain == error_mark_node)
10334 return error_mark_node;
10336 if (purpose == TREE_PURPOSE (t)
10337 && value == TREE_VALUE (t)
10338 && chain == TREE_CHAIN (t))
10340 return hash_tree_cons (purpose, value, chain);
10344 /* We should never be tsubsting a binfo. */
10345 gcc_unreachable ();
10348 /* A vector of template arguments. */
10349 gcc_assert (!type);
10350 return tsubst_template_args (t, args, complain, in_decl);
10353 case REFERENCE_TYPE:
10355 if (type == TREE_TYPE (t) && TREE_CODE (type) != METHOD_TYPE)
10360 Type deduction may fail for any of the following
10363 -- Attempting to create a pointer to reference type.
10364 -- Attempting to create a reference to a reference type or
10365 a reference to void.
10367 Core issue 106 says that creating a reference to a reference
10368 during instantiation is no longer a cause for failure. We
10369 only enforce this check in strict C++98 mode. */
10370 if ((TREE_CODE (type) == REFERENCE_TYPE
10371 && (((cxx_dialect == cxx98) && flag_iso) || code != REFERENCE_TYPE))
10372 || (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE))
10374 static location_t last_loc;
10376 /* We keep track of the last time we issued this error
10377 message to avoid spewing a ton of messages during a
10378 single bad template instantiation. */
10379 if (complain & tf_error
10380 && last_loc != input_location)
10382 if (TREE_CODE (type) == VOID_TYPE)
10383 error ("forming reference to void");
10384 else if (code == POINTER_TYPE)
10385 error ("forming pointer to reference type %qT", type);
10387 error ("forming reference to reference type %qT", type);
10388 last_loc = input_location;
10391 return error_mark_node;
10393 else if (code == POINTER_TYPE)
10395 r = build_pointer_type (type);
10396 if (TREE_CODE (type) == METHOD_TYPE)
10397 r = build_ptrmemfunc_type (r);
10399 else if (TREE_CODE (type) == REFERENCE_TYPE)
10400 /* In C++0x, during template argument substitution, when there is an
10401 attempt to create a reference to a reference type, reference
10402 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
10404 "If a template-argument for a template-parameter T names a type
10405 that is a reference to a type A, an attempt to create the type
10406 'lvalue reference to cv T' creates the type 'lvalue reference to
10407 A,' while an attempt to create the type type rvalue reference to
10408 cv T' creates the type T"
10410 r = cp_build_reference_type
10412 TYPE_REF_IS_RVALUE (t) && TYPE_REF_IS_RVALUE (type));
10414 r = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
10415 r = cp_build_qualified_type_real (r, cp_type_quals (t), complain);
10417 if (r != error_mark_node)
10418 /* Will this ever be needed for TYPE_..._TO values? */
10425 r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
10426 if (r == error_mark_node || !MAYBE_CLASS_TYPE_P (r))
10430 Type deduction may fail for any of the following
10433 -- Attempting to create "pointer to member of T" when T
10434 is not a class type. */
10435 if (complain & tf_error)
10436 error ("creating pointer to member of non-class type %qT", r);
10437 return error_mark_node;
10439 if (TREE_CODE (type) == REFERENCE_TYPE)
10441 if (complain & tf_error)
10442 error ("creating pointer to member reference type %qT", type);
10443 return error_mark_node;
10445 if (TREE_CODE (type) == VOID_TYPE)
10447 if (complain & tf_error)
10448 error ("creating pointer to member of type void");
10449 return error_mark_node;
10451 gcc_assert (TREE_CODE (type) != METHOD_TYPE);
10452 if (TREE_CODE (type) == FUNCTION_TYPE)
10454 /* The type of the implicit object parameter gets its
10455 cv-qualifiers from the FUNCTION_TYPE. */
10457 tree method_type = build_memfn_type (type, r, type_memfn_quals (type));
10458 memptr = build_ptrmemfunc_type (build_pointer_type (method_type));
10459 return cp_build_qualified_type_real (memptr, cp_type_quals (t),
10463 return cp_build_qualified_type_real (build_ptrmem_type (r, type),
10467 case FUNCTION_TYPE:
10472 fntype = tsubst_function_type (t, args, complain, in_decl);
10473 if (fntype == error_mark_node)
10474 return error_mark_node;
10476 /* Substitute the exception specification. */
10477 specs = tsubst_exception_specification (t, args, complain,
10479 if (specs == error_mark_node)
10480 return error_mark_node;
10482 fntype = build_exception_variant (fntype, specs);
10487 tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
10488 if (domain == error_mark_node)
10489 return error_mark_node;
10491 /* As an optimization, we avoid regenerating the array type if
10492 it will obviously be the same as T. */
10493 if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
10496 /* These checks should match the ones in grokdeclarator.
10500 The deduction may fail for any of the following reasons:
10502 -- Attempting to create an array with an element type that
10503 is void, a function type, or a reference type, or [DR337]
10504 an abstract class type. */
10505 if (TREE_CODE (type) == VOID_TYPE
10506 || TREE_CODE (type) == FUNCTION_TYPE
10507 || TREE_CODE (type) == REFERENCE_TYPE)
10509 if (complain & tf_error)
10510 error ("creating array of %qT", type);
10511 return error_mark_node;
10513 if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
10515 if (complain & tf_error)
10516 error ("creating array of %qT, which is an abstract class type",
10518 return error_mark_node;
10521 r = build_cplus_array_type (type, domain);
10523 if (TYPE_USER_ALIGN (t))
10525 TYPE_ALIGN (r) = TYPE_ALIGN (t);
10526 TYPE_USER_ALIGN (r) = 1;
10535 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
10536 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
10538 if (e1 == error_mark_node || e2 == error_mark_node)
10539 return error_mark_node;
10541 return fold_build2_loc (input_location,
10542 code, TREE_TYPE (t), e1, e2);
10548 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
10549 if (e == error_mark_node)
10550 return error_mark_node;
10552 return fold_build1_loc (input_location, code, TREE_TYPE (t), e);
10555 case TYPENAME_TYPE:
10557 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
10558 in_decl, /*entering_scope=*/1);
10559 tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
10560 complain, in_decl);
10562 if (ctx == error_mark_node || f == error_mark_node)
10563 return error_mark_node;
10565 if (!MAYBE_CLASS_TYPE_P (ctx))
10567 if (complain & tf_error)
10568 error ("%qT is not a class, struct, or union type", ctx);
10569 return error_mark_node;
10571 else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
10573 /* Normally, make_typename_type does not require that the CTX
10574 have complete type in order to allow things like:
10576 template <class T> struct S { typename S<T>::X Y; };
10578 But, such constructs have already been resolved by this
10579 point, so here CTX really should have complete type, unless
10580 it's a partial instantiation. */
10581 if (!(complain & tf_no_class_instantiations))
10582 ctx = complete_type (ctx);
10583 if (!COMPLETE_TYPE_P (ctx))
10585 if (complain & tf_error)
10586 cxx_incomplete_type_error (NULL_TREE, ctx);
10587 return error_mark_node;
10591 f = make_typename_type (ctx, f, typename_type,
10592 (complain & tf_error) | tf_keep_type_decl);
10593 if (f == error_mark_node)
10595 if (TREE_CODE (f) == TYPE_DECL)
10597 complain |= tf_ignore_bad_quals;
10601 if (TREE_CODE (f) != TYPENAME_TYPE)
10603 if (TYPENAME_IS_ENUM_P (t) && TREE_CODE (f) != ENUMERAL_TYPE)
10604 error ("%qT resolves to %qT, which is not an enumeration type",
10606 else if (TYPENAME_IS_CLASS_P (t) && !CLASS_TYPE_P (f))
10607 error ("%qT resolves to %qT, which is is not a class type",
10611 return cp_build_qualified_type_real
10612 (f, cp_type_quals (f) | cp_type_quals (t), complain);
10615 case UNBOUND_CLASS_TEMPLATE:
10617 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
10618 in_decl, /*entering_scope=*/1);
10619 tree name = TYPE_IDENTIFIER (t);
10620 tree parm_list = DECL_TEMPLATE_PARMS (TYPE_NAME (t));
10622 if (ctx == error_mark_node || name == error_mark_node)
10623 return error_mark_node;
10626 parm_list = tsubst_template_parms (parm_list, args, complain);
10627 return make_unbound_class_template (ctx, name, parm_list, complain);
10633 gcc_unreachable ();
10637 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
10638 tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl,
10639 /*integral_constant_expression_p=*/false);
10640 if (e1 == error_mark_node || e2 == error_mark_node)
10641 return error_mark_node;
10643 return build_nt (ARRAY_REF, e1, e2, NULL_TREE, NULL_TREE);
10648 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
10649 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
10650 if (e1 == error_mark_node || e2 == error_mark_node)
10651 return error_mark_node;
10653 return build_qualified_name (/*type=*/NULL_TREE,
10654 e1, e2, QUALIFIED_NAME_IS_TEMPLATE (t));
10661 ++cp_unevaluated_operand;
10662 ++c_inhibit_evaluation_warnings;
10664 type = tsubst_expr (TYPEOF_TYPE_EXPR (t), args,
10666 /*integral_constant_expression_p=*/false);
10668 --cp_unevaluated_operand;
10669 --c_inhibit_evaluation_warnings;
10671 type = finish_typeof (type);
10672 return cp_build_qualified_type_real (type,
10674 | cp_type_quals (type),
10678 case DECLTYPE_TYPE:
10682 ++cp_unevaluated_operand;
10683 ++c_inhibit_evaluation_warnings;
10685 type = tsubst_expr (DECLTYPE_TYPE_EXPR (t), args,
10687 /*integral_constant_expression_p=*/false);
10689 --cp_unevaluated_operand;
10690 --c_inhibit_evaluation_warnings;
10692 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t))
10693 type = lambda_capture_field_type (type);
10694 else if (DECLTYPE_FOR_LAMBDA_RETURN (t))
10695 type = lambda_return_type (type);
10697 type = finish_decltype_type
10698 (type, DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t));
10699 return cp_build_qualified_type_real (type,
10701 | cp_type_quals (type),
10705 case TYPE_ARGUMENT_PACK:
10706 case NONTYPE_ARGUMENT_PACK:
10708 tree r = TYPE_P (t) ? cxx_make_type (code) : make_node (code);
10710 tsubst_template_args (ARGUMENT_PACK_ARGS (t),
10714 SET_ARGUMENT_PACK_ARGS (r, packed_out);
10716 /* For template nontype argument packs, also substitute into
10718 if (code == NONTYPE_ARGUMENT_PACK)
10719 TREE_TYPE (r) = tsubst (TREE_TYPE (t), args, complain, in_decl);
10726 sorry ("use of %qs in template", tree_code_name [(int) code]);
10727 return error_mark_node;
10731 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
10732 type of the expression on the left-hand side of the "." or "->"
10736 tsubst_baselink (tree baselink, tree object_type,
10737 tree args, tsubst_flags_t complain, tree in_decl)
10740 tree qualifying_scope;
10743 tree template_args = 0;
10744 bool template_id_p = false;
10746 /* A baselink indicates a function from a base class. Both the
10747 BASELINK_ACCESS_BINFO and the base class referenced may
10748 indicate bases of the template class, rather than the
10749 instantiated class. In addition, lookups that were not
10750 ambiguous before may be ambiguous now. Therefore, we perform
10751 the lookup again. */
10752 qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink));
10753 qualifying_scope = tsubst (qualifying_scope, args,
10754 complain, in_decl);
10755 fns = BASELINK_FUNCTIONS (baselink);
10756 optype = tsubst (BASELINK_OPTYPE (baselink), args, complain, in_decl);
10757 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
10759 template_id_p = true;
10760 template_args = TREE_OPERAND (fns, 1);
10761 fns = TREE_OPERAND (fns, 0);
10763 template_args = tsubst_template_args (template_args, args,
10764 complain, in_decl);
10766 name = DECL_NAME (get_first_fn (fns));
10767 if (IDENTIFIER_TYPENAME_P (name))
10768 name = mangle_conv_op_name_for_type (optype);
10769 baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1);
10771 return error_mark_node;
10773 /* If lookup found a single function, mark it as used at this
10774 point. (If it lookup found multiple functions the one selected
10775 later by overload resolution will be marked as used at that
10777 if (BASELINK_P (baselink))
10778 fns = BASELINK_FUNCTIONS (baselink);
10779 if (!template_id_p && !really_overloaded_fn (fns))
10780 mark_used (OVL_CURRENT (fns));
10782 /* Add back the template arguments, if present. */
10783 if (BASELINK_P (baselink) && template_id_p)
10784 BASELINK_FUNCTIONS (baselink)
10785 = build_nt (TEMPLATE_ID_EXPR,
10786 BASELINK_FUNCTIONS (baselink),
10788 /* Update the conversion operator type. */
10789 BASELINK_OPTYPE (baselink) = optype;
10792 object_type = current_class_type;
10793 return adjust_result_of_qualified_name_lookup (baselink,
10798 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
10799 true if the qualified-id will be a postfix-expression in-and-of
10800 itself; false if more of the postfix-expression follows the
10801 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
10805 tsubst_qualified_id (tree qualified_id, tree args,
10806 tsubst_flags_t complain, tree in_decl,
10807 bool done, bool address_p)
10813 tree template_args;
10815 gcc_assert (TREE_CODE (qualified_id) == SCOPE_REF);
10817 /* Figure out what name to look up. */
10818 name = TREE_OPERAND (qualified_id, 1);
10819 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
10821 is_template = true;
10822 template_args = TREE_OPERAND (name, 1);
10824 template_args = tsubst_template_args (template_args, args,
10825 complain, in_decl);
10826 name = TREE_OPERAND (name, 0);
10830 is_template = false;
10831 template_args = NULL_TREE;
10834 /* Substitute into the qualifying scope. When there are no ARGS, we
10835 are just trying to simplify a non-dependent expression. In that
10836 case the qualifying scope may be dependent, and, in any case,
10837 substituting will not help. */
10838 scope = TREE_OPERAND (qualified_id, 0);
10841 scope = tsubst (scope, args, complain, in_decl);
10842 expr = tsubst_copy (name, args, complain, in_decl);
10847 if (dependent_scope_p (scope))
10848 return build_qualified_name (NULL_TREE, scope, expr,
10849 QUALIFIED_NAME_IS_TEMPLATE (qualified_id));
10851 if (!BASELINK_P (name) && !DECL_P (expr))
10853 if (TREE_CODE (expr) == BIT_NOT_EXPR)
10855 /* A BIT_NOT_EXPR is used to represent a destructor. */
10856 if (!check_dtor_name (scope, TREE_OPERAND (expr, 0)))
10858 error ("qualifying type %qT does not match destructor name ~%qT",
10859 scope, TREE_OPERAND (expr, 0));
10860 expr = error_mark_node;
10863 expr = lookup_qualified_name (scope, complete_dtor_identifier,
10864 /*is_type_p=*/0, false);
10867 expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0, false);
10868 if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL
10869 ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL)
10871 if (complain & tf_error)
10873 error ("dependent-name %qE is parsed as a non-type, but "
10874 "instantiation yields a type", qualified_id);
10875 inform (input_location, "say %<typename %E%> if a type is meant", qualified_id);
10877 return error_mark_node;
10883 check_accessibility_of_qualified_id (expr, /*object_type=*/NULL_TREE,
10885 /* Remember that there was a reference to this entity. */
10889 if (expr == error_mark_node || TREE_CODE (expr) == TREE_LIST)
10891 if (complain & tf_error)
10892 qualified_name_lookup_error (scope,
10893 TREE_OPERAND (qualified_id, 1),
10894 expr, input_location);
10895 return error_mark_node;
10899 expr = lookup_template_function (expr, template_args);
10901 if (expr == error_mark_node && complain & tf_error)
10902 qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1),
10903 expr, input_location);
10904 else if (TYPE_P (scope))
10906 expr = (adjust_result_of_qualified_name_lookup
10907 (expr, scope, current_class_type));
10908 expr = (finish_qualified_id_expr
10909 (scope, expr, done, address_p,
10910 QUALIFIED_NAME_IS_TEMPLATE (qualified_id),
10911 /*template_arg_p=*/false));
10914 /* Expressions do not generally have reference type. */
10915 if (TREE_CODE (expr) != SCOPE_REF
10916 /* However, if we're about to form a pointer-to-member, we just
10917 want the referenced member referenced. */
10918 && TREE_CODE (expr) != OFFSET_REF)
10919 expr = convert_from_reference (expr);
10924 /* Like tsubst, but deals with expressions. This function just replaces
10925 template parms; to finish processing the resultant expression, use
10929 tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
10931 enum tree_code code;
10934 if (t == NULL_TREE || t == error_mark_node || args == NULL_TREE)
10937 code = TREE_CODE (t);
10942 r = retrieve_local_specialization (t);
10947 /* This can happen for a parameter name used later in a function
10948 declaration (such as in a late-specified return type). Just
10949 make a dummy decl, since it's only used for its type. */
10950 gcc_assert (cp_unevaluated_operand != 0);
10951 /* We copy T because want to tsubst the PARM_DECL only,
10952 not the following PARM_DECLs that are chained to T. */
10954 r = tsubst_decl (c, args, complain);
10955 /* Give it the template pattern as its context; its true context
10956 hasn't been instantiated yet and this is good enough for
10958 DECL_CONTEXT (r) = DECL_CONTEXT (t);
10961 if (TREE_CODE (r) == ARGUMENT_PACK_SELECT)
10962 r = ARGUMENT_PACK_SELECT_ARG (r);
10971 if (DECL_TEMPLATE_PARM_P (t))
10972 return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
10973 /* There is no need to substitute into namespace-scope
10975 if (DECL_NAMESPACE_SCOPE_P (t))
10977 /* If ARGS is NULL, then T is known to be non-dependent. */
10978 if (args == NULL_TREE)
10979 return integral_constant_value (t);
10981 /* Unfortunately, we cannot just call lookup_name here.
10984 template <int I> int f() {
10986 struct S { void g() { E e = a; } };
10989 When we instantiate f<7>::S::g(), say, lookup_name is not
10990 clever enough to find f<7>::a. */
10992 = tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl,
10993 /*entering_scope=*/0);
10995 for (v = TYPE_VALUES (enum_type);
10997 v = TREE_CHAIN (v))
10998 if (TREE_PURPOSE (v) == DECL_NAME (t))
10999 return TREE_VALUE (v);
11001 /* We didn't find the name. That should never happen; if
11002 name-lookup found it during preliminary parsing, we
11003 should find it again here during instantiation. */
11004 gcc_unreachable ();
11009 if (DECL_CONTEXT (t))
11013 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
11014 /*entering_scope=*/1);
11015 if (ctx != DECL_CONTEXT (t))
11017 tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
11020 if (complain & tf_error)
11021 error ("using invalid field %qD", t);
11022 return error_mark_node;
11031 case FUNCTION_DECL:
11032 if ((DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
11033 || local_variable_p (t))
11034 t = tsubst (t, args, complain, in_decl);
11039 return tsubst_baselink (t, current_class_type, args, complain, in_decl);
11041 case TEMPLATE_DECL:
11042 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
11043 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
11044 args, complain, in_decl);
11045 else if (DECL_FUNCTION_TEMPLATE_P (t) && DECL_MEMBER_TEMPLATE_P (t))
11046 return tsubst (t, args, complain, in_decl);
11047 else if (DECL_CLASS_SCOPE_P (t)
11048 && uses_template_parms (DECL_CONTEXT (t)))
11050 /* Template template argument like the following example need
11053 template <template <class> class TT> struct C {};
11054 template <class T> struct D {
11055 template <class U> struct E {};
11060 We are processing the template argument `E' in #1 for
11061 the template instantiation #2. Originally, `E' is a
11062 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
11063 have to substitute this with one having context `D<int>'. */
11065 tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
11066 return lookup_field (context, DECL_NAME(t), 0, false);
11069 /* Ordinary template template argument. */
11073 case REINTERPRET_CAST_EXPR:
11074 case CONST_CAST_EXPR:
11075 case STATIC_CAST_EXPR:
11076 case DYNAMIC_CAST_EXPR:
11079 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
11080 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
11083 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
11085 /* We only want to compute the number of arguments. */
11086 tree expanded = tsubst_pack_expansion (TREE_OPERAND (t, 0), args,
11087 complain, in_decl);
11090 if (TREE_CODE (expanded) == TREE_VEC)
11091 len = TREE_VEC_LENGTH (expanded);
11093 if (expanded == error_mark_node)
11094 return error_mark_node;
11095 else if (PACK_EXPANSION_P (expanded)
11096 || (TREE_CODE (expanded) == TREE_VEC
11098 && PACK_EXPANSION_P (TREE_VEC_ELT (expanded, len-1))))
11100 if (TREE_CODE (expanded) == TREE_VEC)
11101 expanded = TREE_VEC_ELT (expanded, len - 1);
11103 if (TYPE_P (expanded))
11104 return cxx_sizeof_or_alignof_type (expanded, SIZEOF_EXPR,
11105 complain & tf_error);
11107 return cxx_sizeof_or_alignof_expr (expanded, SIZEOF_EXPR,
11108 complain & tf_error);
11111 return build_int_cst (size_type_node, len);
11117 case TRUTH_NOT_EXPR:
11120 case UNARY_PLUS_EXPR: /* Unary + */
11125 case REALPART_EXPR:
11126 case IMAGPART_EXPR:
11128 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
11129 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
11131 case COMPONENT_REF:
11136 object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
11137 name = TREE_OPERAND (t, 1);
11138 if (TREE_CODE (name) == BIT_NOT_EXPR)
11140 name = tsubst_copy (TREE_OPERAND (name, 0), args,
11141 complain, in_decl);
11142 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
11144 else if (TREE_CODE (name) == SCOPE_REF
11145 && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
11147 tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
11148 complain, in_decl);
11149 name = TREE_OPERAND (name, 1);
11150 name = tsubst_copy (TREE_OPERAND (name, 0), args,
11151 complain, in_decl);
11152 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
11153 name = build_qualified_name (/*type=*/NULL_TREE,
11155 /*template_p=*/false);
11157 else if (TREE_CODE (name) == BASELINK)
11158 name = tsubst_baselink (name,
11159 non_reference (TREE_TYPE (object)),
11163 name = tsubst_copy (name, args, complain, in_decl);
11164 return build_nt (COMPONENT_REF, object, name, NULL_TREE);
11170 case TRUNC_DIV_EXPR:
11171 case CEIL_DIV_EXPR:
11172 case FLOOR_DIV_EXPR:
11173 case ROUND_DIV_EXPR:
11174 case EXACT_DIV_EXPR:
11178 case TRUNC_MOD_EXPR:
11179 case FLOOR_MOD_EXPR:
11180 case TRUTH_ANDIF_EXPR:
11181 case TRUTH_ORIF_EXPR:
11182 case TRUTH_AND_EXPR:
11183 case TRUTH_OR_EXPR:
11196 case COMPOUND_EXPR:
11199 case PREDECREMENT_EXPR:
11200 case PREINCREMENT_EXPR:
11201 case POSTDECREMENT_EXPR:
11202 case POSTINCREMENT_EXPR:
11204 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
11205 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
11208 return build_qualified_name (/*type=*/NULL_TREE,
11209 tsubst_copy (TREE_OPERAND (t, 0),
11210 args, complain, in_decl),
11211 tsubst_copy (TREE_OPERAND (t, 1),
11212 args, complain, in_decl),
11213 QUALIFIED_NAME_IS_TEMPLATE (t));
11218 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
11219 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
11220 NULL_TREE, NULL_TREE);
11224 int n = VL_EXP_OPERAND_LENGTH (t);
11225 tree result = build_vl_exp (CALL_EXPR, n);
11227 for (i = 0; i < n; i++)
11228 TREE_OPERAND (t, i) = tsubst_copy (TREE_OPERAND (t, i), args,
11229 complain, in_decl);
11235 case PSEUDO_DTOR_EXPR:
11238 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
11239 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
11240 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
11241 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
11248 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
11249 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
11250 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
11251 NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
11258 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
11259 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
11260 DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
11261 DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
11265 case TEMPLATE_ID_EXPR:
11267 /* Substituted template arguments */
11268 tree fn = TREE_OPERAND (t, 0);
11269 tree targs = TREE_OPERAND (t, 1);
11271 fn = tsubst_copy (fn, args, complain, in_decl);
11273 targs = tsubst_template_args (targs, args, complain, in_decl);
11275 return lookup_template_function (fn, targs);
11280 tree purpose, value, chain;
11282 if (t == void_list_node)
11285 purpose = TREE_PURPOSE (t);
11287 purpose = tsubst_copy (purpose, args, complain, in_decl);
11288 value = TREE_VALUE (t);
11290 value = tsubst_copy (value, args, complain, in_decl);
11291 chain = TREE_CHAIN (t);
11292 if (chain && chain != void_type_node)
11293 chain = tsubst_copy (chain, args, complain, in_decl);
11294 if (purpose == TREE_PURPOSE (t)
11295 && value == TREE_VALUE (t)
11296 && chain == TREE_CHAIN (t))
11298 return tree_cons (purpose, value, chain);
11303 case ENUMERAL_TYPE:
11305 case TEMPLATE_TYPE_PARM:
11306 case TEMPLATE_TEMPLATE_PARM:
11307 case BOUND_TEMPLATE_TEMPLATE_PARM:
11308 case TEMPLATE_PARM_INDEX:
11310 case REFERENCE_TYPE:
11312 case FUNCTION_TYPE:
11315 case TYPENAME_TYPE:
11316 case UNBOUND_CLASS_TEMPLATE:
11318 case DECLTYPE_TYPE:
11320 return tsubst (t, args, complain, in_decl);
11322 case IDENTIFIER_NODE:
11323 if (IDENTIFIER_TYPENAME_P (t))
11325 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
11326 return mangle_conv_op_name_for_type (new_type);
11332 /* This is handled by tsubst_copy_and_build. */
11333 gcc_unreachable ();
11336 return build_x_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain,
11338 tsubst (TREE_TYPE (t), args, complain, in_decl));
11340 case CLEANUP_POINT_EXPR:
11341 /* We shouldn't have built any of these during initial template
11342 generation. Instead, they should be built during instantiation
11343 in response to the saved STMT_IS_FULL_EXPR_P setting. */
11344 gcc_unreachable ();
11348 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
11349 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
11350 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
11351 PTRMEM_OK_P (r) = PTRMEM_OK_P (t);
11352 mark_used (TREE_OPERAND (r, 1));
11355 case EXPR_PACK_EXPANSION:
11356 error ("invalid use of pack expansion expression");
11357 return error_mark_node;
11359 case NONTYPE_ARGUMENT_PACK:
11360 error ("use %<...%> to expand argument pack");
11361 return error_mark_node;
11368 /* Like tsubst_copy, but specifically for OpenMP clauses. */
11371 tsubst_omp_clauses (tree clauses, tree args, tsubst_flags_t complain,
11374 tree new_clauses = NULL, nc, oc;
11376 for (oc = clauses; oc ; oc = OMP_CLAUSE_CHAIN (oc))
11378 nc = copy_node (oc);
11379 OMP_CLAUSE_CHAIN (nc) = new_clauses;
11382 switch (OMP_CLAUSE_CODE (nc))
11384 case OMP_CLAUSE_LASTPRIVATE:
11385 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc))
11387 OMP_CLAUSE_LASTPRIVATE_STMT (nc) = push_stmt_list ();
11388 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc), args, complain,
11389 in_decl, /*integral_constant_expression_p=*/false);
11390 OMP_CLAUSE_LASTPRIVATE_STMT (nc)
11391 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc));
11394 case OMP_CLAUSE_PRIVATE:
11395 case OMP_CLAUSE_SHARED:
11396 case OMP_CLAUSE_FIRSTPRIVATE:
11397 case OMP_CLAUSE_REDUCTION:
11398 case OMP_CLAUSE_COPYIN:
11399 case OMP_CLAUSE_COPYPRIVATE:
11400 case OMP_CLAUSE_IF:
11401 case OMP_CLAUSE_NUM_THREADS:
11402 case OMP_CLAUSE_SCHEDULE:
11403 case OMP_CLAUSE_COLLAPSE:
11404 OMP_CLAUSE_OPERAND (nc, 0)
11405 = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 0), args, complain,
11406 in_decl, /*integral_constant_expression_p=*/false);
11408 case OMP_CLAUSE_NOWAIT:
11409 case OMP_CLAUSE_ORDERED:
11410 case OMP_CLAUSE_DEFAULT:
11411 case OMP_CLAUSE_UNTIED:
11414 gcc_unreachable ();
11418 return finish_omp_clauses (nreverse (new_clauses));
11421 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
11424 tsubst_copy_asm_operands (tree t, tree args, tsubst_flags_t complain,
11427 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
11429 tree purpose, value, chain;
11434 if (TREE_CODE (t) != TREE_LIST)
11435 return tsubst_copy_and_build (t, args, complain, in_decl,
11436 /*function_p=*/false,
11437 /*integral_constant_expression_p=*/false);
11439 if (t == void_list_node)
11442 purpose = TREE_PURPOSE (t);
11444 purpose = RECUR (purpose);
11445 value = TREE_VALUE (t);
11446 if (value && TREE_CODE (value) != LABEL_DECL)
11447 value = RECUR (value);
11448 chain = TREE_CHAIN (t);
11449 if (chain && chain != void_type_node)
11450 chain = RECUR (chain);
11451 return tree_cons (purpose, value, chain);
11455 /* Substitute one OMP_FOR iterator. */
11458 tsubst_omp_for_iterator (tree t, int i, tree declv, tree initv,
11459 tree condv, tree incrv, tree *clauses,
11460 tree args, tsubst_flags_t complain, tree in_decl,
11461 bool integral_constant_expression_p)
11463 #define RECUR(NODE) \
11464 tsubst_expr ((NODE), args, complain, in_decl, \
11465 integral_constant_expression_p)
11466 tree decl, init, cond, incr, auto_node;
11468 init = TREE_VEC_ELT (OMP_FOR_INIT (t), i);
11469 gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
11470 decl = RECUR (TREE_OPERAND (init, 0));
11471 init = TREE_OPERAND (init, 1);
11472 auto_node = type_uses_auto (TREE_TYPE (decl));
11473 if (auto_node && init)
11475 tree init_expr = init;
11476 if (TREE_CODE (init_expr) == DECL_EXPR)
11477 init_expr = DECL_INITIAL (DECL_EXPR_DECL (init_expr));
11478 init_expr = RECUR (init_expr);
11480 = do_auto_deduction (TREE_TYPE (decl), init_expr, auto_node);
11482 gcc_assert (!type_dependent_expression_p (decl));
11484 if (!CLASS_TYPE_P (TREE_TYPE (decl)))
11486 cond = RECUR (TREE_VEC_ELT (OMP_FOR_COND (t), i));
11487 incr = TREE_VEC_ELT (OMP_FOR_INCR (t), i);
11488 if (TREE_CODE (incr) == MODIFY_EXPR)
11489 incr = build_x_modify_expr (RECUR (TREE_OPERAND (incr, 0)), NOP_EXPR,
11490 RECUR (TREE_OPERAND (incr, 1)),
11493 incr = RECUR (incr);
11494 TREE_VEC_ELT (declv, i) = decl;
11495 TREE_VEC_ELT (initv, i) = init;
11496 TREE_VEC_ELT (condv, i) = cond;
11497 TREE_VEC_ELT (incrv, i) = incr;
11501 if (init && TREE_CODE (init) != DECL_EXPR)
11504 for (c = *clauses; c ; c = OMP_CLAUSE_CHAIN (c))
11506 if ((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_PRIVATE
11507 || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE)
11508 && OMP_CLAUSE_DECL (c) == decl)
11510 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
11511 && OMP_CLAUSE_DECL (c) == decl)
11512 error ("iteration variable %qD should not be firstprivate", decl);
11513 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
11514 && OMP_CLAUSE_DECL (c) == decl)
11515 error ("iteration variable %qD should not be reduction", decl);
11519 c = build_omp_clause (input_location, OMP_CLAUSE_PRIVATE);
11520 OMP_CLAUSE_DECL (c) = decl;
11521 c = finish_omp_clauses (c);
11524 OMP_CLAUSE_CHAIN (c) = *clauses;
11529 cond = TREE_VEC_ELT (OMP_FOR_COND (t), i);
11530 if (COMPARISON_CLASS_P (cond))
11531 cond = build2 (TREE_CODE (cond), boolean_type_node,
11532 RECUR (TREE_OPERAND (cond, 0)),
11533 RECUR (TREE_OPERAND (cond, 1)));
11535 cond = RECUR (cond);
11536 incr = TREE_VEC_ELT (OMP_FOR_INCR (t), i);
11537 switch (TREE_CODE (incr))
11539 case PREINCREMENT_EXPR:
11540 case PREDECREMENT_EXPR:
11541 case POSTINCREMENT_EXPR:
11542 case POSTDECREMENT_EXPR:
11543 incr = build2 (TREE_CODE (incr), TREE_TYPE (decl),
11544 RECUR (TREE_OPERAND (incr, 0)), NULL_TREE);
11547 if (TREE_CODE (TREE_OPERAND (incr, 1)) == PLUS_EXPR
11548 || TREE_CODE (TREE_OPERAND (incr, 1)) == MINUS_EXPR)
11550 tree rhs = TREE_OPERAND (incr, 1);
11551 incr = build2 (MODIFY_EXPR, TREE_TYPE (decl),
11552 RECUR (TREE_OPERAND (incr, 0)),
11553 build2 (TREE_CODE (rhs), TREE_TYPE (decl),
11554 RECUR (TREE_OPERAND (rhs, 0)),
11555 RECUR (TREE_OPERAND (rhs, 1))));
11558 incr = RECUR (incr);
11561 if (TREE_CODE (TREE_OPERAND (incr, 1)) == PLUS_EXPR
11562 || TREE_CODE (TREE_OPERAND (incr, 1)) == MINUS_EXPR)
11564 tree lhs = RECUR (TREE_OPERAND (incr, 0));
11565 incr = build2 (MODIFY_EXPR, TREE_TYPE (decl), lhs,
11566 build2 (TREE_CODE (TREE_OPERAND (incr, 1)),
11567 TREE_TYPE (decl), lhs,
11568 RECUR (TREE_OPERAND (incr, 2))));
11570 else if (TREE_CODE (TREE_OPERAND (incr, 1)) == NOP_EXPR
11571 && (TREE_CODE (TREE_OPERAND (incr, 2)) == PLUS_EXPR
11572 || (TREE_CODE (TREE_OPERAND (incr, 2)) == MINUS_EXPR)))
11574 tree rhs = TREE_OPERAND (incr, 2);
11575 incr = build2 (MODIFY_EXPR, TREE_TYPE (decl),
11576 RECUR (TREE_OPERAND (incr, 0)),
11577 build2 (TREE_CODE (rhs), TREE_TYPE (decl),
11578 RECUR (TREE_OPERAND (rhs, 0)),
11579 RECUR (TREE_OPERAND (rhs, 1))));
11582 incr = RECUR (incr);
11585 incr = RECUR (incr);
11589 TREE_VEC_ELT (declv, i) = decl;
11590 TREE_VEC_ELT (initv, i) = init;
11591 TREE_VEC_ELT (condv, i) = cond;
11592 TREE_VEC_ELT (incrv, i) = incr;
11596 /* Like tsubst_copy for expressions, etc. but also does semantic
11600 tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl,
11601 bool integral_constant_expression_p)
11603 #define RECUR(NODE) \
11604 tsubst_expr ((NODE), args, complain, in_decl, \
11605 integral_constant_expression_p)
11609 if (t == NULL_TREE || t == error_mark_node)
11612 if (EXPR_HAS_LOCATION (t))
11613 input_location = EXPR_LOCATION (t);
11614 if (STATEMENT_CODE_P (TREE_CODE (t)))
11615 current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
11617 switch (TREE_CODE (t))
11619 case STATEMENT_LIST:
11621 tree_stmt_iterator i;
11622 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
11623 RECUR (tsi_stmt (i));
11627 case CTOR_INITIALIZER:
11628 finish_mem_initializers (tsubst_initializer_list
11629 (TREE_OPERAND (t, 0), args));
11633 finish_return_stmt (RECUR (TREE_OPERAND (t, 0)));
11637 tmp = RECUR (EXPR_STMT_EXPR (t));
11638 if (EXPR_STMT_STMT_EXPR_RESULT (t))
11639 finish_stmt_expr_expr (tmp, cur_stmt_expr);
11641 finish_expr_stmt (tmp);
11645 do_using_directive (RECUR (USING_STMT_NAMESPACE (t)));
11653 decl = DECL_EXPR_DECL (t);
11654 if (TREE_CODE (decl) == LABEL_DECL)
11655 finish_label_decl (DECL_NAME (decl));
11656 else if (TREE_CODE (decl) == USING_DECL)
11658 tree scope = USING_DECL_SCOPE (decl);
11659 tree name = DECL_NAME (decl);
11662 scope = RECUR (scope);
11663 decl = lookup_qualified_name (scope, name,
11664 /*is_type_p=*/false,
11665 /*complain=*/false);
11666 if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
11667 qualified_name_lookup_error (scope, name, decl, input_location);
11669 do_local_using_decl (decl, scope, name);
11673 init = DECL_INITIAL (decl);
11674 decl = tsubst (decl, args, complain, in_decl);
11675 if (decl != error_mark_node)
11677 /* By marking the declaration as instantiated, we avoid
11678 trying to instantiate it. Since instantiate_decl can't
11679 handle local variables, and since we've already done
11680 all that needs to be done, that's the right thing to
11682 if (TREE_CODE (decl) == VAR_DECL)
11683 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
11684 if (TREE_CODE (decl) == VAR_DECL
11685 && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
11686 /* Anonymous aggregates are a special case. */
11687 finish_anon_union (decl);
11690 maybe_push_decl (decl);
11691 if (TREE_CODE (decl) == VAR_DECL
11692 && DECL_PRETTY_FUNCTION_P (decl))
11694 /* For __PRETTY_FUNCTION__ we have to adjust the
11696 const char *const name
11697 = cxx_printable_name (current_function_decl, 2);
11698 init = cp_fname_init (name, &TREE_TYPE (decl));
11702 tree t = RECUR (init);
11706 /* If we had an initializer but it
11707 instantiated to nothing,
11708 value-initialize the object. This will
11709 only occur when the initializer was a
11710 pack expansion where the parameter packs
11711 used in that expansion were of length
11713 init = build_value_init (TREE_TYPE (decl),
11715 if (TREE_CODE (init) == AGGR_INIT_EXPR)
11716 init = get_target_expr (init);
11722 cp_finish_decl (decl, init, false, NULL_TREE, 0);
11727 /* A DECL_EXPR can also be used as an expression, in the condition
11728 clause of an if/for/while construct. */
11733 stmt = begin_for_stmt ();
11734 RECUR (FOR_INIT_STMT (t));
11735 finish_for_init_stmt (stmt);
11736 tmp = RECUR (FOR_COND (t));
11737 finish_for_cond (tmp, stmt);
11738 tmp = RECUR (FOR_EXPR (t));
11739 finish_for_expr (tmp, stmt);
11740 RECUR (FOR_BODY (t));
11741 finish_for_stmt (stmt);
11745 stmt = begin_while_stmt ();
11746 tmp = RECUR (WHILE_COND (t));
11747 finish_while_stmt_cond (tmp, stmt);
11748 RECUR (WHILE_BODY (t));
11749 finish_while_stmt (stmt);
11753 stmt = begin_do_stmt ();
11754 RECUR (DO_BODY (t));
11755 finish_do_body (stmt);
11756 tmp = RECUR (DO_COND (t));
11757 finish_do_stmt (tmp, stmt);
11761 stmt = begin_if_stmt ();
11762 tmp = RECUR (IF_COND (t));
11763 finish_if_stmt_cond (tmp, stmt);
11764 RECUR (THEN_CLAUSE (t));
11765 finish_then_clause (stmt);
11767 if (ELSE_CLAUSE (t))
11769 begin_else_clause (stmt);
11770 RECUR (ELSE_CLAUSE (t));
11771 finish_else_clause (stmt);
11774 finish_if_stmt (stmt);
11778 if (BIND_EXPR_BODY_BLOCK (t))
11779 stmt = begin_function_body ();
11781 stmt = begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t)
11782 ? BCS_TRY_BLOCK : 0);
11784 RECUR (BIND_EXPR_BODY (t));
11786 if (BIND_EXPR_BODY_BLOCK (t))
11787 finish_function_body (stmt);
11789 finish_compound_stmt (stmt);
11793 finish_break_stmt ();
11796 case CONTINUE_STMT:
11797 finish_continue_stmt ();
11801 stmt = begin_switch_stmt ();
11802 tmp = RECUR (SWITCH_STMT_COND (t));
11803 finish_switch_cond (tmp, stmt);
11804 RECUR (SWITCH_STMT_BODY (t));
11805 finish_switch_stmt (stmt);
11808 case CASE_LABEL_EXPR:
11809 finish_case_label (EXPR_LOCATION (t),
11810 RECUR (CASE_LOW (t)),
11811 RECUR (CASE_HIGH (t)));
11816 tree decl = LABEL_EXPR_LABEL (t);
11819 label = finish_label_stmt (DECL_NAME (decl));
11820 if (DECL_ATTRIBUTES (decl) != NULL_TREE)
11821 cplus_decl_attributes (&label, DECL_ATTRIBUTES (decl), 0);
11826 tmp = GOTO_DESTINATION (t);
11827 if (TREE_CODE (tmp) != LABEL_DECL)
11828 /* Computed goto's must be tsubst'd into. On the other hand,
11829 non-computed gotos must not be; the identifier in question
11830 will have no binding. */
11833 tmp = DECL_NAME (tmp);
11834 finish_goto_stmt (tmp);
11838 tmp = finish_asm_stmt
11839 (ASM_VOLATILE_P (t),
11840 RECUR (ASM_STRING (t)),
11841 tsubst_copy_asm_operands (ASM_OUTPUTS (t), args, complain, in_decl),
11842 tsubst_copy_asm_operands (ASM_INPUTS (t), args, complain, in_decl),
11843 tsubst_copy_asm_operands (ASM_CLOBBERS (t), args, complain, in_decl),
11844 tsubst_copy_asm_operands (ASM_LABELS (t), args, complain, in_decl));
11846 tree asm_expr = tmp;
11847 if (TREE_CODE (asm_expr) == CLEANUP_POINT_EXPR)
11848 asm_expr = TREE_OPERAND (asm_expr, 0);
11849 ASM_INPUT_P (asm_expr) = ASM_INPUT_P (t);
11856 stmt = begin_try_block ();
11857 RECUR (TRY_STMTS (t));
11858 finish_cleanup_try_block (stmt);
11859 finish_cleanup (RECUR (TRY_HANDLERS (t)), stmt);
11863 tree compound_stmt = NULL_TREE;
11865 if (FN_TRY_BLOCK_P (t))
11866 stmt = begin_function_try_block (&compound_stmt);
11868 stmt = begin_try_block ();
11870 RECUR (TRY_STMTS (t));
11872 if (FN_TRY_BLOCK_P (t))
11873 finish_function_try_block (stmt);
11875 finish_try_block (stmt);
11877 RECUR (TRY_HANDLERS (t));
11878 if (FN_TRY_BLOCK_P (t))
11879 finish_function_handler_sequence (stmt, compound_stmt);
11881 finish_handler_sequence (stmt);
11887 tree decl = HANDLER_PARMS (t);
11891 decl = tsubst (decl, args, complain, in_decl);
11892 /* Prevent instantiate_decl from trying to instantiate
11893 this variable. We've already done all that needs to be
11895 if (decl != error_mark_node)
11896 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
11898 stmt = begin_handler ();
11899 finish_handler_parms (decl, stmt);
11900 RECUR (HANDLER_BODY (t));
11901 finish_handler (stmt);
11906 tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
11909 case STATIC_ASSERT:
11912 tsubst_expr (STATIC_ASSERT_CONDITION (t),
11915 /*integral_constant_expression_p=*/true);
11916 finish_static_assert (condition,
11917 STATIC_ASSERT_MESSAGE (t),
11918 STATIC_ASSERT_SOURCE_LOCATION (t),
11919 /*member_p=*/false);
11924 tmp = tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t),
11925 args, complain, in_decl);
11926 stmt = begin_omp_parallel ();
11927 RECUR (OMP_PARALLEL_BODY (t));
11928 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp, stmt))
11929 = OMP_PARALLEL_COMBINED (t);
11933 tmp = tsubst_omp_clauses (OMP_TASK_CLAUSES (t),
11934 args, complain, in_decl);
11935 stmt = begin_omp_task ();
11936 RECUR (OMP_TASK_BODY (t));
11937 finish_omp_task (tmp, stmt);
11942 tree clauses, body, pre_body;
11943 tree declv, initv, condv, incrv;
11946 clauses = tsubst_omp_clauses (OMP_FOR_CLAUSES (t),
11947 args, complain, in_decl);
11948 declv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
11949 initv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
11950 condv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
11951 incrv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
11953 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (t)); i++)
11954 tsubst_omp_for_iterator (t, i, declv, initv, condv, incrv,
11955 &clauses, args, complain, in_decl,
11956 integral_constant_expression_p);
11958 stmt = begin_omp_structured_block ();
11960 for (i = 0; i < TREE_VEC_LENGTH (initv); i++)
11961 if (TREE_VEC_ELT (initv, i) == NULL
11962 || TREE_CODE (TREE_VEC_ELT (initv, i)) != DECL_EXPR)
11963 TREE_VEC_ELT (initv, i) = RECUR (TREE_VEC_ELT (initv, i));
11964 else if (CLASS_TYPE_P (TREE_TYPE (TREE_VEC_ELT (initv, i))))
11966 tree init = RECUR (TREE_VEC_ELT (initv, i));
11967 gcc_assert (init == TREE_VEC_ELT (declv, i));
11968 TREE_VEC_ELT (initv, i) = NULL_TREE;
11972 tree decl_expr = TREE_VEC_ELT (initv, i);
11973 tree init = DECL_INITIAL (DECL_EXPR_DECL (decl_expr));
11974 gcc_assert (init != NULL);
11975 TREE_VEC_ELT (initv, i) = RECUR (init);
11976 DECL_INITIAL (DECL_EXPR_DECL (decl_expr)) = NULL;
11978 DECL_INITIAL (DECL_EXPR_DECL (decl_expr)) = init;
11981 pre_body = push_stmt_list ();
11982 RECUR (OMP_FOR_PRE_BODY (t));
11983 pre_body = pop_stmt_list (pre_body);
11985 body = push_stmt_list ();
11986 RECUR (OMP_FOR_BODY (t));
11987 body = pop_stmt_list (body);
11989 t = finish_omp_for (EXPR_LOCATION (t), declv, initv, condv, incrv,
11990 body, pre_body, clauses);
11992 add_stmt (finish_omp_structured_block (stmt));
11998 tmp = tsubst_omp_clauses (OMP_CLAUSES (t), args, complain, in_decl);
11999 stmt = push_stmt_list ();
12000 RECUR (OMP_BODY (t));
12001 stmt = pop_stmt_list (stmt);
12004 OMP_BODY (t) = stmt;
12005 OMP_CLAUSES (t) = tmp;
12013 stmt = push_stmt_list ();
12014 RECUR (OMP_BODY (t));
12015 stmt = pop_stmt_list (stmt);
12018 OMP_BODY (t) = stmt;
12023 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t));
12025 tree op1 = TREE_OPERAND (t, 1);
12026 tree lhs = RECUR (TREE_OPERAND (op1, 0));
12027 tree rhs = RECUR (TREE_OPERAND (op1, 1));
12028 finish_omp_atomic (TREE_CODE (op1), lhs, rhs);
12032 case EXPR_PACK_EXPANSION:
12033 error ("invalid use of pack expansion expression");
12034 return error_mark_node;
12036 case NONTYPE_ARGUMENT_PACK:
12037 error ("use %<...%> to expand argument pack");
12038 return error_mark_node;
12041 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t)));
12043 return tsubst_copy_and_build (t, args, complain, in_decl,
12044 /*function_p=*/false,
12045 integral_constant_expression_p);
12052 /* T is a postfix-expression that is not being used in a function
12053 call. Return the substituted version of T. */
12056 tsubst_non_call_postfix_expression (tree t, tree args,
12057 tsubst_flags_t complain,
12060 if (TREE_CODE (t) == SCOPE_REF)
12061 t = tsubst_qualified_id (t, args, complain, in_decl,
12062 /*done=*/false, /*address_p=*/false);
12064 t = tsubst_copy_and_build (t, args, complain, in_decl,
12065 /*function_p=*/false,
12066 /*integral_constant_expression_p=*/false);
12071 /* Like tsubst but deals with expressions and performs semantic
12072 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
12075 tsubst_copy_and_build (tree t,
12077 tsubst_flags_t complain,
12080 bool integral_constant_expression_p)
12082 #define RECUR(NODE) \
12083 tsubst_copy_and_build (NODE, args, complain, in_decl, \
12084 /*function_p=*/false, \
12085 integral_constant_expression_p)
12089 if (t == NULL_TREE || t == error_mark_node)
12092 switch (TREE_CODE (t))
12096 /* Fall through. */
12097 case IDENTIFIER_NODE:
12101 bool non_integral_constant_expression_p;
12102 const char *error_msg;
12104 if (IDENTIFIER_TYPENAME_P (t))
12106 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
12107 t = mangle_conv_op_name_for_type (new_type);
12110 /* Look up the name. */
12111 decl = lookup_name (t);
12113 /* By convention, expressions use ERROR_MARK_NODE to indicate
12114 failure, not NULL_TREE. */
12115 if (decl == NULL_TREE)
12116 decl = error_mark_node;
12118 decl = finish_id_expression (t, decl, NULL_TREE,
12120 integral_constant_expression_p,
12121 /*allow_non_integral_constant_expression_p=*/false,
12122 &non_integral_constant_expression_p,
12123 /*template_p=*/false,
12125 /*address_p=*/false,
12126 /*template_arg_p=*/false,
12131 if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE)
12132 decl = unqualified_name_lookup_error (decl);
12136 case TEMPLATE_ID_EXPR:
12139 tree templ = RECUR (TREE_OPERAND (t, 0));
12140 tree targs = TREE_OPERAND (t, 1);
12143 targs = tsubst_template_args (targs, args, complain, in_decl);
12145 if (TREE_CODE (templ) == COMPONENT_REF)
12147 object = TREE_OPERAND (templ, 0);
12148 templ = TREE_OPERAND (templ, 1);
12151 object = NULL_TREE;
12152 templ = lookup_template_function (templ, targs);
12155 return build3 (COMPONENT_REF, TREE_TYPE (templ),
12156 object, templ, NULL_TREE);
12158 return baselink_for_fns (templ);
12163 tree r = RECUR (TREE_OPERAND (t, 0));
12165 if (REFERENCE_REF_P (t))
12167 /* A type conversion to reference type will be enclosed in
12168 such an indirect ref, but the substitution of the cast
12169 will have also added such an indirect ref. */
12170 if (TREE_CODE (TREE_TYPE (r)) == REFERENCE_TYPE)
12171 r = convert_from_reference (r);
12174 r = build_x_indirect_ref (r, RO_UNARY_STAR, complain);
12180 (tsubst (TREE_TYPE (t), args, complain, in_decl),
12181 RECUR (TREE_OPERAND (t, 0)));
12184 case REINTERPRET_CAST_EXPR:
12185 case CONST_CAST_EXPR:
12186 case DYNAMIC_CAST_EXPR:
12187 case STATIC_CAST_EXPR:
12192 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
12193 if (integral_constant_expression_p
12194 && !cast_valid_in_integral_constant_expression_p (type))
12196 if (complain & tf_error)
12197 error ("a cast to a type other than an integral or "
12198 "enumeration type cannot appear in a constant-expression");
12199 return error_mark_node;
12202 op = RECUR (TREE_OPERAND (t, 0));
12204 switch (TREE_CODE (t))
12207 return build_functional_cast (type, op, complain);
12208 case REINTERPRET_CAST_EXPR:
12209 return build_reinterpret_cast (type, op, complain);
12210 case CONST_CAST_EXPR:
12211 return build_const_cast (type, op, complain);
12212 case DYNAMIC_CAST_EXPR:
12213 return build_dynamic_cast (type, op, complain);
12214 case STATIC_CAST_EXPR:
12215 return build_static_cast (type, op, complain);
12217 gcc_unreachable ();
12221 case POSTDECREMENT_EXPR:
12222 case POSTINCREMENT_EXPR:
12223 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
12224 args, complain, in_decl);
12225 return build_x_unary_op (TREE_CODE (t), op1, complain);
12227 case PREDECREMENT_EXPR:
12228 case PREINCREMENT_EXPR:
12232 case TRUTH_NOT_EXPR:
12233 case UNARY_PLUS_EXPR: /* Unary + */
12234 case REALPART_EXPR:
12235 case IMAGPART_EXPR:
12236 return build_x_unary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0)),
12240 op1 = TREE_OPERAND (t, 0);
12241 if (TREE_CODE (op1) == SCOPE_REF)
12242 op1 = tsubst_qualified_id (op1, args, complain, in_decl,
12243 /*done=*/true, /*address_p=*/true);
12245 op1 = tsubst_non_call_postfix_expression (op1, args, complain,
12247 if (TREE_CODE (op1) == LABEL_DECL)
12248 return finish_label_address_expr (DECL_NAME (op1),
12249 EXPR_LOCATION (op1));
12250 return build_x_unary_op (ADDR_EXPR, op1, complain);
12255 case TRUNC_DIV_EXPR:
12256 case CEIL_DIV_EXPR:
12257 case FLOOR_DIV_EXPR:
12258 case ROUND_DIV_EXPR:
12259 case EXACT_DIV_EXPR:
12263 case TRUNC_MOD_EXPR:
12264 case FLOOR_MOD_EXPR:
12265 case TRUTH_ANDIF_EXPR:
12266 case TRUTH_ORIF_EXPR:
12267 case TRUTH_AND_EXPR:
12268 case TRUTH_OR_EXPR:
12283 return build_x_binary_op
12285 RECUR (TREE_OPERAND (t, 0)),
12286 (TREE_NO_WARNING (TREE_OPERAND (t, 0))
12288 : TREE_CODE (TREE_OPERAND (t, 0))),
12289 RECUR (TREE_OPERAND (t, 1)),
12290 (TREE_NO_WARNING (TREE_OPERAND (t, 1))
12292 : TREE_CODE (TREE_OPERAND (t, 1))),
12293 /*overloaded_p=*/NULL,
12297 return tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
12298 /*address_p=*/false);
12300 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
12301 args, complain, in_decl);
12302 return build_x_array_ref (op1, RECUR (TREE_OPERAND (t, 1)), complain);
12305 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
12306 return tsubst_copy (t, args, complain, in_decl);
12310 op1 = TREE_OPERAND (t, 0);
12313 /* When there are no ARGS, we are trying to evaluate a
12314 non-dependent expression from the parser. Trying to do
12315 the substitutions may not work. */
12317 op1 = TREE_TYPE (op1);
12321 ++cp_unevaluated_operand;
12322 ++c_inhibit_evaluation_warnings;
12323 op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
12324 /*function_p=*/false,
12325 /*integral_constant_expression_p=*/false);
12326 --cp_unevaluated_operand;
12327 --c_inhibit_evaluation_warnings;
12330 return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t),
12331 complain & tf_error);
12333 return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t),
12334 complain & tf_error);
12336 case NOEXCEPT_EXPR:
12337 op1 = TREE_OPERAND (t, 0);
12338 ++cp_unevaluated_operand;
12339 ++c_inhibit_evaluation_warnings;
12340 op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
12341 /*function_p=*/false,
12342 /*integral_constant_expression_p=*/false);
12343 --cp_unevaluated_operand;
12344 --c_inhibit_evaluation_warnings;
12345 return finish_noexcept_expr (op1, complain);
12349 tree r = build_x_modify_expr
12350 (RECUR (TREE_OPERAND (t, 0)),
12351 TREE_CODE (TREE_OPERAND (t, 1)),
12352 RECUR (TREE_OPERAND (t, 2)),
12354 /* TREE_NO_WARNING must be set if either the expression was
12355 parenthesized or it uses an operator such as >>= rather
12356 than plain assignment. In the former case, it was already
12357 set and must be copied. In the latter case,
12358 build_x_modify_expr sets it and it must not be reset
12360 if (TREE_NO_WARNING (t))
12361 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
12366 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
12367 args, complain, in_decl);
12368 /* Remember that there was a reference to this entity. */
12371 return build_x_arrow (op1);
12375 tree placement = RECUR (TREE_OPERAND (t, 0));
12376 tree init = RECUR (TREE_OPERAND (t, 3));
12377 VEC(tree,gc) *placement_vec;
12378 VEC(tree,gc) *init_vec;
12381 if (placement == NULL_TREE)
12382 placement_vec = NULL;
12385 placement_vec = make_tree_vector ();
12386 for (; placement != NULL_TREE; placement = TREE_CHAIN (placement))
12387 VEC_safe_push (tree, gc, placement_vec, TREE_VALUE (placement));
12390 /* If there was an initializer in the original tree, but it
12391 instantiated to an empty list, then we should pass a
12392 non-NULL empty vector to tell build_new that it was an
12393 empty initializer() rather than no initializer. This can
12394 only happen when the initializer is a pack expansion whose
12395 parameter packs are of length zero. */
12396 if (init == NULL_TREE && TREE_OPERAND (t, 3) == NULL_TREE)
12400 init_vec = make_tree_vector ();
12401 if (init == void_zero_node)
12402 gcc_assert (init_vec != NULL);
12405 for (; init != NULL_TREE; init = TREE_CHAIN (init))
12406 VEC_safe_push (tree, gc, init_vec, TREE_VALUE (init));
12410 ret = build_new (&placement_vec,
12411 RECUR (TREE_OPERAND (t, 1)),
12412 RECUR (TREE_OPERAND (t, 2)),
12414 NEW_EXPR_USE_GLOBAL (t),
12417 if (placement_vec != NULL)
12418 release_tree_vector (placement_vec);
12419 if (init_vec != NULL)
12420 release_tree_vector (init_vec);
12426 return delete_sanity
12427 (RECUR (TREE_OPERAND (t, 0)),
12428 RECUR (TREE_OPERAND (t, 1)),
12429 DELETE_EXPR_USE_VEC (t),
12430 DELETE_EXPR_USE_GLOBAL (t));
12432 case COMPOUND_EXPR:
12433 return build_x_compound_expr (RECUR (TREE_OPERAND (t, 0)),
12434 RECUR (TREE_OPERAND (t, 1)),
12440 VEC(tree,gc) *call_args;
12441 unsigned int nargs, i;
12446 function = CALL_EXPR_FN (t);
12447 /* When we parsed the expression, we determined whether or
12448 not Koenig lookup should be performed. */
12449 koenig_p = KOENIG_LOOKUP_P (t);
12450 if (TREE_CODE (function) == SCOPE_REF)
12452 qualified_p = true;
12453 function = tsubst_qualified_id (function, args, complain, in_decl,
12455 /*address_p=*/false);
12459 if (TREE_CODE (function) == COMPONENT_REF)
12461 tree op = TREE_OPERAND (function, 1);
12463 qualified_p = (TREE_CODE (op) == SCOPE_REF
12464 || (BASELINK_P (op)
12465 && BASELINK_QUALIFIED_P (op)));
12468 qualified_p = false;
12470 function = tsubst_copy_and_build (function, args, complain,
12473 integral_constant_expression_p);
12475 if (BASELINK_P (function))
12476 qualified_p = true;
12479 nargs = call_expr_nargs (t);
12480 call_args = make_tree_vector ();
12481 for (i = 0; i < nargs; ++i)
12483 tree arg = CALL_EXPR_ARG (t, i);
12485 if (!PACK_EXPANSION_P (arg))
12486 VEC_safe_push (tree, gc, call_args,
12487 RECUR (CALL_EXPR_ARG (t, i)));
12490 /* Expand the pack expansion and push each entry onto
12492 arg = tsubst_pack_expansion (arg, args, complain, in_decl);
12493 if (TREE_CODE (arg) == TREE_VEC)
12495 unsigned int len, j;
12497 len = TREE_VEC_LENGTH (arg);
12498 for (j = 0; j < len; ++j)
12500 tree value = TREE_VEC_ELT (arg, j);
12501 if (value != NULL_TREE)
12502 value = convert_from_reference (value);
12503 VEC_safe_push (tree, gc, call_args, value);
12508 /* A partial substitution. Add one entry. */
12509 VEC_safe_push (tree, gc, call_args, arg);
12514 /* We do not perform argument-dependent lookup if normal
12515 lookup finds a non-function, in accordance with the
12516 expected resolution of DR 218. */
12518 && ((is_overloaded_fn (function)
12519 /* If lookup found a member function, the Koenig lookup is
12520 not appropriate, even if an unqualified-name was used
12521 to denote the function. */
12522 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function)))
12523 || TREE_CODE (function) == IDENTIFIER_NODE)
12524 /* Only do this when substitution turns a dependent call
12525 into a non-dependent call. */
12526 && type_dependent_expression_p_push (t)
12527 && !any_type_dependent_arguments_p (call_args))
12528 function = perform_koenig_lookup (function, call_args);
12530 if (TREE_CODE (function) == IDENTIFIER_NODE)
12532 unqualified_name_lookup_error (function);
12533 release_tree_vector (call_args);
12534 return error_mark_node;
12537 /* Remember that there was a reference to this entity. */
12538 if (DECL_P (function))
12539 mark_used (function);
12541 if (TREE_CODE (function) == OFFSET_REF)
12542 ret = build_offset_ref_call_from_tree (function, &call_args);
12543 else if (TREE_CODE (function) == COMPONENT_REF)
12545 tree instance = TREE_OPERAND (function, 0);
12546 tree fn = TREE_OPERAND (function, 1);
12548 if (processing_template_decl
12549 && (type_dependent_expression_p (instance)
12550 || (!BASELINK_P (fn)
12551 && TREE_CODE (fn) != FIELD_DECL)
12552 || type_dependent_expression_p (fn)
12553 || any_type_dependent_arguments_p (call_args)))
12554 ret = build_nt_call_vec (function, call_args);
12555 else if (!BASELINK_P (fn))
12556 ret = finish_call_expr (function, &call_args,
12557 /*disallow_virtual=*/false,
12558 /*koenig_p=*/false,
12561 ret = (build_new_method_call
12563 &call_args, NULL_TREE,
12564 qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL,
12569 ret = finish_call_expr (function, &call_args,
12570 /*disallow_virtual=*/qualified_p,
12574 release_tree_vector (call_args);
12580 return build_x_conditional_expr
12581 (RECUR (TREE_OPERAND (t, 0)),
12582 RECUR (TREE_OPERAND (t, 1)),
12583 RECUR (TREE_OPERAND (t, 2)),
12586 case PSEUDO_DTOR_EXPR:
12587 return finish_pseudo_destructor_expr
12588 (RECUR (TREE_OPERAND (t, 0)),
12589 RECUR (TREE_OPERAND (t, 1)),
12590 RECUR (TREE_OPERAND (t, 2)));
12594 tree purpose, value, chain;
12596 if (t == void_list_node)
12599 if ((TREE_PURPOSE (t) && PACK_EXPANSION_P (TREE_PURPOSE (t)))
12600 || (TREE_VALUE (t) && PACK_EXPANSION_P (TREE_VALUE (t))))
12602 /* We have pack expansions, so expand those and
12603 create a new list out of it. */
12604 tree purposevec = NULL_TREE;
12605 tree valuevec = NULL_TREE;
12609 /* Expand the argument expressions. */
12610 if (TREE_PURPOSE (t))
12611 purposevec = tsubst_pack_expansion (TREE_PURPOSE (t), args,
12612 complain, in_decl);
12613 if (TREE_VALUE (t))
12614 valuevec = tsubst_pack_expansion (TREE_VALUE (t), args,
12615 complain, in_decl);
12617 /* Build the rest of the list. */
12618 chain = TREE_CHAIN (t);
12619 if (chain && chain != void_type_node)
12620 chain = RECUR (chain);
12622 /* Determine the number of arguments. */
12623 if (purposevec && TREE_CODE (purposevec) == TREE_VEC)
12625 len = TREE_VEC_LENGTH (purposevec);
12626 gcc_assert (!valuevec || len == TREE_VEC_LENGTH (valuevec));
12628 else if (TREE_CODE (valuevec) == TREE_VEC)
12629 len = TREE_VEC_LENGTH (valuevec);
12632 /* Since we only performed a partial substitution into
12633 the argument pack, we only return a single list
12635 if (purposevec == TREE_PURPOSE (t)
12636 && valuevec == TREE_VALUE (t)
12637 && chain == TREE_CHAIN (t))
12640 return tree_cons (purposevec, valuevec, chain);
12643 /* Convert the argument vectors into a TREE_LIST */
12647 /* Grab the Ith values. */
12649 purpose = purposevec ? TREE_VEC_ELT (purposevec, i)
12652 = valuevec ? convert_from_reference (TREE_VEC_ELT (valuevec, i))
12655 /* Build the list (backwards). */
12656 chain = tree_cons (purpose, value, chain);
12662 purpose = TREE_PURPOSE (t);
12664 purpose = RECUR (purpose);
12665 value = TREE_VALUE (t);
12667 value = RECUR (value);
12668 chain = TREE_CHAIN (t);
12669 if (chain && chain != void_type_node)
12670 chain = RECUR (chain);
12671 if (purpose == TREE_PURPOSE (t)
12672 && value == TREE_VALUE (t)
12673 && chain == TREE_CHAIN (t))
12675 return tree_cons (purpose, value, chain);
12678 case COMPONENT_REF:
12684 object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
12685 args, complain, in_decl);
12686 /* Remember that there was a reference to this entity. */
12687 if (DECL_P (object))
12688 mark_used (object);
12689 object_type = TREE_TYPE (object);
12691 member = TREE_OPERAND (t, 1);
12692 if (BASELINK_P (member))
12693 member = tsubst_baselink (member,
12694 non_reference (TREE_TYPE (object)),
12695 args, complain, in_decl);
12697 member = tsubst_copy (member, args, complain, in_decl);
12698 if (member == error_mark_node)
12699 return error_mark_node;
12701 if (object_type && !CLASS_TYPE_P (object_type))
12703 if (SCALAR_TYPE_P (object_type))
12705 tree s = NULL_TREE;
12706 tree dtor = member;
12708 if (TREE_CODE (dtor) == SCOPE_REF)
12710 s = TREE_OPERAND (dtor, 0);
12711 dtor = TREE_OPERAND (dtor, 1);
12713 if (TREE_CODE (dtor) == BIT_NOT_EXPR)
12715 dtor = TREE_OPERAND (dtor, 0);
12717 return finish_pseudo_destructor_expr (object, s, dtor);
12721 else if (TREE_CODE (member) == SCOPE_REF
12722 && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
12727 /* Lookup the template functions now that we know what the
12729 tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
12730 args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
12731 member = lookup_qualified_name (TREE_OPERAND (member, 0), tmpl,
12732 /*is_type_p=*/false,
12733 /*complain=*/false);
12734 if (BASELINK_P (member))
12736 BASELINK_FUNCTIONS (member)
12737 = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
12739 member = (adjust_result_of_qualified_name_lookup
12740 (member, BINFO_TYPE (BASELINK_BINFO (member)),
12745 qualified_name_lookup_error (object_type, tmpl, member,
12747 return error_mark_node;
12750 else if (TREE_CODE (member) == SCOPE_REF
12751 && !CLASS_TYPE_P (TREE_OPERAND (member, 0))
12752 && TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL)
12754 if (complain & tf_error)
12756 if (TYPE_P (TREE_OPERAND (member, 0)))
12757 error ("%qT is not a class or namespace",
12758 TREE_OPERAND (member, 0));
12760 error ("%qD is not a class or namespace",
12761 TREE_OPERAND (member, 0));
12763 return error_mark_node;
12765 else if (TREE_CODE (member) == FIELD_DECL)
12766 return finish_non_static_data_member (member, object, NULL_TREE);
12768 return finish_class_member_access_expr (object, member,
12769 /*template_p=*/false,
12775 (RECUR (TREE_OPERAND (t, 0)));
12779 VEC(constructor_elt,gc) *n;
12780 constructor_elt *ce;
12781 unsigned HOST_WIDE_INT idx;
12782 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
12783 bool process_index_p;
12785 bool need_copy_p = false;
12788 if (type == error_mark_node)
12789 return error_mark_node;
12791 /* digest_init will do the wrong thing if we let it. */
12792 if (type && TYPE_PTRMEMFUNC_P (type))
12795 /* We do not want to process the index of aggregate
12796 initializers as they are identifier nodes which will be
12797 looked up by digest_init. */
12798 process_index_p = !(type && MAYBE_CLASS_TYPE_P (type));
12800 n = VEC_copy (constructor_elt, gc, CONSTRUCTOR_ELTS (t));
12801 newlen = VEC_length (constructor_elt, n);
12802 for (idx = 0; VEC_iterate (constructor_elt, n, idx, ce); idx++)
12804 if (ce->index && process_index_p)
12805 ce->index = RECUR (ce->index);
12807 if (PACK_EXPANSION_P (ce->value))
12809 /* Substitute into the pack expansion. */
12810 ce->value = tsubst_pack_expansion (ce->value, args, complain,
12813 if (ce->value == error_mark_node)
12815 else if (TREE_VEC_LENGTH (ce->value) == 1)
12816 /* Just move the argument into place. */
12817 ce->value = TREE_VEC_ELT (ce->value, 0);
12820 /* Update the length of the final CONSTRUCTOR
12821 arguments vector, and note that we will need to
12823 newlen = newlen + TREE_VEC_LENGTH (ce->value) - 1;
12824 need_copy_p = true;
12828 ce->value = RECUR (ce->value);
12833 VEC(constructor_elt,gc) *old_n = n;
12835 n = VEC_alloc (constructor_elt, gc, newlen);
12836 for (idx = 0; VEC_iterate (constructor_elt, old_n, idx, ce);
12839 if (TREE_CODE (ce->value) == TREE_VEC)
12841 int i, len = TREE_VEC_LENGTH (ce->value);
12842 for (i = 0; i < len; ++i)
12843 CONSTRUCTOR_APPEND_ELT (n, 0,
12844 TREE_VEC_ELT (ce->value, i));
12847 CONSTRUCTOR_APPEND_ELT (n, 0, ce->value);
12851 r = build_constructor (init_list_type_node, n);
12852 CONSTRUCTOR_IS_DIRECT_INIT (r) = CONSTRUCTOR_IS_DIRECT_INIT (t);
12854 if (TREE_HAS_CONSTRUCTOR (t))
12855 return finish_compound_literal (type, r);
12862 tree operand_0 = RECUR (TREE_OPERAND (t, 0));
12863 if (TYPE_P (operand_0))
12864 return get_typeid (operand_0);
12865 return build_typeid (operand_0);
12875 tree r = tsubst_copy (t, args, complain, in_decl);
12877 if (TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
12878 /* If the original type was a reference, we'll be wrapped in
12879 the appropriate INDIRECT_REF. */
12880 r = convert_from_reference (r);
12885 return build_x_va_arg (RECUR (TREE_OPERAND (t, 0)),
12886 tsubst_copy (TREE_TYPE (t), args, complain,
12889 case OFFSETOF_EXPR:
12890 return finish_offsetof (RECUR (TREE_OPERAND (t, 0)));
12894 tree type1 = tsubst_copy (TRAIT_EXPR_TYPE1 (t), args,
12895 complain, in_decl);
12897 tree type2 = TRAIT_EXPR_TYPE2 (t);
12899 type2 = tsubst_copy (type2, args, complain, in_decl);
12901 return finish_trait_expr (TRAIT_EXPR_KIND (t), type1, type2);
12906 tree old_stmt_expr = cur_stmt_expr;
12907 tree stmt_expr = begin_stmt_expr ();
12909 cur_stmt_expr = stmt_expr;
12910 tsubst_expr (STMT_EXPR_STMT (t), args, complain, in_decl,
12911 integral_constant_expression_p);
12912 stmt_expr = finish_stmt_expr (stmt_expr, false);
12913 cur_stmt_expr = old_stmt_expr;
12915 /* If the resulting list of expression statement is empty,
12916 fold it further into void_zero_node. */
12917 if (empty_expr_stmt_p (stmt_expr))
12918 stmt_expr = void_zero_node;
12924 t = tsubst_copy (t, args, complain, in_decl);
12925 /* As in finish_id_expression, we resolve enumeration constants
12926 to their underlying values. */
12927 if (TREE_CODE (t) == CONST_DECL)
12929 used_types_insert (TREE_TYPE (t));
12930 return DECL_INITIAL (t);
12936 tree r = build_lambda_expr ();
12938 tree type = tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
12939 TREE_TYPE (r) = type;
12940 CLASSTYPE_LAMBDA_EXPR (type) = r;
12942 LAMBDA_EXPR_LOCATION (r)
12943 = LAMBDA_EXPR_LOCATION (t);
12944 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r)
12945 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t);
12946 LAMBDA_EXPR_MUTABLE_P (r) = LAMBDA_EXPR_MUTABLE_P (t);
12947 LAMBDA_EXPR_DISCRIMINATOR (r)
12948 = (LAMBDA_EXPR_DISCRIMINATOR (t));
12949 LAMBDA_EXPR_CAPTURE_LIST (r)
12950 = RECUR (LAMBDA_EXPR_CAPTURE_LIST (t));
12951 LAMBDA_EXPR_THIS_CAPTURE (r)
12952 = RECUR (LAMBDA_EXPR_THIS_CAPTURE (t));
12953 LAMBDA_EXPR_EXTRA_SCOPE (r)
12954 = RECUR (LAMBDA_EXPR_EXTRA_SCOPE (t));
12956 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
12957 determine_visibility (TYPE_NAME (type));
12958 /* Now that we know visibility, instantiate the type so we have a
12959 declaration of the op() for later calls to lambda_function. */
12960 complete_type (type);
12962 type = tsubst (LAMBDA_EXPR_RETURN_TYPE (t), args, complain, in_decl);
12964 apply_lambda_return_type (r, type);
12966 return build_lambda_object (r);
12970 /* Handle Objective-C++ constructs, if appropriate. */
12973 = objcp_tsubst_copy_and_build (t, args, complain,
12974 in_decl, /*function_p=*/false);
12978 return tsubst_copy (t, args, complain, in_decl);
12984 /* Verify that the instantiated ARGS are valid. For type arguments,
12985 make sure that the type's linkage is ok. For non-type arguments,
12986 make sure they are constants if they are integral or enumerations.
12987 Emit an error under control of COMPLAIN, and return TRUE on error. */
12990 check_instantiated_arg (tree tmpl, tree t, tsubst_flags_t complain)
12992 if (ARGUMENT_PACK_P (t))
12994 tree vec = ARGUMENT_PACK_ARGS (t);
12995 int len = TREE_VEC_LENGTH (vec);
12996 bool result = false;
12999 for (i = 0; i < len; ++i)
13000 if (check_instantiated_arg (tmpl, TREE_VEC_ELT (vec, i), complain))
13004 else if (TYPE_P (t))
13006 /* [basic.link]: A name with no linkage (notably, the name
13007 of a class or enumeration declared in a local scope)
13008 shall not be used to declare an entity with linkage.
13009 This implies that names with no linkage cannot be used as
13012 DR 757 relaxes this restriction for C++0x. */
13013 tree nt = (cxx_dialect > cxx98 ? NULL_TREE
13014 : no_linkage_check (t, /*relaxed_p=*/false));
13018 /* DR 488 makes use of a type with no linkage cause
13019 type deduction to fail. */
13020 if (complain & tf_error)
13022 if (TYPE_ANONYMOUS_P (nt))
13023 error ("%qT is/uses anonymous type", t);
13025 error ("template argument for %qD uses local type %qT",
13030 /* In order to avoid all sorts of complications, we do not
13031 allow variably-modified types as template arguments. */
13032 else if (variably_modified_type_p (t, NULL_TREE))
13034 if (complain & tf_error)
13035 error ("%qT is a variably modified type", t);
13039 /* A non-type argument of integral or enumerated type must be a
13041 else if (TREE_TYPE (t)
13042 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t))
13043 && !TREE_CONSTANT (t))
13045 if (complain & tf_error)
13046 error ("integral expression %qE is not constant", t);
13053 check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain)
13055 int ix, len = DECL_NTPARMS (tmpl);
13056 bool result = false;
13058 for (ix = 0; ix != len; ix++)
13060 if (check_instantiated_arg (tmpl, TREE_VEC_ELT (args, ix), complain))
13063 if (result && (complain & tf_error))
13064 error (" trying to instantiate %qD", tmpl);
13068 /* Instantiate the indicated variable or function template TMPL with
13069 the template arguments in TARG_PTR. */
13072 instantiate_template (tree tmpl, tree orig_args, tsubst_flags_t complain)
13074 tree targ_ptr = orig_args;
13078 HOST_WIDE_INT saved_processing_template_decl;
13080 if (tmpl == error_mark_node)
13081 return error_mark_node;
13083 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
13085 /* If this function is a clone, handle it specially. */
13086 if (DECL_CLONED_FUNCTION_P (tmpl))
13091 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
13092 DECL_CLONED_FUNCTION. */
13093 spec = instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl),
13094 targ_ptr, complain);
13095 if (spec == error_mark_node)
13096 return error_mark_node;
13098 /* Look for the clone. */
13099 FOR_EACH_CLONE (clone, spec)
13100 if (DECL_NAME (clone) == DECL_NAME (tmpl))
13102 /* We should always have found the clone by now. */
13103 gcc_unreachable ();
13107 /* Check to see if we already have this specialization. */
13108 gen_tmpl = most_general_template (tmpl);
13109 if (tmpl != gen_tmpl)
13110 /* The TMPL is a partial instantiation. To get a full set of
13111 arguments we must add the arguments used to perform the
13112 partial instantiation. */
13113 targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl),
13116 /* It would be nice to avoid hashing here and then again in tsubst_decl,
13117 but it doesn't seem to be on the hot path. */
13118 spec = retrieve_specialization (gen_tmpl, targ_ptr, 0);
13120 gcc_assert (tmpl == gen_tmpl
13121 || ((fndecl = retrieve_specialization (tmpl, orig_args, 0))
13123 || fndecl == NULL_TREE);
13125 if (spec != NULL_TREE)
13128 if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr),
13130 return error_mark_node;
13132 /* We are building a FUNCTION_DECL, during which the access of its
13133 parameters and return types have to be checked. However this
13134 FUNCTION_DECL which is the desired context for access checking
13135 is not built yet. We solve this chicken-and-egg problem by
13136 deferring all checks until we have the FUNCTION_DECL. */
13137 push_deferring_access_checks (dk_deferred);
13139 /* Although PROCESSING_TEMPLATE_DECL may be true at this point
13140 (because, for example, we have encountered a non-dependent
13141 function call in the body of a template function and must now
13142 determine which of several overloaded functions will be called),
13143 within the instantiation itself we are not processing a
13145 saved_processing_template_decl = processing_template_decl;
13146 processing_template_decl = 0;
13147 /* Substitute template parameters to obtain the specialization. */
13148 fndecl = tsubst (DECL_TEMPLATE_RESULT (gen_tmpl),
13149 targ_ptr, complain, gen_tmpl);
13150 processing_template_decl = saved_processing_template_decl;
13151 if (fndecl == error_mark_node)
13152 return error_mark_node;
13154 /* Now we know the specialization, compute access previously
13156 push_access_scope (fndecl);
13158 /* Some typedefs referenced from within the template code need to be access
13159 checked at template instantiation time, i.e now. These types were
13160 added to the template at parsing time. Let's get those and perfom
13161 the acces checks then. */
13162 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (tmpl), targ_ptr);
13163 perform_deferred_access_checks ();
13164 pop_access_scope (fndecl);
13165 pop_deferring_access_checks ();
13167 /* The DECL_TI_TEMPLATE should always be the immediate parent
13168 template, not the most general template. */
13169 DECL_TI_TEMPLATE (fndecl) = tmpl;
13171 /* If we've just instantiated the main entry point for a function,
13172 instantiate all the alternate entry points as well. We do this
13173 by cloning the instantiation of the main entry point, not by
13174 instantiating the template clones. */
13175 if (DECL_CHAIN (gen_tmpl) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl)))
13176 clone_function_decl (fndecl, /*update_method_vec_p=*/0);
13181 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
13182 NARGS elements of the arguments that are being used when calling
13183 it. TARGS is a vector into which the deduced template arguments
13186 Return zero for success, 2 for an incomplete match that doesn't resolve
13187 all the types, and 1 for complete failure. An error message will be
13188 printed only for an incomplete match.
13190 If FN is a conversion operator, or we are trying to produce a specific
13191 specialization, RETURN_TYPE is the return type desired.
13193 The EXPLICIT_TARGS are explicit template arguments provided via a
13196 The parameter STRICT is one of:
13199 We are deducing arguments for a function call, as in
13200 [temp.deduct.call].
13203 We are deducing arguments for a conversion function, as in
13204 [temp.deduct.conv].
13207 We are deducing arguments when doing an explicit instantiation
13208 as in [temp.explicit], when determining an explicit specialization
13209 as in [temp.expl.spec], or when taking the address of a function
13210 template, as in [temp.deduct.funcaddr]. */
13213 fn_type_unification (tree fn,
13214 tree explicit_targs,
13217 unsigned int nargs,
13219 unification_kind_t strict,
13225 bool incomplete_argument_packs_p = false;
13227 gcc_assert (TREE_CODE (fn) == TEMPLATE_DECL);
13229 fntype = TREE_TYPE (fn);
13230 if (explicit_targs)
13234 The specified template arguments must match the template
13235 parameters in kind (i.e., type, nontype, template), and there
13236 must not be more arguments than there are parameters;
13237 otherwise type deduction fails.
13239 Nontype arguments must match the types of the corresponding
13240 nontype template parameters, or must be convertible to the
13241 types of the corresponding nontype parameters as specified in
13242 _temp.arg.nontype_, otherwise type deduction fails.
13244 All references in the function type of the function template
13245 to the corresponding template parameters are replaced by the
13246 specified template argument values. If a substitution in a
13247 template parameter or in the function type of the function
13248 template results in an invalid type, type deduction fails. */
13249 tree tparms = DECL_INNERMOST_TEMPLATE_PARMS (fn);
13250 int i, len = TREE_VEC_LENGTH (tparms);
13251 tree converted_args;
13252 bool incomplete = false;
13254 if (explicit_targs == error_mark_node)
13258 = (coerce_template_parms (tparms, explicit_targs, NULL_TREE, tf_none,
13259 /*require_all_args=*/false,
13260 /*use_default_args=*/false));
13261 if (converted_args == error_mark_node)
13264 /* Substitute the explicit args into the function type. This is
13265 necessary so that, for instance, explicitly declared function
13266 arguments can match null pointed constants. If we were given
13267 an incomplete set of explicit args, we must not do semantic
13268 processing during substitution as we could create partial
13270 for (i = 0; i < len; i++)
13272 tree parm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
13273 bool parameter_pack = false;
13275 /* Dig out the actual parm. */
13276 if (TREE_CODE (parm) == TYPE_DECL
13277 || TREE_CODE (parm) == TEMPLATE_DECL)
13279 parm = TREE_TYPE (parm);
13280 parameter_pack = TEMPLATE_TYPE_PARAMETER_PACK (parm);
13282 else if (TREE_CODE (parm) == PARM_DECL)
13284 parm = DECL_INITIAL (parm);
13285 parameter_pack = TEMPLATE_PARM_PARAMETER_PACK (parm);
13288 if (parameter_pack)
13292 template_parm_level_and_index (parm, &level, &idx);
13294 /* Mark the argument pack as "incomplete". We could
13295 still deduce more arguments during unification. */
13296 targ = TMPL_ARG (converted_args, level, idx);
13299 ARGUMENT_PACK_INCOMPLETE_P(targ) = 1;
13300 ARGUMENT_PACK_EXPLICIT_ARGS (targ)
13301 = ARGUMENT_PACK_ARGS (targ);
13304 /* We have some incomplete argument packs. */
13305 incomplete_argument_packs_p = true;
13309 if (incomplete_argument_packs_p)
13310 /* Any substitution is guaranteed to be incomplete if there
13311 are incomplete argument packs, because we can still deduce
13315 incomplete = NUM_TMPL_ARGS (explicit_targs) != NUM_TMPL_ARGS (targs);
13317 processing_template_decl += incomplete;
13318 fntype = tsubst (fntype, converted_args, tf_none, NULL_TREE);
13319 processing_template_decl -= incomplete;
13321 if (fntype == error_mark_node)
13324 /* Place the explicitly specified arguments in TARGS. */
13325 for (i = NUM_TMPL_ARGS (converted_args); i--;)
13326 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i);
13329 /* Never do unification on the 'this' parameter. */
13330 parms = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (fntype));
13336 parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms);
13337 new_args = XALLOCAVEC (tree, nargs + 1);
13338 new_args[0] = return_type;
13339 memcpy (new_args + 1, args, nargs * sizeof (tree));
13344 /* We allow incomplete unification without an error message here
13345 because the standard doesn't seem to explicitly prohibit it. Our
13346 callers must be ready to deal with unification failures in any
13348 result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
13349 targs, parms, args, nargs, /*subr=*/0,
13352 if (result == 0 && incomplete_argument_packs_p)
13354 int i, len = NUM_TMPL_ARGS (targs);
13356 /* Clear the "incomplete" flags on all argument packs. */
13357 for (i = 0; i < len; i++)
13359 tree arg = TREE_VEC_ELT (targs, i);
13360 if (ARGUMENT_PACK_P (arg))
13362 ARGUMENT_PACK_INCOMPLETE_P (arg) = 0;
13363 ARGUMENT_PACK_EXPLICIT_ARGS (arg) = NULL_TREE;
13368 /* Now that we have bindings for all of the template arguments,
13369 ensure that the arguments deduced for the template template
13370 parameters have compatible template parameter lists. We cannot
13371 check this property before we have deduced all template
13372 arguments, because the template parameter types of a template
13373 template parameter might depend on prior template parameters
13374 deduced after the template template parameter. The following
13375 ill-formed example illustrates this issue:
13377 template<typename T, template<T> class C> void f(C<5>, T);
13379 template<int N> struct X {};
13382 f(X<5>(), 5l); // error: template argument deduction fails
13385 The template parameter list of 'C' depends on the template type
13386 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
13387 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
13388 time that we deduce 'C'. */
13390 && !template_template_parm_bindings_ok_p
13391 (DECL_INNERMOST_TEMPLATE_PARMS (fn), targs))
13395 /* All is well so far. Now, check:
13399 When all template arguments have been deduced, all uses of
13400 template parameters in nondeduced contexts are replaced with
13401 the corresponding deduced argument values. If the
13402 substitution results in an invalid type, as described above,
13403 type deduction fails. */
13405 tree substed = tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE);
13406 if (substed == error_mark_node)
13409 /* If we're looking for an exact match, check that what we got
13410 is indeed an exact match. It might not be if some template
13411 parameters are used in non-deduced contexts. */
13412 if (strict == DEDUCE_EXACT)
13417 = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (substed));
13419 sarg = tree_cons (NULL_TREE, TREE_TYPE (substed), sarg);
13420 for (i = 0; i < nargs && sarg; ++i, sarg = TREE_CHAIN (sarg))
13421 if (!same_type_p (args[i], TREE_VALUE (sarg)))
13429 /* Adjust types before performing type deduction, as described in
13430 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
13431 sections are symmetric. PARM is the type of a function parameter
13432 or the return type of the conversion function. ARG is the type of
13433 the argument passed to the call, or the type of the value
13434 initialized with the result of the conversion function.
13435 ARG_EXPR is the original argument expression, which may be null. */
13438 maybe_adjust_types_for_deduction (unification_kind_t strict,
13452 /* Swap PARM and ARG throughout the remainder of this
13453 function; the handling is precisely symmetric since PARM
13454 will initialize ARG rather than vice versa. */
13462 /* Core issue #873: Do the DR606 thing (see below) for these cases,
13463 too, but here handle it by stripping the reference from PARM
13464 rather than by adding it to ARG. */
13465 if (TREE_CODE (*parm) == REFERENCE_TYPE
13466 && TYPE_REF_IS_RVALUE (*parm)
13467 && TREE_CODE (TREE_TYPE (*parm)) == TEMPLATE_TYPE_PARM
13468 && cp_type_quals (TREE_TYPE (*parm)) == TYPE_UNQUALIFIED
13469 && TREE_CODE (*arg) == REFERENCE_TYPE
13470 && !TYPE_REF_IS_RVALUE (*arg))
13471 *parm = TREE_TYPE (*parm);
13472 /* Nothing else to do in this case. */
13476 gcc_unreachable ();
13479 if (TREE_CODE (*parm) != REFERENCE_TYPE)
13481 /* [temp.deduct.call]
13483 If P is not a reference type:
13485 --If A is an array type, the pointer type produced by the
13486 array-to-pointer standard conversion (_conv.array_) is
13487 used in place of A for type deduction; otherwise,
13489 --If A is a function type, the pointer type produced by
13490 the function-to-pointer standard conversion
13491 (_conv.func_) is used in place of A for type deduction;
13494 --If A is a cv-qualified type, the top level
13495 cv-qualifiers of A's type are ignored for type
13497 if (TREE_CODE (*arg) == ARRAY_TYPE)
13498 *arg = build_pointer_type (TREE_TYPE (*arg));
13499 else if (TREE_CODE (*arg) == FUNCTION_TYPE)
13500 *arg = build_pointer_type (*arg);
13502 *arg = TYPE_MAIN_VARIANT (*arg);
13505 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
13506 of the form T&&, where T is a template parameter, and the argument
13507 is an lvalue, T is deduced as A& */
13508 if (TREE_CODE (*parm) == REFERENCE_TYPE
13509 && TYPE_REF_IS_RVALUE (*parm)
13510 && TREE_CODE (TREE_TYPE (*parm)) == TEMPLATE_TYPE_PARM
13511 && cp_type_quals (TREE_TYPE (*parm)) == TYPE_UNQUALIFIED
13512 && arg_expr && real_lvalue_p (arg_expr))
13513 *arg = build_reference_type (*arg);
13515 /* [temp.deduct.call]
13517 If P is a cv-qualified type, the top level cv-qualifiers
13518 of P's type are ignored for type deduction. If P is a
13519 reference type, the type referred to by P is used for
13521 *parm = TYPE_MAIN_VARIANT (*parm);
13522 if (TREE_CODE (*parm) == REFERENCE_TYPE)
13524 *parm = TREE_TYPE (*parm);
13525 result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
13528 /* DR 322. For conversion deduction, remove a reference type on parm
13529 too (which has been swapped into ARG). */
13530 if (strict == DEDUCE_CONV && TREE_CODE (*arg) == REFERENCE_TYPE)
13531 *arg = TREE_TYPE (*arg);
13536 /* Most parms like fn_type_unification.
13538 If SUBR is 1, we're being called recursively (to unify the
13539 arguments of a function or method parameter of a function
13543 type_unification_real (tree tparms,
13547 unsigned int xnargs,
13549 unification_kind_t strict,
13552 tree parm, arg, arg_expr;
13554 int ntparms = TREE_VEC_LENGTH (tparms);
13556 int saw_undeduced = 0;
13559 unsigned int nargs;
13562 gcc_assert (TREE_CODE (tparms) == TREE_VEC);
13563 gcc_assert (xparms == NULL_TREE || TREE_CODE (xparms) == TREE_LIST);
13564 gcc_assert (ntparms > 0);
13566 /* Reset the number of non-defaulted template arguments contained
13568 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs) = NULL_TREE;
13573 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL | UNIFY_ALLOW_MORE_CV_QUAL
13574 | UNIFY_ALLOW_DERIVED);
13578 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
13582 sub_strict = UNIFY_ALLOW_NONE;
13586 gcc_unreachable ();
13595 while (parms && parms != void_list_node
13598 if (TREE_CODE (TREE_VALUE (parms)) == TYPE_PACK_EXPANSION)
13601 parm = TREE_VALUE (parms);
13602 parms = TREE_CHAIN (parms);
13607 if (arg == error_mark_node)
13609 if (arg == unknown_type_node)
13610 /* We can't deduce anything from this, but we might get all the
13611 template args from other function args. */
13614 /* Conversions will be performed on a function argument that
13615 corresponds with a function parameter that contains only
13616 non-deducible template parameters and explicitly specified
13617 template parameters. */
13618 if (!uses_template_parms (parm))
13623 type = TREE_TYPE (arg);
13627 if (same_type_p (parm, type))
13629 if (strict != DEDUCE_EXACT
13630 && can_convert_arg (parm, type, TYPE_P (arg) ? NULL_TREE : arg,
13639 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
13640 if (type_unknown_p (arg))
13642 /* [temp.deduct.type]
13644 A template-argument can be deduced from a pointer to
13645 function or pointer to member function argument if
13646 the set of overloaded functions does not contain
13647 function templates and at most one of a set of
13648 overloaded functions provides a unique match. */
13649 if (resolve_overloaded_unification
13650 (tparms, targs, parm, arg, strict, sub_strict))
13656 arg = unlowered_expr_type (arg);
13657 if (arg == error_mark_node)
13662 int arg_strict = sub_strict;
13665 arg_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg,
13668 if (arg == init_list_type_node && arg_expr)
13670 if (unify (tparms, targs, parm, arg, arg_strict))
13677 && parms != void_list_node
13678 && TREE_CODE (TREE_VALUE (parms)) == TYPE_PACK_EXPANSION)
13680 /* Unify the remaining arguments with the pack expansion type. */
13682 tree parmvec = make_tree_vec (1);
13684 /* Allocate a TREE_VEC and copy in all of the arguments */
13685 argvec = make_tree_vec (nargs - ia);
13686 for (i = 0; ia < nargs; ++ia, ++i)
13687 TREE_VEC_ELT (argvec, i) = args[ia];
13689 /* Copy the parameter into parmvec. */
13690 TREE_VEC_ELT (parmvec, 0) = TREE_VALUE (parms);
13691 if (unify_pack_expansion (tparms, targs, parmvec, argvec, strict,
13692 /*call_args_p=*/true, /*subr=*/subr))
13695 /* Advance to the end of the list of parameters. */
13696 parms = TREE_CHAIN (parms);
13699 /* Fail if we've reached the end of the parm list, and more args
13700 are present, and the parm list isn't variadic. */
13701 if (ia < nargs && parms == void_list_node)
13703 /* Fail if parms are left and they don't have default values. */
13704 if (parms && parms != void_list_node
13705 && TREE_PURPOSE (parms) == NULL_TREE)
13709 for (i = 0; i < ntparms; i++)
13710 if (!TREE_VEC_ELT (targs, i))
13714 if (TREE_VEC_ELT (tparms, i) == error_mark_node)
13717 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
13719 /* If this is an undeduced nontype parameter that depends on
13720 a type parameter, try another pass; its type may have been
13721 deduced from a later argument than the one from which
13722 this parameter can be deduced. */
13723 if (TREE_CODE (tparm) == PARM_DECL
13724 && uses_template_parms (TREE_TYPE (tparm))
13725 && !saw_undeduced++)
13728 /* Core issue #226 (C++0x) [temp.deduct]:
13730 If a template argument has not been deduced, its
13731 default template argument, if any, is used.
13733 When we are in C++98 mode, TREE_PURPOSE will either
13734 be NULL_TREE or ERROR_MARK_NODE, so we do not need
13735 to explicitly check cxx_dialect here. */
13736 if (TREE_PURPOSE (TREE_VEC_ELT (tparms, i)))
13738 tree parm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
13739 tree arg = TREE_PURPOSE (TREE_VEC_ELT (tparms, i));
13740 arg = tsubst_template_arg (arg, targs, tf_none, NULL_TREE);
13741 arg = convert_template_argument (parm, arg, targs, tf_none,
13743 if (arg == error_mark_node)
13747 TREE_VEC_ELT (targs, i) = arg;
13748 /* The position of the first default template argument,
13749 is also the number of non-defaulted arguments in TARGS.
13751 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs))
13752 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs, i);
13757 /* If the type parameter is a parameter pack, then it will
13758 be deduced to an empty parameter pack. */
13759 if (template_parameter_pack_p (tparm))
13763 if (TREE_CODE (tparm) == TEMPLATE_PARM_INDEX)
13765 arg = make_node (NONTYPE_ARGUMENT_PACK);
13766 TREE_TYPE (arg) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm));
13767 TREE_CONSTANT (arg) = 1;
13770 arg = cxx_make_type (TYPE_ARGUMENT_PACK);
13772 SET_ARGUMENT_PACK_ARGS (arg, make_tree_vec (0));
13774 TREE_VEC_ELT (targs, i) = arg;
13780 #ifdef ENABLE_CHECKING
13781 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs))
13782 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs, TREE_VEC_LENGTH (targs));
13788 /* Subroutine of type_unification_real. Args are like the variables
13789 at the call site. ARG is an overloaded function (or template-id);
13790 we try deducing template args from each of the overloads, and if
13791 only one succeeds, we go with that. Modifies TARGS and returns
13792 true on success. */
13795 resolve_overloaded_unification (tree tparms,
13799 unification_kind_t strict,
13802 tree tempargs = copy_node (targs);
13804 tree goodfn = NULL_TREE;
13807 if (TREE_CODE (arg) == ADDR_EXPR)
13809 arg = TREE_OPERAND (arg, 0);
13815 if (TREE_CODE (arg) == COMPONENT_REF)
13816 /* Handle `&x' where `x' is some static or non-static member
13818 arg = TREE_OPERAND (arg, 1);
13820 if (TREE_CODE (arg) == OFFSET_REF)
13821 arg = TREE_OPERAND (arg, 1);
13823 /* Strip baselink information. */
13824 if (BASELINK_P (arg))
13825 arg = BASELINK_FUNCTIONS (arg);
13827 if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
13829 /* If we got some explicit template args, we need to plug them into
13830 the affected templates before we try to unify, in case the
13831 explicit args will completely resolve the templates in question. */
13833 tree expl_subargs = TREE_OPERAND (arg, 1);
13834 arg = TREE_OPERAND (arg, 0);
13836 for (; arg; arg = OVL_NEXT (arg))
13838 tree fn = OVL_CURRENT (arg);
13839 tree subargs, elem;
13841 if (TREE_CODE (fn) != TEMPLATE_DECL)
13844 ++processing_template_decl;
13845 subargs = get_bindings (fn, DECL_TEMPLATE_RESULT (fn),
13846 expl_subargs, /*check_ret=*/false);
13849 elem = tsubst (TREE_TYPE (fn), subargs, tf_none, NULL_TREE);
13850 if (try_one_overload (tparms, targs, tempargs, parm,
13851 elem, strict, sub_strict, addr_p)
13852 && (!goodfn || !decls_match (goodfn, elem)))
13858 --processing_template_decl;
13861 else if (TREE_CODE (arg) != OVERLOAD
13862 && TREE_CODE (arg) != FUNCTION_DECL)
13863 /* If ARG is, for example, "(0, &f)" then its type will be unknown
13864 -- but the deduction does not succeed because the expression is
13865 not just the function on its own. */
13868 for (; arg; arg = OVL_NEXT (arg))
13869 if (try_one_overload (tparms, targs, tempargs, parm,
13870 TREE_TYPE (OVL_CURRENT (arg)),
13871 strict, sub_strict, addr_p)
13872 && (!goodfn || !decls_match (goodfn, OVL_CURRENT (arg))))
13874 goodfn = OVL_CURRENT (arg);
13878 /* [temp.deduct.type] A template-argument can be deduced from a pointer
13879 to function or pointer to member function argument if the set of
13880 overloaded functions does not contain function templates and at most
13881 one of a set of overloaded functions provides a unique match.
13883 So if we found multiple possibilities, we return success but don't
13884 deduce anything. */
13888 int i = TREE_VEC_LENGTH (targs);
13890 if (TREE_VEC_ELT (tempargs, i))
13891 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i);
13899 /* Core DR 115: In contexts where deduction is done and fails, or in
13900 contexts where deduction is not done, if a template argument list is
13901 specified and it, along with any default template arguments, identifies
13902 a single function template specialization, then the template-id is an
13903 lvalue for the function template specialization. */
13906 resolve_nondeduced_context (tree orig_expr)
13908 tree expr, offset, baselink;
13911 if (!type_unknown_p (orig_expr))
13916 offset = NULL_TREE;
13917 baselink = NULL_TREE;
13919 if (TREE_CODE (expr) == ADDR_EXPR)
13921 expr = TREE_OPERAND (expr, 0);
13924 if (TREE_CODE (expr) == OFFSET_REF)
13927 expr = TREE_OPERAND (expr, 1);
13929 if (TREE_CODE (expr) == BASELINK)
13932 expr = BASELINK_FUNCTIONS (expr);
13935 if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
13938 tree goodfn = NULL_TREE;
13940 /* If we got some explicit template args, we need to plug them into
13941 the affected templates before we try to unify, in case the
13942 explicit args will completely resolve the templates in question. */
13944 tree expl_subargs = TREE_OPERAND (expr, 1);
13945 tree arg = TREE_OPERAND (expr, 0);
13946 tree badfn = NULL_TREE;
13947 tree badargs = NULL_TREE;
13949 for (; arg; arg = OVL_NEXT (arg))
13951 tree fn = OVL_CURRENT (arg);
13952 tree subargs, elem;
13954 if (TREE_CODE (fn) != TEMPLATE_DECL)
13957 ++processing_template_decl;
13958 subargs = get_bindings (fn, DECL_TEMPLATE_RESULT (fn),
13959 expl_subargs, /*check_ret=*/false);
13960 if (subargs && !any_dependent_template_arguments_p (subargs))
13962 elem = instantiate_template (fn, subargs, tf_none);
13963 if (elem == error_mark_node)
13968 else if (elem && (!goodfn || !decls_match (goodfn, elem)))
13974 --processing_template_decl;
13980 expr = build_baselink (BASELINK_BINFO (baselink),
13981 BASELINK_ACCESS_BINFO (baselink),
13982 expr, BASELINK_OPTYPE (baselink));
13984 expr = build2 (OFFSET_REF, TREE_TYPE (expr),
13985 TREE_OPERAND (offset, 0), expr);
13987 expr = build_address (expr);
13990 else if (good == 0 && badargs)
13991 /* There were no good options and at least one bad one, so let the
13992 user know what the problem is. */
13993 instantiate_template (badfn, badargs, tf_warning_or_error);
13998 /* Subroutine of resolve_overloaded_unification; does deduction for a single
13999 overload. Fills TARGS with any deduced arguments, or error_mark_node if
14000 different overloads deduce different arguments for a given parm.
14001 ADDR_P is true if the expression for which deduction is being
14002 performed was of the form "& fn" rather than simply "fn".
14004 Returns 1 on success. */
14007 try_one_overload (tree tparms,
14012 unification_kind_t strict,
14020 /* [temp.deduct.type] A template-argument can be deduced from a pointer
14021 to function or pointer to member function argument if the set of
14022 overloaded functions does not contain function templates and at most
14023 one of a set of overloaded functions provides a unique match.
14025 So if this is a template, just return success. */
14027 if (uses_template_parms (arg))
14030 if (TREE_CODE (arg) == METHOD_TYPE)
14031 arg = build_ptrmemfunc_type (build_pointer_type (arg));
14033 arg = build_pointer_type (arg);
14035 sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg, NULL);
14037 /* We don't copy orig_targs for this because if we have already deduced
14038 some template args from previous args, unify would complain when we
14039 try to deduce a template parameter for the same argument, even though
14040 there isn't really a conflict. */
14041 nargs = TREE_VEC_LENGTH (targs);
14042 tempargs = make_tree_vec (nargs);
14044 if (unify (tparms, tempargs, parm, arg, sub_strict) != 0)
14047 /* First make sure we didn't deduce anything that conflicts with
14048 explicitly specified args. */
14049 for (i = nargs; i--; )
14051 tree elt = TREE_VEC_ELT (tempargs, i);
14052 tree oldelt = TREE_VEC_ELT (orig_targs, i);
14056 else if (uses_template_parms (elt))
14057 /* Since we're unifying against ourselves, we will fill in
14058 template args used in the function parm list with our own
14059 template parms. Discard them. */
14060 TREE_VEC_ELT (tempargs, i) = NULL_TREE;
14061 else if (oldelt && !template_args_equal (oldelt, elt))
14065 for (i = nargs; i--; )
14067 tree elt = TREE_VEC_ELT (tempargs, i);
14070 TREE_VEC_ELT (targs, i) = elt;
14076 /* PARM is a template class (perhaps with unbound template
14077 parameters). ARG is a fully instantiated type. If ARG can be
14078 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
14079 TARGS are as for unify. */
14082 try_class_unification (tree tparms, tree targs, tree parm, tree arg)
14084 tree copy_of_targs;
14086 if (!CLASSTYPE_TEMPLATE_INFO (arg)
14087 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg))
14088 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm))))
14091 /* We need to make a new template argument vector for the call to
14092 unify. If we used TARGS, we'd clutter it up with the result of
14093 the attempted unification, even if this class didn't work out.
14094 We also don't want to commit ourselves to all the unifications
14095 we've already done, since unification is supposed to be done on
14096 an argument-by-argument basis. In other words, consider the
14097 following pathological case:
14099 template <int I, int J, int K>
14102 template <int I, int J>
14103 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
14105 template <int I, int J, int K>
14106 void f(S<I, J, K>, S<I, I, I>);
14115 Now, by the time we consider the unification involving `s2', we
14116 already know that we must have `f<0, 0, 0>'. But, even though
14117 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
14118 because there are two ways to unify base classes of S<0, 1, 2>
14119 with S<I, I, I>. If we kept the already deduced knowledge, we
14120 would reject the possibility I=1. */
14121 copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs));
14123 /* If unification failed, we're done. */
14124 if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm),
14125 CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE))
14131 /* Given a template type PARM and a class type ARG, find the unique
14132 base type in ARG that is an instance of PARM. We do not examine
14133 ARG itself; only its base-classes. If there is not exactly one
14134 appropriate base class, return NULL_TREE. PARM may be the type of
14135 a partial specialization, as well as a plain template type. Used
14139 get_template_base (tree tparms, tree targs, tree parm, tree arg)
14141 tree rval = NULL_TREE;
14144 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg)));
14146 binfo = TYPE_BINFO (complete_type (arg));
14148 /* The type could not be completed. */
14151 /* Walk in inheritance graph order. The search order is not
14152 important, and this avoids multiple walks of virtual bases. */
14153 for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo))
14155 tree r = try_class_unification (tparms, targs, parm, BINFO_TYPE (binfo));
14159 /* If there is more than one satisfactory baseclass, then:
14163 If they yield more than one possible deduced A, the type
14167 if (rval && !same_type_p (r, rval))
14177 /* Returns the level of DECL, which declares a template parameter. */
14180 template_decl_level (tree decl)
14182 switch (TREE_CODE (decl))
14185 case TEMPLATE_DECL:
14186 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl));
14189 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
14192 gcc_unreachable ();
14197 /* Decide whether ARG can be unified with PARM, considering only the
14198 cv-qualifiers of each type, given STRICT as documented for unify.
14199 Returns nonzero iff the unification is OK on that basis. */
14202 check_cv_quals_for_unify (int strict, tree arg, tree parm)
14204 int arg_quals = cp_type_quals (arg);
14205 int parm_quals = cp_type_quals (parm);
14207 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
14208 && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
14210 /* Although a CVR qualifier is ignored when being applied to a
14211 substituted template parameter ([8.3.2]/1 for example), that
14212 does not allow us to unify "const T" with "int&" because both
14213 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
14214 It is ok when we're allowing additional CV qualifiers
14215 at the outer level [14.8.2.1]/3,1st bullet. */
14216 if ((TREE_CODE (arg) == REFERENCE_TYPE
14217 || TREE_CODE (arg) == FUNCTION_TYPE
14218 || TREE_CODE (arg) == METHOD_TYPE)
14219 && (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)))
14222 if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
14223 && (parm_quals & TYPE_QUAL_RESTRICT))
14227 if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
14228 && (arg_quals & parm_quals) != parm_quals)
14231 if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL))
14232 && (parm_quals & arg_quals) != arg_quals)
14238 /* Determines the LEVEL and INDEX for the template parameter PARM. */
14240 template_parm_level_and_index (tree parm, int* level, int* index)
14242 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
14243 || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
14244 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
14246 *index = TEMPLATE_TYPE_IDX (parm);
14247 *level = TEMPLATE_TYPE_LEVEL (parm);
14251 *index = TEMPLATE_PARM_IDX (parm);
14252 *level = TEMPLATE_PARM_LEVEL (parm);
14256 /* Unifies the remaining arguments in PACKED_ARGS with the pack
14257 expansion at the end of PACKED_PARMS. Returns 0 if the type
14258 deduction succeeds, 1 otherwise. STRICT is the same as in
14259 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
14260 call argument list. We'll need to adjust the arguments to make them
14261 types. SUBR tells us if this is from a recursive call to
14262 type_unification_real. */
14264 unify_pack_expansion (tree tparms, tree targs, tree packed_parms,
14265 tree packed_args, int strict, bool call_args_p,
14269 = TREE_VEC_ELT (packed_parms, TREE_VEC_LENGTH (packed_parms) - 1);
14270 tree pattern = PACK_EXPANSION_PATTERN (parm);
14271 tree pack, packs = NULL_TREE;
14272 int i, start = TREE_VEC_LENGTH (packed_parms) - 1;
14273 int len = TREE_VEC_LENGTH (packed_args);
14275 /* Determine the parameter packs we will be deducing from the
14276 pattern, and record their current deductions. */
14277 for (pack = PACK_EXPANSION_PARAMETER_PACKS (parm);
14278 pack; pack = TREE_CHAIN (pack))
14280 tree parm_pack = TREE_VALUE (pack);
14283 /* Determine the index and level of this parameter pack. */
14284 template_parm_level_and_index (parm_pack, &level, &idx);
14286 /* Keep track of the parameter packs and their corresponding
14288 packs = tree_cons (parm_pack, TMPL_ARG (targs, level, idx), packs);
14289 TREE_TYPE (packs) = make_tree_vec (len - start);
14292 /* Loop through all of the arguments that have not yet been
14293 unified and unify each with the pattern. */
14294 for (i = start; i < len; i++)
14296 tree parm = pattern;
14298 /* For each parameter pack, clear out the deduced value so that
14299 we can deduce it again. */
14300 for (pack = packs; pack; pack = TREE_CHAIN (pack))
14303 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
14305 TMPL_ARG (targs, level, idx) = NULL_TREE;
14308 /* Unify the pattern with the current argument. */
14310 tree arg = TREE_VEC_ELT (packed_args, i);
14311 tree arg_expr = NULL_TREE;
14312 int arg_strict = strict;
14313 bool skip_arg_p = false;
14319 /* This mirrors what we do in type_unification_real. */
14323 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL
14324 | UNIFY_ALLOW_MORE_CV_QUAL
14325 | UNIFY_ALLOW_DERIVED);
14329 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
14333 sub_strict = UNIFY_ALLOW_NONE;
14337 gcc_unreachable ();
14342 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
14343 if (type_unknown_p (arg))
14345 /* [temp.deduct.type] A template-argument can be
14346 deduced from a pointer to function or pointer
14347 to member function argument if the set of
14348 overloaded functions does not contain function
14349 templates and at most one of a set of
14350 overloaded functions provides a unique
14353 if (resolve_overloaded_unification
14354 (tparms, targs, parm, arg,
14355 (unification_kind_t) strict,
14365 arg = unlowered_expr_type (arg);
14366 if (arg == error_mark_node)
14371 arg_strict = sub_strict;
14375 maybe_adjust_types_for_deduction ((unification_kind_t) strict,
14376 &parm, &arg, arg_expr);
14381 /* For deduction from an init-list we need the actual list. */
14382 if (arg_expr && BRACE_ENCLOSED_INITIALIZER_P (arg_expr))
14384 if (unify (tparms, targs, parm, arg, arg_strict))
14389 /* For each parameter pack, collect the deduced value. */
14390 for (pack = packs; pack; pack = TREE_CHAIN (pack))
14393 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
14395 TREE_VEC_ELT (TREE_TYPE (pack), i - start) =
14396 TMPL_ARG (targs, level, idx);
14400 /* Verify that the results of unification with the parameter packs
14401 produce results consistent with what we've seen before, and make
14402 the deduced argument packs available. */
14403 for (pack = packs; pack; pack = TREE_CHAIN (pack))
14405 tree old_pack = TREE_VALUE (pack);
14406 tree new_args = TREE_TYPE (pack);
14407 int i, len = TREE_VEC_LENGTH (new_args);
14409 bool nondeduced_p = false;
14411 /* By default keep the original deduced argument pack.
14412 If necessary, more specific code is going to update the
14413 resulting deduced argument later down in this function. */
14414 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
14415 TMPL_ARG (targs, level, idx) = old_pack;
14417 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
14418 actually deduce anything. */
14419 for (i = 0; i < len && !nondeduced_p; ++i)
14420 if (TREE_VEC_ELT (new_args, i) == NULL_TREE)
14421 nondeduced_p = true;
14425 if (old_pack && ARGUMENT_PACK_INCOMPLETE_P (old_pack))
14427 /* Prepend the explicit arguments onto NEW_ARGS. */
14428 tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
14429 tree old_args = new_args;
14430 int i, explicit_len = TREE_VEC_LENGTH (explicit_args);
14431 int len = explicit_len + TREE_VEC_LENGTH (old_args);
14433 /* Copy the explicit arguments. */
14434 new_args = make_tree_vec (len);
14435 for (i = 0; i < explicit_len; i++)
14436 TREE_VEC_ELT (new_args, i) = TREE_VEC_ELT (explicit_args, i);
14438 /* Copy the deduced arguments. */
14439 for (; i < len; i++)
14440 TREE_VEC_ELT (new_args, i) =
14441 TREE_VEC_ELT (old_args, i - explicit_len);
14447 /* Build the deduced *_ARGUMENT_PACK. */
14448 if (TREE_CODE (TREE_PURPOSE (pack)) == TEMPLATE_PARM_INDEX)
14450 result = make_node (NONTYPE_ARGUMENT_PACK);
14451 TREE_TYPE (result) =
14452 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack)));
14453 TREE_CONSTANT (result) = 1;
14456 result = cxx_make_type (TYPE_ARGUMENT_PACK);
14458 SET_ARGUMENT_PACK_ARGS (result, new_args);
14460 /* Note the deduced argument packs for this parameter
14462 TMPL_ARG (targs, level, idx) = result;
14464 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack)
14465 && (ARGUMENT_PACK_ARGS (old_pack)
14466 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack)))
14468 /* We only had the explicitly-provided arguments before, but
14469 now we have a complete set of arguments. */
14470 tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
14472 SET_ARGUMENT_PACK_ARGS (old_pack, new_args);
14473 ARGUMENT_PACK_INCOMPLETE_P (old_pack) = 1;
14474 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack) = explicit_args;
14476 else if (!comp_template_args (ARGUMENT_PACK_ARGS (old_pack),
14478 /* Inconsistent unification of this parameter pack. */
14485 /* Deduce the value of template parameters. TPARMS is the (innermost)
14486 set of template parameters to a template. TARGS is the bindings
14487 for those template parameters, as determined thus far; TARGS may
14488 include template arguments for outer levels of template parameters
14489 as well. PARM is a parameter to a template function, or a
14490 subcomponent of that parameter; ARG is the corresponding argument.
14491 This function attempts to match PARM with ARG in a manner
14492 consistent with the existing assignments in TARGS. If more values
14493 are deduced, then TARGS is updated.
14495 Returns 0 if the type deduction succeeds, 1 otherwise. The
14496 parameter STRICT is a bitwise or of the following flags:
14499 Require an exact match between PARM and ARG.
14500 UNIFY_ALLOW_MORE_CV_QUAL:
14501 Allow the deduced ARG to be more cv-qualified (by qualification
14502 conversion) than ARG.
14503 UNIFY_ALLOW_LESS_CV_QUAL:
14504 Allow the deduced ARG to be less cv-qualified than ARG.
14505 UNIFY_ALLOW_DERIVED:
14506 Allow the deduced ARG to be a template base class of ARG,
14507 or a pointer to a template base class of the type pointed to by
14509 UNIFY_ALLOW_INTEGER:
14510 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
14511 case for more information.
14512 UNIFY_ALLOW_OUTER_LEVEL:
14513 This is the outermost level of a deduction. Used to determine validity
14514 of qualification conversions. A valid qualification conversion must
14515 have const qualified pointers leading up to the inner type which
14516 requires additional CV quals, except at the outer level, where const
14517 is not required [conv.qual]. It would be normal to set this flag in
14518 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
14519 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
14520 This is the outermost level of a deduction, and PARM can be more CV
14521 qualified at this point.
14522 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
14523 This is the outermost level of a deduction, and PARM can be less CV
14524 qualified at this point. */
14527 unify (tree tparms, tree targs, tree parm, tree arg, int strict)
14532 int strict_in = strict;
14534 /* I don't think this will do the right thing with respect to types.
14535 But the only case I've seen it in so far has been array bounds, where
14536 signedness is the only information lost, and I think that will be
14538 while (TREE_CODE (parm) == NOP_EXPR)
14539 parm = TREE_OPERAND (parm, 0);
14541 if (arg == error_mark_node)
14543 if (arg == unknown_type_node
14544 || arg == init_list_type_node)
14545 /* We can't deduce anything from this, but we might get all the
14546 template args from other function args. */
14549 /* If PARM uses template parameters, then we can't bail out here,
14550 even if ARG == PARM, since we won't record unifications for the
14551 template parameters. We might need them if we're trying to
14552 figure out which of two things is more specialized. */
14553 if (arg == parm && !uses_template_parms (parm))
14556 /* Handle init lists early, so the rest of the function can assume
14557 we're dealing with a type. */
14558 if (BRACE_ENCLOSED_INITIALIZER_P (arg))
14562 tree orig_parm = parm;
14564 /* Replace T with std::initializer_list<T> for deduction. */
14565 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
14566 && flag_deduce_init_list)
14567 parm = listify (parm);
14569 if (!is_std_init_list (parm))
14570 /* We can only deduce from an initializer list argument if the
14571 parameter is std::initializer_list; otherwise this is a
14572 non-deduced context. */
14575 elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm), 0);
14577 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg), i, elt)
14579 int elt_strict = strict;
14581 if (elt == error_mark_node)
14584 if (!BRACE_ENCLOSED_INITIALIZER_P (elt))
14586 tree type = TREE_TYPE (elt);
14587 /* It should only be possible to get here for a call. */
14588 gcc_assert (elt_strict & UNIFY_ALLOW_OUTER_LEVEL);
14589 elt_strict |= maybe_adjust_types_for_deduction
14590 (DEDUCE_CALL, &elttype, &type, elt);
14594 if (unify (tparms, targs, elttype, elt, elt_strict))
14598 /* If the std::initializer_list<T> deduction worked, replace the
14599 deduced A with std::initializer_list<A>. */
14600 if (orig_parm != parm)
14602 idx = TEMPLATE_TYPE_IDX (orig_parm);
14603 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
14604 targ = listify (targ);
14605 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = targ;
14610 /* Immediately reject some pairs that won't unify because of
14611 cv-qualification mismatches. */
14612 if (TREE_CODE (arg) == TREE_CODE (parm)
14614 /* It is the elements of the array which hold the cv quals of an array
14615 type, and the elements might be template type parms. We'll check
14616 when we recurse. */
14617 && TREE_CODE (arg) != ARRAY_TYPE
14618 /* We check the cv-qualifiers when unifying with template type
14619 parameters below. We want to allow ARG `const T' to unify with
14620 PARM `T' for example, when computing which of two templates
14621 is more specialized, for example. */
14622 && TREE_CODE (arg) != TEMPLATE_TYPE_PARM
14623 && !check_cv_quals_for_unify (strict_in, arg, parm))
14626 if (!(strict & UNIFY_ALLOW_OUTER_LEVEL)
14627 && TYPE_P (parm) && !CP_TYPE_CONST_P (parm))
14628 strict &= ~UNIFY_ALLOW_MORE_CV_QUAL;
14629 strict &= ~UNIFY_ALLOW_OUTER_LEVEL;
14630 strict &= ~UNIFY_ALLOW_DERIVED;
14631 strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
14632 strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL;
14634 switch (TREE_CODE (parm))
14636 case TYPENAME_TYPE:
14638 case UNBOUND_CLASS_TEMPLATE:
14639 /* In a type which contains a nested-name-specifier, template
14640 argument values cannot be deduced for template parameters used
14641 within the nested-name-specifier. */
14644 case TEMPLATE_TYPE_PARM:
14645 case TEMPLATE_TEMPLATE_PARM:
14646 case BOUND_TEMPLATE_TEMPLATE_PARM:
14647 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
14648 if (tparm == error_mark_node)
14651 if (TEMPLATE_TYPE_LEVEL (parm)
14652 != template_decl_level (tparm))
14653 /* The PARM is not one we're trying to unify. Just check
14654 to see if it matches ARG. */
14655 return (TREE_CODE (arg) == TREE_CODE (parm)
14656 && same_type_p (parm, arg)) ? 0 : 1;
14657 idx = TEMPLATE_TYPE_IDX (parm);
14658 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
14659 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx));
14661 /* Check for mixed types and values. */
14662 if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
14663 && TREE_CODE (tparm) != TYPE_DECL)
14664 || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
14665 && TREE_CODE (tparm) != TEMPLATE_DECL))
14668 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
14670 /* ARG must be constructed from a template class or a template
14671 template parameter. */
14672 if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM
14673 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg))
14677 tree parmvec = TYPE_TI_ARGS (parm);
14678 tree argvec = INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg));
14680 = DECL_INNERMOST_TEMPLATE_PARMS
14681 (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm));
14683 int parm_variadic_p = 0;
14685 /* The resolution to DR150 makes clear that default
14686 arguments for an N-argument may not be used to bind T
14687 to a template template parameter with fewer than N
14688 parameters. It is not safe to permit the binding of
14689 default arguments as an extension, as that may change
14690 the meaning of a conforming program. Consider:
14692 struct Dense { static const unsigned int dim = 1; };
14694 template <template <typename> class View,
14696 void operator+(float, View<Block> const&);
14698 template <typename Block,
14699 unsigned int Dim = Block::dim>
14700 struct Lvalue_proxy { operator float() const; };
14704 Lvalue_proxy<Dense> p;
14709 Here, if Lvalue_proxy is permitted to bind to View, then
14710 the global operator+ will be used; if they are not, the
14711 Lvalue_proxy will be converted to float. */
14712 if (coerce_template_parms (parm_parms,
14714 TYPE_TI_TEMPLATE (parm),
14716 /*require_all_args=*/true,
14717 /*use_default_args=*/false)
14718 == error_mark_node)
14721 /* Deduce arguments T, i from TT<T> or TT<i>.
14722 We check each element of PARMVEC and ARGVEC individually
14723 rather than the whole TREE_VEC since they can have
14724 different number of elements. */
14726 parmvec = expand_template_argument_pack (parmvec);
14727 argvec = expand_template_argument_pack (argvec);
14729 len = TREE_VEC_LENGTH (parmvec);
14731 /* Check if the parameters end in a pack, making them
14734 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec, len - 1)))
14735 parm_variadic_p = 1;
14737 if (TREE_VEC_LENGTH (argvec) < len - parm_variadic_p)
14740 for (i = 0; i < len - parm_variadic_p; ++i)
14742 if (unify (tparms, targs,
14743 TREE_VEC_ELT (parmvec, i),
14744 TREE_VEC_ELT (argvec, i),
14749 if (parm_variadic_p
14750 && unify_pack_expansion (tparms, targs,
14753 /*call_args_p=*/false,
14757 arg = TYPE_TI_TEMPLATE (arg);
14759 /* Fall through to deduce template name. */
14762 if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
14763 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
14765 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
14767 /* Simple cases: Value already set, does match or doesn't. */
14768 if (targ != NULL_TREE && template_args_equal (targ, arg))
14775 /* If PARM is `const T' and ARG is only `int', we don't have
14776 a match unless we are allowing additional qualification.
14777 If ARG is `const int' and PARM is just `T' that's OK;
14778 that binds `const int' to `T'. */
14779 if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL,
14783 /* Consider the case where ARG is `const volatile int' and
14784 PARM is `const T'. Then, T should be `volatile int'. */
14785 arg = cp_build_qualified_type_real
14786 (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
14787 if (arg == error_mark_node)
14790 /* Simple cases: Value already set, does match or doesn't. */
14791 if (targ != NULL_TREE && same_type_p (targ, arg))
14796 /* Make sure that ARG is not a variable-sized array. (Note
14797 that were talking about variable-sized arrays (like
14798 `int[n]'), rather than arrays of unknown size (like
14799 `int[]').) We'll get very confused by such a type since
14800 the bound of the array will not be computable in an
14801 instantiation. Besides, such types are not allowed in
14802 ISO C++, so we can do as we please here. */
14803 if (variably_modified_type_p (arg, NULL_TREE))
14806 /* Strip typedefs as in convert_template_argument. */
14807 arg = strip_typedefs (arg);
14810 /* If ARG is a parameter pack or an expansion, we cannot unify
14811 against it unless PARM is also a parameter pack. */
14812 if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
14813 && !template_parameter_pack_p (parm))
14816 /* If the argument deduction results is a METHOD_TYPE,
14817 then there is a problem.
14818 METHOD_TYPE doesn't map to any real C++ type the result of
14819 the deduction can not be of that type. */
14820 if (TREE_CODE (arg) == METHOD_TYPE)
14823 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
14826 case TEMPLATE_PARM_INDEX:
14827 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
14828 if (tparm == error_mark_node)
14831 if (TEMPLATE_PARM_LEVEL (parm)
14832 != template_decl_level (tparm))
14833 /* The PARM is not one we're trying to unify. Just check
14834 to see if it matches ARG. */
14835 return !(TREE_CODE (arg) == TREE_CODE (parm)
14836 && cp_tree_equal (parm, arg));
14838 idx = TEMPLATE_PARM_IDX (parm);
14839 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
14842 return !cp_tree_equal (targ, arg);
14844 /* [temp.deduct.type] If, in the declaration of a function template
14845 with a non-type template-parameter, the non-type
14846 template-parameter is used in an expression in the function
14847 parameter-list and, if the corresponding template-argument is
14848 deduced, the template-argument type shall match the type of the
14849 template-parameter exactly, except that a template-argument
14850 deduced from an array bound may be of any integral type.
14851 The non-type parameter might use already deduced type parameters. */
14852 tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE);
14853 if (!TREE_TYPE (arg))
14854 /* Template-parameter dependent expression. Just accept it for now.
14855 It will later be processed in convert_template_argument. */
14857 else if (same_type_p (TREE_TYPE (arg), tparm))
14859 else if ((strict & UNIFY_ALLOW_INTEGER)
14860 && (TREE_CODE (tparm) == INTEGER_TYPE
14861 || TREE_CODE (tparm) == BOOLEAN_TYPE))
14862 /* Convert the ARG to the type of PARM; the deduced non-type
14863 template argument must exactly match the types of the
14864 corresponding parameter. */
14865 arg = fold (build_nop (tparm, arg));
14866 else if (uses_template_parms (tparm))
14867 /* We haven't deduced the type of this parameter yet. Try again
14873 /* If ARG is a parameter pack or an expansion, we cannot unify
14874 against it unless PARM is also a parameter pack. */
14875 if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
14876 && !TEMPLATE_PARM_PARAMETER_PACK (parm))
14879 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
14884 /* A pointer-to-member constant can be unified only with
14885 another constant. */
14886 if (TREE_CODE (arg) != PTRMEM_CST)
14889 /* Just unify the class member. It would be useless (and possibly
14890 wrong, depending on the strict flags) to unify also
14891 PTRMEM_CST_CLASS, because we want to be sure that both parm and
14892 arg refer to the same variable, even if through different
14893 classes. For instance:
14895 struct A { int x; };
14898 Unification of &A::x and &B::x must succeed. */
14899 return unify (tparms, targs, PTRMEM_CST_MEMBER (parm),
14900 PTRMEM_CST_MEMBER (arg), strict);
14905 if (TREE_CODE (arg) != POINTER_TYPE)
14908 /* [temp.deduct.call]
14910 A can be another pointer or pointer to member type that can
14911 be converted to the deduced A via a qualification
14912 conversion (_conv.qual_).
14914 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
14915 This will allow for additional cv-qualification of the
14916 pointed-to types if appropriate. */
14918 if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
14919 /* The derived-to-base conversion only persists through one
14920 level of pointers. */
14921 strict |= (strict_in & UNIFY_ALLOW_DERIVED);
14923 return unify (tparms, targs, TREE_TYPE (parm),
14924 TREE_TYPE (arg), strict);
14927 case REFERENCE_TYPE:
14928 if (TREE_CODE (arg) != REFERENCE_TYPE)
14930 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
14931 strict & UNIFY_ALLOW_MORE_CV_QUAL);
14934 if (TREE_CODE (arg) != ARRAY_TYPE)
14936 if ((TYPE_DOMAIN (parm) == NULL_TREE)
14937 != (TYPE_DOMAIN (arg) == NULL_TREE))
14939 if (TYPE_DOMAIN (parm) != NULL_TREE)
14946 /* Our representation of array types uses "N - 1" as the
14947 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
14948 not an integer constant. We cannot unify arbitrarily
14949 complex expressions, so we eliminate the MINUS_EXPRs
14951 parm_max = TYPE_MAX_VALUE (TYPE_DOMAIN (parm));
14952 parm_cst = TREE_CODE (parm_max) == INTEGER_CST;
14955 gcc_assert (TREE_CODE (parm_max) == MINUS_EXPR);
14956 parm_max = TREE_OPERAND (parm_max, 0);
14958 arg_max = TYPE_MAX_VALUE (TYPE_DOMAIN (arg));
14959 arg_cst = TREE_CODE (arg_max) == INTEGER_CST;
14962 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
14963 trying to unify the type of a variable with the type
14964 of a template parameter. For example:
14966 template <unsigned int N>
14967 void f (char (&) [N]);
14974 Here, the type of the ARG will be "int [g(i)]", and
14975 may be a SAVE_EXPR, etc. */
14976 if (TREE_CODE (arg_max) != MINUS_EXPR)
14978 arg_max = TREE_OPERAND (arg_max, 0);
14981 /* If only one of the bounds used a MINUS_EXPR, compensate
14982 by adding one to the other bound. */
14983 if (parm_cst && !arg_cst)
14984 parm_max = fold_build2_loc (input_location, PLUS_EXPR,
14988 else if (arg_cst && !parm_cst)
14989 arg_max = fold_build2_loc (input_location, PLUS_EXPR,
14994 if (unify (tparms, targs, parm_max, arg_max, UNIFY_ALLOW_INTEGER))
14997 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
14998 strict & UNIFY_ALLOW_MORE_CV_QUAL);
15005 case ENUMERAL_TYPE:
15007 if (TREE_CODE (arg) != TREE_CODE (parm))
15010 /* We have already checked cv-qualification at the top of the
15012 if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
15015 /* As far as unification is concerned, this wins. Later checks
15016 will invalidate it if necessary. */
15019 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
15020 /* Type INTEGER_CST can come from ordinary constant template args. */
15022 while (TREE_CODE (arg) == NOP_EXPR)
15023 arg = TREE_OPERAND (arg, 0);
15025 if (TREE_CODE (arg) != INTEGER_CST)
15027 return !tree_int_cst_equal (parm, arg);
15032 if (TREE_CODE (arg) != TREE_VEC)
15034 if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
15036 for (i = 0; i < TREE_VEC_LENGTH (parm); ++i)
15037 if (unify (tparms, targs,
15038 TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
15046 if (TREE_CODE (arg) != TREE_CODE (parm))
15049 if (TYPE_PTRMEMFUNC_P (parm))
15051 if (!TYPE_PTRMEMFUNC_P (arg))
15054 return unify (tparms, targs,
15055 TYPE_PTRMEMFUNC_FN_TYPE (parm),
15056 TYPE_PTRMEMFUNC_FN_TYPE (arg),
15060 if (CLASSTYPE_TEMPLATE_INFO (parm))
15062 tree t = NULL_TREE;
15064 if (strict_in & UNIFY_ALLOW_DERIVED)
15066 /* First, we try to unify the PARM and ARG directly. */
15067 t = try_class_unification (tparms, targs,
15072 /* Fallback to the special case allowed in
15073 [temp.deduct.call]:
15075 If P is a class, and P has the form
15076 template-id, then A can be a derived class of
15077 the deduced A. Likewise, if P is a pointer to
15078 a class of the form template-id, A can be a
15079 pointer to a derived class pointed to by the
15081 t = get_template_base (tparms, targs, parm, arg);
15087 else if (CLASSTYPE_TEMPLATE_INFO (arg)
15088 && (CLASSTYPE_TI_TEMPLATE (parm)
15089 == CLASSTYPE_TI_TEMPLATE (arg)))
15090 /* Perhaps PARM is something like S<U> and ARG is S<int>.
15091 Then, we should unify `int' and `U'. */
15094 /* There's no chance of unification succeeding. */
15097 return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
15098 CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE);
15100 else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
15105 case FUNCTION_TYPE:
15107 unsigned int nargs;
15112 if (TREE_CODE (arg) != TREE_CODE (parm))
15115 /* CV qualifications for methods can never be deduced, they must
15116 match exactly. We need to check them explicitly here,
15117 because type_unification_real treats them as any other
15118 cv-qualified parameter. */
15119 if (TREE_CODE (parm) == METHOD_TYPE
15120 && (!check_cv_quals_for_unify
15122 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (arg))),
15123 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (parm))))))
15126 if (unify (tparms, targs, TREE_TYPE (parm),
15127 TREE_TYPE (arg), UNIFY_ALLOW_NONE))
15130 nargs = list_length (TYPE_ARG_TYPES (arg));
15131 args = XALLOCAVEC (tree, nargs);
15132 for (a = TYPE_ARG_TYPES (arg), i = 0;
15133 a != NULL_TREE && a != void_list_node;
15134 a = TREE_CHAIN (a), ++i)
15135 args[i] = TREE_VALUE (a);
15138 return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
15139 args, nargs, 1, DEDUCE_EXACT,
15144 /* Unify a pointer to member with a pointer to member function, which
15145 deduces the type of the member as a function type. */
15146 if (TYPE_PTRMEMFUNC_P (arg))
15151 /* Check top-level cv qualifiers */
15152 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE, arg, parm))
15155 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
15156 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg), UNIFY_ALLOW_NONE))
15159 /* Determine the type of the function we are unifying against. */
15160 method_type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (arg));
15162 build_function_type (TREE_TYPE (method_type),
15163 TREE_CHAIN (TYPE_ARG_TYPES (method_type)));
15165 /* Extract the cv-qualifiers of the member function from the
15166 implicit object parameter and place them on the function
15167 type to be restored later. */
15168 fntype = apply_memfn_quals (fntype, type_memfn_quals (method_type));
15169 return unify (tparms, targs, TREE_TYPE (parm), fntype, strict);
15172 if (TREE_CODE (arg) != OFFSET_TYPE)
15174 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
15175 TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE))
15177 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
15181 if (DECL_TEMPLATE_PARM_P (parm))
15182 return unify (tparms, targs, DECL_INITIAL (parm), arg, strict);
15183 if (arg != integral_constant_value (parm))
15188 case TEMPLATE_DECL:
15189 /* Matched cases are handled by the ARG == PARM test above. */
15193 /* A non-type template parameter that is a variable should be a
15194 an integral constant, in which case, it whould have been
15195 folded into its (constant) value. So we should not be getting
15196 a variable here. */
15197 gcc_unreachable ();
15199 case TYPE_ARGUMENT_PACK:
15200 case NONTYPE_ARGUMENT_PACK:
15202 tree packed_parms = ARGUMENT_PACK_ARGS (parm);
15203 tree packed_args = ARGUMENT_PACK_ARGS (arg);
15204 int i, len = TREE_VEC_LENGTH (packed_parms);
15205 int argslen = TREE_VEC_LENGTH (packed_args);
15206 int parm_variadic_p = 0;
15208 for (i = 0; i < len; ++i)
15210 if (PACK_EXPANSION_P (TREE_VEC_ELT (packed_parms, i)))
15213 /* We can unify against something with a trailing
15215 parm_variadic_p = 1;
15217 /* Since there is something following the pack
15218 expansion, we cannot unify this template argument
15225 /* If we don't have enough arguments to satisfy the parameters
15226 (not counting the pack expression at the end), or we have
15227 too many arguments for a parameter list that doesn't end in
15228 a pack expression, we can't unify. */
15229 if (argslen < (len - parm_variadic_p)
15230 || (argslen > len && !parm_variadic_p))
15233 /* Unify all of the parameters that precede the (optional)
15234 pack expression. */
15235 for (i = 0; i < len - parm_variadic_p; ++i)
15237 if (unify (tparms, targs, TREE_VEC_ELT (packed_parms, i),
15238 TREE_VEC_ELT (packed_args, i), strict))
15242 if (parm_variadic_p)
15243 return unify_pack_expansion (tparms, targs,
15244 packed_parms, packed_args,
15245 strict, /*call_args_p=*/false,
15253 case DECLTYPE_TYPE:
15254 /* Cannot deduce anything from TYPEOF_TYPE or DECLTYPE_TYPE
15259 /* Unification fails if we hit an error node. */
15263 gcc_assert (EXPR_P (parm));
15265 /* We must be looking at an expression. This can happen with
15269 void foo(S<I>, S<I + 2>);
15271 This is a "nondeduced context":
15275 The nondeduced contexts are:
15277 --A type that is a template-id in which one or more of
15278 the template-arguments is an expression that references
15279 a template-parameter.
15281 In these cases, we assume deduction succeeded, but don't
15282 actually infer any unifications. */
15284 if (!uses_template_parms (parm)
15285 && !template_args_equal (parm, arg))
15292 /* Note that DECL can be defined in this translation unit, if
15296 mark_definable (tree decl)
15299 DECL_NOT_REALLY_EXTERN (decl) = 1;
15300 FOR_EACH_CLONE (clone, decl)
15301 DECL_NOT_REALLY_EXTERN (clone) = 1;
15304 /* Called if RESULT is explicitly instantiated, or is a member of an
15305 explicitly instantiated class. */
15308 mark_decl_instantiated (tree result, int extern_p)
15310 SET_DECL_EXPLICIT_INSTANTIATION (result);
15312 /* If this entity has already been written out, it's too late to
15313 make any modifications. */
15314 if (TREE_ASM_WRITTEN (result))
15317 if (TREE_CODE (result) != FUNCTION_DECL)
15318 /* The TREE_PUBLIC flag for function declarations will have been
15319 set correctly by tsubst. */
15320 TREE_PUBLIC (result) = 1;
15322 /* This might have been set by an earlier implicit instantiation. */
15323 DECL_COMDAT (result) = 0;
15326 DECL_NOT_REALLY_EXTERN (result) = 0;
15329 mark_definable (result);
15330 /* Always make artificials weak. */
15331 if (DECL_ARTIFICIAL (result) && flag_weak)
15332 comdat_linkage (result);
15333 /* For WIN32 we also want to put explicit instantiations in
15334 linkonce sections. */
15335 else if (TREE_PUBLIC (result))
15336 maybe_make_one_only (result);
15339 /* If EXTERN_P, then this function will not be emitted -- unless
15340 followed by an explicit instantiation, at which point its linkage
15341 will be adjusted. If !EXTERN_P, then this function will be
15342 emitted here. In neither circumstance do we want
15343 import_export_decl to adjust the linkage. */
15344 DECL_INTERFACE_KNOWN (result) = 1;
15347 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
15348 important template arguments. If any are missing, we check whether
15349 they're important by using error_mark_node for substituting into any
15350 args that were used for partial ordering (the ones between ARGS and END)
15351 and seeing if it bubbles up. */
15354 check_undeduced_parms (tree targs, tree args, tree end)
15356 bool found = false;
15358 for (i = TREE_VEC_LENGTH (targs) - 1; i >= 0; --i)
15359 if (TREE_VEC_ELT (targs, i) == NULL_TREE)
15362 TREE_VEC_ELT (targs, i) = error_mark_node;
15366 for (; args != end; args = TREE_CHAIN (args))
15368 tree substed = tsubst (TREE_VALUE (args), targs, tf_none, NULL_TREE);
15369 if (substed == error_mark_node)
15376 /* Given two function templates PAT1 and PAT2, return:
15378 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
15379 -1 if PAT2 is more specialized than PAT1.
15380 0 if neither is more specialized.
15382 LEN indicates the number of parameters we should consider
15383 (defaulted parameters should not be considered).
15385 The 1998 std underspecified function template partial ordering, and
15386 DR214 addresses the issue. We take pairs of arguments, one from
15387 each of the templates, and deduce them against each other. One of
15388 the templates will be more specialized if all the *other*
15389 template's arguments deduce against its arguments and at least one
15390 of its arguments *does* *not* deduce against the other template's
15391 corresponding argument. Deduction is done as for class templates.
15392 The arguments used in deduction have reference and top level cv
15393 qualifiers removed. Iff both arguments were originally reference
15394 types *and* deduction succeeds in both directions, the template
15395 with the more cv-qualified argument wins for that pairing (if
15396 neither is more cv-qualified, they both are equal). Unlike regular
15397 deduction, after all the arguments have been deduced in this way,
15398 we do *not* verify the deduced template argument values can be
15399 substituted into non-deduced contexts.
15401 The logic can be a bit confusing here, because we look at deduce1 and
15402 targs1 to see if pat2 is at least as specialized, and vice versa; if we
15403 can find template arguments for pat1 to make arg1 look like arg2, that
15404 means that arg2 is at least as specialized as arg1. */
15407 more_specialized_fn (tree pat1, tree pat2, int len)
15409 tree decl1 = DECL_TEMPLATE_RESULT (pat1);
15410 tree decl2 = DECL_TEMPLATE_RESULT (pat2);
15411 tree targs1 = make_tree_vec (DECL_NTPARMS (pat1));
15412 tree targs2 = make_tree_vec (DECL_NTPARMS (pat2));
15413 tree tparms1 = DECL_INNERMOST_TEMPLATE_PARMS (pat1);
15414 tree tparms2 = DECL_INNERMOST_TEMPLATE_PARMS (pat2);
15415 tree args1 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
15416 tree args2 = TYPE_ARG_TYPES (TREE_TYPE (decl2));
15417 tree origs1, origs2;
15418 bool lose1 = false;
15419 bool lose2 = false;
15421 /* Remove the this parameter from non-static member functions. If
15422 one is a non-static member function and the other is not a static
15423 member function, remove the first parameter from that function
15424 also. This situation occurs for operator functions where we
15425 locate both a member function (with this pointer) and non-member
15426 operator (with explicit first operand). */
15427 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1))
15429 len--; /* LEN is the number of significant arguments for DECL1 */
15430 args1 = TREE_CHAIN (args1);
15431 if (!DECL_STATIC_FUNCTION_P (decl2))
15432 args2 = TREE_CHAIN (args2);
15434 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2))
15436 args2 = TREE_CHAIN (args2);
15437 if (!DECL_STATIC_FUNCTION_P (decl1))
15440 args1 = TREE_CHAIN (args1);
15444 /* If only one is a conversion operator, they are unordered. */
15445 if (DECL_CONV_FN_P (decl1) != DECL_CONV_FN_P (decl2))
15448 /* Consider the return type for a conversion function */
15449 if (DECL_CONV_FN_P (decl1))
15451 args1 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl1)), args1);
15452 args2 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl2)), args2);
15456 processing_template_decl++;
15462 /* Stop when an ellipsis is seen. */
15463 && args1 != NULL_TREE && args2 != NULL_TREE)
15465 tree arg1 = TREE_VALUE (args1);
15466 tree arg2 = TREE_VALUE (args2);
15467 int deduce1, deduce2;
15471 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
15472 && TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
15474 /* When both arguments are pack expansions, we need only
15475 unify the patterns themselves. */
15476 arg1 = PACK_EXPANSION_PATTERN (arg1);
15477 arg2 = PACK_EXPANSION_PATTERN (arg2);
15479 /* This is the last comparison we need to do. */
15483 if (TREE_CODE (arg1) == REFERENCE_TYPE)
15485 arg1 = TREE_TYPE (arg1);
15486 quals1 = cp_type_quals (arg1);
15489 if (TREE_CODE (arg2) == REFERENCE_TYPE)
15491 arg2 = TREE_TYPE (arg2);
15492 quals2 = cp_type_quals (arg2);
15495 if ((quals1 < 0) != (quals2 < 0))
15497 /* Only of the args is a reference, see if we should apply
15498 array/function pointer decay to it. This is not part of
15499 DR214, but is, IMHO, consistent with the deduction rules
15500 for the function call itself, and with our earlier
15501 implementation of the underspecified partial ordering
15502 rules. (nathan). */
15505 switch (TREE_CODE (arg1))
15508 arg1 = TREE_TYPE (arg1);
15510 case FUNCTION_TYPE:
15511 arg1 = build_pointer_type (arg1);
15520 switch (TREE_CODE (arg2))
15523 arg2 = TREE_TYPE (arg2);
15525 case FUNCTION_TYPE:
15526 arg2 = build_pointer_type (arg2);
15535 arg1 = TYPE_MAIN_VARIANT (arg1);
15536 arg2 = TYPE_MAIN_VARIANT (arg2);
15538 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION)
15540 int i, len2 = list_length (args2);
15541 tree parmvec = make_tree_vec (1);
15542 tree argvec = make_tree_vec (len2);
15545 /* Setup the parameter vector, which contains only ARG1. */
15546 TREE_VEC_ELT (parmvec, 0) = arg1;
15548 /* Setup the argument vector, which contains the remaining
15550 for (i = 0; i < len2; i++, ta = TREE_CHAIN (ta))
15551 TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
15553 deduce1 = !unify_pack_expansion (tparms1, targs1, parmvec,
15554 argvec, UNIFY_ALLOW_NONE,
15555 /*call_args_p=*/false,
15558 /* We cannot deduce in the other direction, because ARG1 is
15559 a pack expansion but ARG2 is not. */
15562 else if (TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
15564 int i, len1 = list_length (args1);
15565 tree parmvec = make_tree_vec (1);
15566 tree argvec = make_tree_vec (len1);
15569 /* Setup the parameter vector, which contains only ARG1. */
15570 TREE_VEC_ELT (parmvec, 0) = arg2;
15572 /* Setup the argument vector, which contains the remaining
15574 for (i = 0; i < len1; i++, ta = TREE_CHAIN (ta))
15575 TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
15577 deduce2 = !unify_pack_expansion (tparms2, targs2, parmvec,
15578 argvec, UNIFY_ALLOW_NONE,
15579 /*call_args_p=*/false,
15582 /* We cannot deduce in the other direction, because ARG2 is
15583 a pack expansion but ARG1 is not.*/
15589 /* The normal case, where neither argument is a pack
15591 deduce1 = !unify (tparms1, targs1, arg1, arg2, UNIFY_ALLOW_NONE);
15592 deduce2 = !unify (tparms2, targs2, arg2, arg1, UNIFY_ALLOW_NONE);
15595 /* If we couldn't deduce arguments for tparms1 to make arg1 match
15596 arg2, then arg2 is not as specialized as arg1. */
15602 /* "If, for a given type, deduction succeeds in both directions
15603 (i.e., the types are identical after the transformations above)
15604 and if the type from the argument template is more cv-qualified
15605 than the type from the parameter template (as described above)
15606 that type is considered to be more specialized than the other. If
15607 neither type is more cv-qualified than the other then neither type
15608 is more specialized than the other." */
15610 if (deduce1 && deduce2
15611 && quals1 != quals2 && quals1 >= 0 && quals2 >= 0)
15613 if ((quals1 & quals2) == quals2)
15615 if ((quals1 & quals2) == quals1)
15619 if (lose1 && lose2)
15620 /* We've failed to deduce something in either direction.
15621 These must be unordered. */
15624 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
15625 || TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
15626 /* We have already processed all of the arguments in our
15627 handing of the pack expansion type. */
15630 args1 = TREE_CHAIN (args1);
15631 args2 = TREE_CHAIN (args2);
15634 /* "In most cases, all template parameters must have values in order for
15635 deduction to succeed, but for partial ordering purposes a template
15636 parameter may remain without a value provided it is not used in the
15637 types being used for partial ordering."
15639 Thus, if we are missing any of the targs1 we need to substitute into
15640 origs1, then pat2 is not as specialized as pat1. This can happen when
15641 there is a nondeduced context. */
15642 if (!lose2 && check_undeduced_parms (targs1, origs1, args1))
15644 if (!lose1 && check_undeduced_parms (targs2, origs2, args2))
15647 processing_template_decl--;
15649 /* All things being equal, if the next argument is a pack expansion
15650 for one function but not for the other, prefer the
15651 non-variadic function. FIXME this is bogus; see c++/41958. */
15653 && args1 && TREE_VALUE (args1)
15654 && args2 && TREE_VALUE (args2))
15656 lose1 = TREE_CODE (TREE_VALUE (args1)) == TYPE_PACK_EXPANSION;
15657 lose2 = TREE_CODE (TREE_VALUE (args2)) == TYPE_PACK_EXPANSION;
15660 if (lose1 == lose2)
15668 /* Determine which of two partial specializations is more specialized.
15670 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
15671 to the first partial specialization. The TREE_VALUE is the
15672 innermost set of template parameters for the partial
15673 specialization. PAT2 is similar, but for the second template.
15675 Return 1 if the first partial specialization is more specialized;
15676 -1 if the second is more specialized; 0 if neither is more
15679 See [temp.class.order] for information about determining which of
15680 two templates is more specialized. */
15683 more_specialized_class (tree pat1, tree pat2)
15688 bool any_deductions = false;
15690 tmpl1 = TREE_TYPE (pat1);
15691 tmpl2 = TREE_TYPE (pat2);
15693 /* Just like what happens for functions, if we are ordering between
15694 different class template specializations, we may encounter dependent
15695 types in the arguments, and we need our dependency check functions
15696 to behave correctly. */
15697 ++processing_template_decl;
15698 targs = get_class_bindings (TREE_VALUE (pat1),
15699 CLASSTYPE_TI_ARGS (tmpl1),
15700 CLASSTYPE_TI_ARGS (tmpl2));
15704 any_deductions = true;
15707 targs = get_class_bindings (TREE_VALUE (pat2),
15708 CLASSTYPE_TI_ARGS (tmpl2),
15709 CLASSTYPE_TI_ARGS (tmpl1));
15713 any_deductions = true;
15715 --processing_template_decl;
15717 /* In the case of a tie where at least one of the class templates
15718 has a parameter pack at the end, the template with the most
15719 non-packed parameters wins. */
15722 && (template_args_variadic_p (TREE_PURPOSE (pat1))
15723 || template_args_variadic_p (TREE_PURPOSE (pat2))))
15725 tree args1 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1));
15726 tree args2 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2));
15727 int len1 = TREE_VEC_LENGTH (args1);
15728 int len2 = TREE_VEC_LENGTH (args2);
15730 /* We don't count the pack expansion at the end. */
15731 if (template_args_variadic_p (TREE_PURPOSE (pat1)))
15733 if (template_args_variadic_p (TREE_PURPOSE (pat2)))
15738 else if (len1 < len2)
15745 /* Return the template arguments that will produce the function signature
15746 DECL from the function template FN, with the explicit template
15747 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
15748 also match. Return NULL_TREE if no satisfactory arguments could be
15752 get_bindings (tree fn, tree decl, tree explicit_args, bool check_rettype)
15754 int ntparms = DECL_NTPARMS (fn);
15755 tree targs = make_tree_vec (ntparms);
15757 tree decl_arg_types;
15759 unsigned int nargs, ix;
15762 /* Substitute the explicit template arguments into the type of DECL.
15763 The call to fn_type_unification will handle substitution into the
15765 decl_type = TREE_TYPE (decl);
15766 if (explicit_args && uses_template_parms (decl_type))
15769 tree converted_args;
15771 if (DECL_TEMPLATE_INFO (decl))
15772 tmpl = DECL_TI_TEMPLATE (decl);
15774 /* We can get here for some invalid specializations. */
15778 = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
15779 explicit_args, NULL_TREE,
15781 /*require_all_args=*/false,
15782 /*use_default_args=*/false);
15783 if (converted_args == error_mark_node)
15786 decl_type = tsubst (decl_type, converted_args, tf_none, NULL_TREE);
15787 if (decl_type == error_mark_node)
15791 /* Never do unification on the 'this' parameter. */
15792 decl_arg_types = skip_artificial_parms_for (decl,
15793 TYPE_ARG_TYPES (decl_type));
15795 nargs = list_length (decl_arg_types);
15796 args = XALLOCAVEC (tree, nargs);
15797 for (arg = decl_arg_types, ix = 0;
15798 arg != NULL_TREE && arg != void_list_node;
15799 arg = TREE_CHAIN (arg), ++ix)
15800 args[ix] = TREE_VALUE (arg);
15802 if (fn_type_unification (fn, explicit_args, targs,
15804 (check_rettype || DECL_CONV_FN_P (fn)
15805 ? TREE_TYPE (decl_type) : NULL_TREE),
15806 DEDUCE_EXACT, LOOKUP_NORMAL))
15812 /* Return the innermost template arguments that, when applied to a
15813 template specialization whose innermost template parameters are
15814 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
15817 For example, suppose we have:
15819 template <class T, class U> struct S {};
15820 template <class T> struct S<T*, int> {};
15822 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
15823 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
15824 int}. The resulting vector will be {double}, indicating that `T'
15825 is bound to `double'. */
15828 get_class_bindings (tree tparms, tree spec_args, tree args)
15830 int i, ntparms = TREE_VEC_LENGTH (tparms);
15832 tree innermost_deduced_args;
15834 innermost_deduced_args = make_tree_vec (ntparms);
15835 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
15837 deduced_args = copy_node (args);
15838 SET_TMPL_ARGS_LEVEL (deduced_args,
15839 TMPL_ARGS_DEPTH (deduced_args),
15840 innermost_deduced_args);
15843 deduced_args = innermost_deduced_args;
15845 if (unify (tparms, deduced_args,
15846 INNERMOST_TEMPLATE_ARGS (spec_args),
15847 INNERMOST_TEMPLATE_ARGS (args),
15851 for (i = 0; i < ntparms; ++i)
15852 if (! TREE_VEC_ELT (innermost_deduced_args, i))
15855 /* Verify that nondeduced template arguments agree with the type
15856 obtained from argument deduction.
15860 struct A { typedef int X; };
15861 template <class T, class U> struct C {};
15862 template <class T> struct C<T, typename T::X> {};
15864 Then with the instantiation `C<A, int>', we can deduce that
15865 `T' is `A' but unify () does not check whether `typename T::X'
15867 spec_args = tsubst (spec_args, deduced_args, tf_none, NULL_TREE);
15868 if (spec_args == error_mark_node
15869 /* We only need to check the innermost arguments; the other
15870 arguments will always agree. */
15871 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args),
15872 INNERMOST_TEMPLATE_ARGS (args)))
15875 /* Now that we have bindings for all of the template arguments,
15876 ensure that the arguments deduced for the template template
15877 parameters have compatible template parameter lists. See the use
15878 of template_template_parm_bindings_ok_p in fn_type_unification
15879 for more information. */
15880 if (!template_template_parm_bindings_ok_p (tparms, deduced_args))
15883 return deduced_args;
15886 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
15887 Return the TREE_LIST node with the most specialized template, if
15888 any. If there is no most specialized template, the error_mark_node
15891 Note that this function does not look at, or modify, the
15892 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
15893 returned is one of the elements of INSTANTIATIONS, callers may
15894 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
15895 and retrieve it from the value returned. */
15898 most_specialized_instantiation (tree templates)
15902 ++processing_template_decl;
15905 for (fn = TREE_CHAIN (templates); fn; fn = TREE_CHAIN (fn))
15909 if (get_bindings (TREE_VALUE (champ),
15910 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
15911 NULL_TREE, /*check_ret=*/false))
15914 if (get_bindings (TREE_VALUE (fn),
15915 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
15916 NULL_TREE, /*check_ret=*/false))
15923 /* Equally specialized, move to next function. If there
15924 is no next function, nothing's most specialized. */
15925 fn = TREE_CHAIN (fn);
15933 /* Now verify that champ is better than everything earlier in the
15934 instantiation list. */
15935 for (fn = templates; fn != champ; fn = TREE_CHAIN (fn))
15936 if (get_bindings (TREE_VALUE (champ),
15937 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
15938 NULL_TREE, /*check_ret=*/false)
15939 || !get_bindings (TREE_VALUE (fn),
15940 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
15941 NULL_TREE, /*check_ret=*/false))
15947 processing_template_decl--;
15950 return error_mark_node;
15955 /* If DECL is a specialization of some template, return the most
15956 general such template. Otherwise, returns NULL_TREE.
15958 For example, given:
15960 template <class T> struct S { template <class U> void f(U); };
15962 if TMPL is `template <class U> void S<int>::f(U)' this will return
15963 the full template. This function will not trace past partial
15964 specializations, however. For example, given in addition:
15966 template <class T> struct S<T*> { template <class U> void f(U); };
15968 if TMPL is `template <class U> void S<int*>::f(U)' this will return
15969 `template <class T> template <class U> S<T*>::f(U)'. */
15972 most_general_template (tree decl)
15974 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
15975 an immediate specialization. */
15976 if (TREE_CODE (decl) == FUNCTION_DECL)
15978 if (DECL_TEMPLATE_INFO (decl)) {
15979 decl = DECL_TI_TEMPLATE (decl);
15981 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
15982 template friend. */
15983 if (TREE_CODE (decl) != TEMPLATE_DECL)
15989 /* Look for more and more general templates. */
15990 while (DECL_TEMPLATE_INFO (decl))
15992 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
15993 (See cp-tree.h for details.) */
15994 if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
15997 if (CLASS_TYPE_P (TREE_TYPE (decl))
15998 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
16001 /* Stop if we run into an explicitly specialized class template. */
16002 if (!DECL_NAMESPACE_SCOPE_P (decl)
16003 && DECL_CONTEXT (decl)
16004 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl)))
16007 decl = DECL_TI_TEMPLATE (decl);
16013 /* Return the most specialized of the class template partial
16014 specializations of TMPL which can produce TYPE, a specialization of
16015 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
16016 a _TYPE node corresponding to the partial specialization, while the
16017 TREE_PURPOSE is the set of template arguments that must be
16018 substituted into the TREE_TYPE in order to generate TYPE.
16020 If the choice of partial specialization is ambiguous, a diagnostic
16021 is issued, and the error_mark_node is returned. If there are no
16022 partial specializations of TMPL matching TYPE, then NULL_TREE is
16026 most_specialized_class (tree type, tree tmpl, tsubst_flags_t complain)
16028 tree list = NULL_TREE;
16034 tree outer_args = NULL_TREE;
16036 tmpl = most_general_template (tmpl);
16037 args = CLASSTYPE_TI_ARGS (type);
16039 /* For determining which partial specialization to use, only the
16040 innermost args are interesting. */
16041 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
16043 outer_args = strip_innermost_template_args (args, 1);
16044 args = INNERMOST_TEMPLATE_ARGS (args);
16047 for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t))
16049 tree partial_spec_args;
16051 tree parms = TREE_VALUE (t);
16053 partial_spec_args = CLASSTYPE_TI_ARGS (TREE_TYPE (t));
16055 ++processing_template_decl;
16061 /* Discard the outer levels of args, and then substitute in the
16062 template args from the enclosing class. */
16063 partial_spec_args = INNERMOST_TEMPLATE_ARGS (partial_spec_args);
16064 partial_spec_args = tsubst_template_args
16065 (partial_spec_args, outer_args, tf_none, NULL_TREE);
16067 /* PARMS already refers to just the innermost parms, but the
16068 template parms in partial_spec_args had their levels lowered
16069 by tsubst, so we need to do the same for the parm list. We
16070 can't just tsubst the TREE_VEC itself, as tsubst wants to
16071 treat a TREE_VEC as an argument vector. */
16072 parms = copy_node (parms);
16073 for (i = TREE_VEC_LENGTH (parms) - 1; i >= 0; --i)
16074 TREE_VEC_ELT (parms, i) =
16075 tsubst (TREE_VEC_ELT (parms, i), outer_args, tf_none, NULL_TREE);
16079 partial_spec_args =
16080 coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
16081 add_to_template_args (outer_args,
16082 partial_spec_args),
16084 /*require_all_args=*/true,
16085 /*use_default_args=*/true);
16087 --processing_template_decl;
16089 if (partial_spec_args == error_mark_node)
16090 return error_mark_node;
16092 spec_args = get_class_bindings (parms,
16098 spec_args = add_to_template_args (outer_args, spec_args);
16099 list = tree_cons (spec_args, TREE_VALUE (t), list);
16100 TREE_TYPE (list) = TREE_TYPE (t);
16107 ambiguous_p = false;
16110 t = TREE_CHAIN (t);
16111 for (; t; t = TREE_CHAIN (t))
16113 fate = more_specialized_class (champ, t);
16120 t = TREE_CHAIN (t);
16123 ambiguous_p = true;
16132 for (t = list; t && t != champ; t = TREE_CHAIN (t))
16134 fate = more_specialized_class (champ, t);
16137 ambiguous_p = true;
16145 char *spaces = NULL;
16146 if (!(complain & tf_error))
16147 return error_mark_node;
16148 error ("ambiguous class template instantiation for %q#T", type);
16149 str = TREE_CHAIN (list) ? _("candidates are:") : _("candidate is:");
16150 for (t = list; t; t = TREE_CHAIN (t))
16152 error ("%s %+#T", spaces ? spaces : str, TREE_TYPE (t));
16153 spaces = spaces ? spaces : get_spaces (str);
16156 return error_mark_node;
16162 /* Explicitly instantiate DECL. */
16165 do_decl_instantiation (tree decl, tree storage)
16167 tree result = NULL_TREE;
16170 if (!decl || decl == error_mark_node)
16171 /* An error occurred, for which grokdeclarator has already issued
16172 an appropriate message. */
16174 else if (! DECL_LANG_SPECIFIC (decl))
16176 error ("explicit instantiation of non-template %q#D", decl);
16179 else if (TREE_CODE (decl) == VAR_DECL)
16181 /* There is an asymmetry here in the way VAR_DECLs and
16182 FUNCTION_DECLs are handled by grokdeclarator. In the case of
16183 the latter, the DECL we get back will be marked as a
16184 template instantiation, and the appropriate
16185 DECL_TEMPLATE_INFO will be set up. This does not happen for
16186 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
16187 should handle VAR_DECLs as it currently handles
16189 if (!DECL_CLASS_SCOPE_P (decl))
16191 error ("%qD is not a static data member of a class template", decl);
16194 result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false);
16195 if (!result || TREE_CODE (result) != VAR_DECL)
16197 error ("no matching template for %qD found", decl);
16200 if (!same_type_p (TREE_TYPE (result), TREE_TYPE (decl)))
16202 error ("type %qT for explicit instantiation %qD does not match "
16203 "declared type %qT", TREE_TYPE (result), decl,
16208 else if (TREE_CODE (decl) != FUNCTION_DECL)
16210 error ("explicit instantiation of %q#D", decl);
16216 /* Check for various error cases. Note that if the explicit
16217 instantiation is valid the RESULT will currently be marked as an
16218 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
16219 until we get here. */
16221 if (DECL_TEMPLATE_SPECIALIZATION (result))
16223 /* DR 259 [temp.spec].
16225 Both an explicit instantiation and a declaration of an explicit
16226 specialization shall not appear in a program unless the explicit
16227 instantiation follows a declaration of the explicit specialization.
16229 For a given set of template parameters, if an explicit
16230 instantiation of a template appears after a declaration of an
16231 explicit specialization for that template, the explicit
16232 instantiation has no effect. */
16235 else if (DECL_EXPLICIT_INSTANTIATION (result))
16239 No program shall explicitly instantiate any template more
16242 We check DECL_NOT_REALLY_EXTERN so as not to complain when
16243 the first instantiation was `extern' and the second is not,
16244 and EXTERN_P for the opposite case. */
16245 if (DECL_NOT_REALLY_EXTERN (result) && !extern_p)
16246 permerror (input_location, "duplicate explicit instantiation of %q#D", result);
16247 /* If an "extern" explicit instantiation follows an ordinary
16248 explicit instantiation, the template is instantiated. */
16252 else if (!DECL_IMPLICIT_INSTANTIATION (result))
16254 error ("no matching template for %qD found", result);
16257 else if (!DECL_TEMPLATE_INFO (result))
16259 permerror (input_location, "explicit instantiation of non-template %q#D", result);
16263 if (storage == NULL_TREE)
16265 else if (storage == ridpointers[(int) RID_EXTERN])
16267 if (!in_system_header && (cxx_dialect == cxx98))
16268 pedwarn (input_location, OPT_pedantic,
16269 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
16274 error ("storage class %qD applied to template instantiation", storage);
16276 check_explicit_instantiation_namespace (result);
16277 mark_decl_instantiated (result, extern_p);
16279 instantiate_decl (result, /*defer_ok=*/1,
16280 /*expl_inst_class_mem_p=*/false);
16284 mark_class_instantiated (tree t, int extern_p)
16286 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
16287 SET_CLASSTYPE_INTERFACE_KNOWN (t);
16288 CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
16289 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
16292 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
16293 rest_of_type_compilation (t, 1);
16297 /* Called from do_type_instantiation through binding_table_foreach to
16298 do recursive instantiation for the type bound in ENTRY. */
16300 bt_instantiate_type_proc (binding_entry entry, void *data)
16302 tree storage = *(tree *) data;
16304 if (MAYBE_CLASS_TYPE_P (entry->type)
16305 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type)))
16306 do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0);
16309 /* Called from do_type_instantiation to instantiate a member
16310 (a member function or a static member variable) of an
16311 explicitly instantiated class template. */
16313 instantiate_class_member (tree decl, int extern_p)
16315 mark_decl_instantiated (decl, extern_p);
16317 instantiate_decl (decl, /*defer_ok=*/1,
16318 /*expl_inst_class_mem_p=*/true);
16321 /* Perform an explicit instantiation of template class T. STORAGE, if
16322 non-null, is the RID for extern, inline or static. COMPLAIN is
16323 nonzero if this is called from the parser, zero if called recursively,
16324 since the standard is unclear (as detailed below). */
16327 do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
16332 int previous_instantiation_extern_p = 0;
16334 if (TREE_CODE (t) == TYPE_DECL)
16337 if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t))
16339 error ("explicit instantiation of non-template type %qT", t);
16345 if (!COMPLETE_TYPE_P (t))
16347 if (complain & tf_error)
16348 error ("explicit instantiation of %q#T before definition of template",
16353 if (storage != NULL_TREE)
16355 if (!in_system_header)
16357 if (storage == ridpointers[(int) RID_EXTERN])
16359 if (cxx_dialect == cxx98)
16360 pedwarn (input_location, OPT_pedantic,
16361 "ISO C++ 1998 forbids the use of %<extern%> on "
16362 "explicit instantiations");
16365 pedwarn (input_location, OPT_pedantic,
16366 "ISO C++ forbids the use of %qE"
16367 " on explicit instantiations", storage);
16370 if (storage == ridpointers[(int) RID_INLINE])
16372 else if (storage == ridpointers[(int) RID_EXTERN])
16374 else if (storage == ridpointers[(int) RID_STATIC])
16378 error ("storage class %qD applied to template instantiation",
16384 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
16386 /* DR 259 [temp.spec].
16388 Both an explicit instantiation and a declaration of an explicit
16389 specialization shall not appear in a program unless the explicit
16390 instantiation follows a declaration of the explicit specialization.
16392 For a given set of template parameters, if an explicit
16393 instantiation of a template appears after a declaration of an
16394 explicit specialization for that template, the explicit
16395 instantiation has no effect. */
16398 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t))
16402 No program shall explicitly instantiate any template more
16405 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
16406 instantiation was `extern'. If EXTERN_P then the second is.
16407 These cases are OK. */
16408 previous_instantiation_extern_p = CLASSTYPE_INTERFACE_ONLY (t);
16410 if (!previous_instantiation_extern_p && !extern_p
16411 && (complain & tf_error))
16412 permerror (input_location, "duplicate explicit instantiation of %q#T", t);
16414 /* If we've already instantiated the template, just return now. */
16415 if (!CLASSTYPE_INTERFACE_ONLY (t))
16419 check_explicit_instantiation_namespace (TYPE_NAME (t));
16420 mark_class_instantiated (t, extern_p);
16428 /* In contrast to implicit instantiation, where only the
16429 declarations, and not the definitions, of members are
16430 instantiated, we have here:
16434 The explicit instantiation of a class template specialization
16435 implies the instantiation of all of its members not
16436 previously explicitly specialized in the translation unit
16437 containing the explicit instantiation.
16439 Of course, we can't instantiate member template classes, since
16440 we don't have any arguments for them. Note that the standard
16441 is unclear on whether the instantiation of the members are
16442 *explicit* instantiations or not. However, the most natural
16443 interpretation is that it should be an explicit instantiation. */
16446 for (tmp = TYPE_METHODS (t); tmp; tmp = DECL_CHAIN (tmp))
16447 if (TREE_CODE (tmp) == FUNCTION_DECL
16448 && DECL_TEMPLATE_INSTANTIATION (tmp))
16449 instantiate_class_member (tmp, extern_p);
16451 for (tmp = TYPE_FIELDS (t); tmp; tmp = DECL_CHAIN (tmp))
16452 if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp))
16453 instantiate_class_member (tmp, extern_p);
16455 if (CLASSTYPE_NESTED_UTDS (t))
16456 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t),
16457 bt_instantiate_type_proc, &storage);
16461 /* Given a function DECL, which is a specialization of TMPL, modify
16462 DECL to be a re-instantiation of TMPL with the same template
16463 arguments. TMPL should be the template into which tsubst'ing
16464 should occur for DECL, not the most general template.
16466 One reason for doing this is a scenario like this:
16469 void f(const T&, int i);
16471 void g() { f(3, 7); }
16474 void f(const T& t, const int i) { }
16476 Note that when the template is first instantiated, with
16477 instantiate_template, the resulting DECL will have no name for the
16478 first parameter, and the wrong type for the second. So, when we go
16479 to instantiate the DECL, we regenerate it. */
16482 regenerate_decl_from_template (tree decl, tree tmpl)
16484 /* The arguments used to instantiate DECL, from the most general
16489 args = DECL_TI_ARGS (decl);
16490 code_pattern = DECL_TEMPLATE_RESULT (tmpl);
16492 /* Make sure that we can see identifiers, and compute access
16494 push_access_scope (decl);
16496 if (TREE_CODE (decl) == FUNCTION_DECL)
16504 args_depth = TMPL_ARGS_DEPTH (args);
16505 parms_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
16506 if (args_depth > parms_depth)
16507 args = get_innermost_template_args (args, parms_depth);
16509 specs = tsubst_exception_specification (TREE_TYPE (code_pattern),
16510 args, tf_error, NULL_TREE);
16512 TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl),
16515 /* Merge parameter declarations. */
16516 decl_parm = skip_artificial_parms_for (decl,
16517 DECL_ARGUMENTS (decl));
16519 = skip_artificial_parms_for (code_pattern,
16520 DECL_ARGUMENTS (code_pattern));
16521 while (decl_parm && !FUNCTION_PARAMETER_PACK_P (pattern_parm))
16526 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
16527 DECL_NAME (decl_parm) = DECL_NAME (pattern_parm);
16528 parm_type = tsubst (TREE_TYPE (pattern_parm), args, tf_error,
16530 parm_type = type_decays_to (parm_type);
16531 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
16532 TREE_TYPE (decl_parm) = parm_type;
16533 attributes = DECL_ATTRIBUTES (pattern_parm);
16534 if (DECL_ATTRIBUTES (decl_parm) != attributes)
16536 DECL_ATTRIBUTES (decl_parm) = attributes;
16537 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
16539 decl_parm = DECL_CHAIN (decl_parm);
16540 pattern_parm = DECL_CHAIN (pattern_parm);
16542 /* Merge any parameters that match with the function parameter
16544 if (pattern_parm && FUNCTION_PARAMETER_PACK_P (pattern_parm))
16547 tree expanded_types;
16548 /* Expand the TYPE_PACK_EXPANSION that provides the types for
16549 the parameters in this function parameter pack. */
16550 expanded_types = tsubst_pack_expansion (TREE_TYPE (pattern_parm),
16551 args, tf_error, NULL_TREE);
16552 len = TREE_VEC_LENGTH (expanded_types);
16553 for (i = 0; i < len; i++)
16558 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
16559 /* Rename the parameter to include the index. */
16560 DECL_NAME (decl_parm) =
16561 make_ith_pack_parameter_name (DECL_NAME (pattern_parm), i);
16562 parm_type = TREE_VEC_ELT (expanded_types, i);
16563 parm_type = type_decays_to (parm_type);
16564 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
16565 TREE_TYPE (decl_parm) = parm_type;
16566 attributes = DECL_ATTRIBUTES (pattern_parm);
16567 if (DECL_ATTRIBUTES (decl_parm) != attributes)
16569 DECL_ATTRIBUTES (decl_parm) = attributes;
16570 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
16572 decl_parm = DECL_CHAIN (decl_parm);
16575 /* Merge additional specifiers from the CODE_PATTERN. */
16576 if (DECL_DECLARED_INLINE_P (code_pattern)
16577 && !DECL_DECLARED_INLINE_P (decl))
16578 DECL_DECLARED_INLINE_P (decl) = 1;
16580 else if (TREE_CODE (decl) == VAR_DECL)
16582 DECL_INITIAL (decl) =
16583 tsubst_expr (DECL_INITIAL (code_pattern), args,
16584 tf_error, DECL_TI_TEMPLATE (decl),
16585 /*integral_constant_expression_p=*/false);
16586 if (VAR_HAD_UNKNOWN_BOUND (decl))
16587 TREE_TYPE (decl) = tsubst (TREE_TYPE (code_pattern), args,
16588 tf_error, DECL_TI_TEMPLATE (decl));
16591 gcc_unreachable ();
16593 pop_access_scope (decl);
16596 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
16597 substituted to get DECL. */
16600 template_for_substitution (tree decl)
16602 tree tmpl = DECL_TI_TEMPLATE (decl);
16604 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
16605 for the instantiation. This is not always the most general
16606 template. Consider, for example:
16609 struct S { template <class U> void f();
16610 template <> void f<int>(); };
16612 and an instantiation of S<double>::f<int>. We want TD to be the
16613 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
16614 while (/* An instantiation cannot have a definition, so we need a
16615 more general template. */
16616 DECL_TEMPLATE_INSTANTIATION (tmpl)
16617 /* We must also deal with friend templates. Given:
16619 template <class T> struct S {
16620 template <class U> friend void f() {};
16623 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
16624 so far as the language is concerned, but that's still
16625 where we get the pattern for the instantiation from. On
16626 other hand, if the definition comes outside the class, say:
16628 template <class T> struct S {
16629 template <class U> friend void f();
16631 template <class U> friend void f() {}
16633 we don't need to look any further. That's what the check for
16634 DECL_INITIAL is for. */
16635 || (TREE_CODE (decl) == FUNCTION_DECL
16636 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl)
16637 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl))))
16639 /* The present template, TD, should not be a definition. If it
16640 were a definition, we should be using it! Note that we
16641 cannot restructure the loop to just keep going until we find
16642 a template with a definition, since that might go too far if
16643 a specialization was declared, but not defined. */
16644 gcc_assert (TREE_CODE (decl) != VAR_DECL
16645 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl)));
16647 /* Fetch the more general template. */
16648 tmpl = DECL_TI_TEMPLATE (tmpl);
16654 /* Returns true if we need to instantiate this template instance even if we
16655 know we aren't going to emit it.. */
16658 always_instantiate_p (tree decl)
16660 /* We always instantiate inline functions so that we can inline them. An
16661 explicit instantiation declaration prohibits implicit instantiation of
16662 non-inline functions. With high levels of optimization, we would
16663 normally inline non-inline functions -- but we're not allowed to do
16664 that for "extern template" functions. Therefore, we check
16665 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
16666 return ((TREE_CODE (decl) == FUNCTION_DECL
16667 && DECL_DECLARED_INLINE_P (decl))
16668 /* And we need to instantiate static data members so that
16669 their initializers are available in integral constant
16671 || (TREE_CODE (decl) == VAR_DECL
16672 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl)));
16675 /* Produce the definition of D, a _DECL generated from a template. If
16676 DEFER_OK is nonzero, then we don't have to actually do the
16677 instantiation now; we just have to do it sometime. Normally it is
16678 an error if this is an explicit instantiation but D is undefined.
16679 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
16680 explicitly instantiated class template. */
16683 instantiate_decl (tree d, int defer_ok,
16684 bool expl_inst_class_mem_p)
16686 tree tmpl = DECL_TI_TEMPLATE (d);
16693 bool pattern_defined;
16695 location_t saved_loc = input_location;
16698 /* This function should only be used to instantiate templates for
16699 functions and static member variables. */
16700 gcc_assert (TREE_CODE (d) == FUNCTION_DECL
16701 || TREE_CODE (d) == VAR_DECL);
16703 /* Variables are never deferred; if instantiation is required, they
16704 are instantiated right away. That allows for better code in the
16705 case that an expression refers to the value of the variable --
16706 if the variable has a constant value the referring expression can
16707 take advantage of that fact. */
16708 if (TREE_CODE (d) == VAR_DECL)
16711 /* Don't instantiate cloned functions. Instead, instantiate the
16712 functions they cloned. */
16713 if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d))
16714 d = DECL_CLONED_FUNCTION (d);
16716 if (DECL_TEMPLATE_INSTANTIATED (d)
16717 || DECL_TEMPLATE_SPECIALIZATION (d))
16718 /* D has already been instantiated or explicitly specialized, so
16719 there's nothing for us to do here.
16721 It might seem reasonable to check whether or not D is an explicit
16722 instantiation, and, if so, stop here. But when an explicit
16723 instantiation is deferred until the end of the compilation,
16724 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
16725 the instantiation. */
16728 /* Check to see whether we know that this template will be
16729 instantiated in some other file, as with "extern template"
16731 external_p = (DECL_INTERFACE_KNOWN (d) && DECL_REALLY_EXTERN (d));
16733 /* In general, we do not instantiate such templates. */
16734 if (external_p && !always_instantiate_p (d))
16737 gen_tmpl = most_general_template (tmpl);
16738 gen_args = DECL_TI_ARGS (d);
16740 if (tmpl != gen_tmpl)
16741 /* We should already have the extra args. */
16742 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl))
16743 == TMPL_ARGS_DEPTH (gen_args));
16744 /* And what's in the hash table should match D. */
16745 gcc_assert ((spec = retrieve_specialization (gen_tmpl, gen_args, 0)) == d
16746 || spec == NULL_TREE);
16748 /* This needs to happen before any tsubsting. */
16749 if (! push_tinst_level (d))
16752 timevar_push (TV_PARSE);
16754 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
16755 for the instantiation. */
16756 td = template_for_substitution (d);
16757 code_pattern = DECL_TEMPLATE_RESULT (td);
16759 /* We should never be trying to instantiate a member of a class
16760 template or partial specialization. */
16761 gcc_assert (d != code_pattern);
16763 if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d))
16764 || DECL_TEMPLATE_SPECIALIZATION (td))
16765 /* In the case of a friend template whose definition is provided
16766 outside the class, we may have too many arguments. Drop the
16767 ones we don't need. The same is true for specializations. */
16768 args = get_innermost_template_args
16769 (gen_args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td)));
16773 if (TREE_CODE (d) == FUNCTION_DECL)
16774 pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE);
16776 pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
16778 /* We may be in the middle of deferred access check. Disable it now. */
16779 push_deferring_access_checks (dk_no_deferred);
16781 /* Unless an explicit instantiation directive has already determined
16782 the linkage of D, remember that a definition is available for
16784 if (pattern_defined
16785 && !DECL_INTERFACE_KNOWN (d)
16786 && !DECL_NOT_REALLY_EXTERN (d))
16787 mark_definable (d);
16789 input_location = DECL_SOURCE_LOCATION (d);
16791 /* If D is a member of an explicitly instantiated class template,
16792 and no definition is available, treat it like an implicit
16794 if (!pattern_defined && expl_inst_class_mem_p
16795 && DECL_EXPLICIT_INSTANTIATION (d))
16797 DECL_NOT_REALLY_EXTERN (d) = 0;
16798 DECL_INTERFACE_KNOWN (d) = 0;
16799 SET_DECL_IMPLICIT_INSTANTIATION (d);
16802 /* Recheck the substitutions to obtain any warning messages
16803 about ignoring cv qualifiers. Don't do this for artificial decls,
16804 as it breaks the context-sensitive substitution for lambda op(). */
16805 if (!defer_ok && !DECL_ARTIFICIAL (d))
16807 tree gen = DECL_TEMPLATE_RESULT (gen_tmpl);
16808 tree type = TREE_TYPE (gen);
16810 /* Make sure that we can see identifiers, and compute access
16811 correctly. D is already the target FUNCTION_DECL with the
16813 push_access_scope (d);
16815 if (TREE_CODE (gen) == FUNCTION_DECL)
16817 tsubst (DECL_ARGUMENTS (gen), gen_args, tf_warning_or_error, d);
16818 tsubst_exception_specification (type, gen_args, tf_warning_or_error,
16820 /* Don't simply tsubst the function type, as that will give
16821 duplicate warnings about poor parameter qualifications.
16822 The function arguments are the same as the decl_arguments
16823 without the top level cv qualifiers. */
16824 type = TREE_TYPE (type);
16826 tsubst (type, gen_args, tf_warning_or_error, d);
16828 pop_access_scope (d);
16831 /* Defer all other templates, unless we have been explicitly
16832 forbidden from doing so. */
16833 if (/* If there is no definition, we cannot instantiate the
16836 /* If it's OK to postpone instantiation, do so. */
16838 /* If this is a static data member that will be defined
16839 elsewhere, we don't want to instantiate the entire data
16840 member, but we do want to instantiate the initializer so that
16841 we can substitute that elsewhere. */
16842 || (external_p && TREE_CODE (d) == VAR_DECL))
16844 /* The definition of the static data member is now required so
16845 we must substitute the initializer. */
16846 if (TREE_CODE (d) == VAR_DECL
16847 && !DECL_INITIAL (d)
16848 && DECL_INITIAL (code_pattern))
16853 ns = decl_namespace_context (d);
16854 push_nested_namespace (ns);
16855 push_nested_class (DECL_CONTEXT (d));
16856 init = tsubst_expr (DECL_INITIAL (code_pattern),
16858 tf_warning_or_error, NULL_TREE,
16859 /*integral_constant_expression_p=*/false);
16860 cp_finish_decl (d, init, /*init_const_expr_p=*/false,
16861 /*asmspec_tree=*/NULL_TREE,
16862 LOOKUP_ONLYCONVERTING);
16863 pop_nested_class ();
16864 pop_nested_namespace (ns);
16867 /* We restore the source position here because it's used by
16868 add_pending_template. */
16869 input_location = saved_loc;
16871 if (at_eof && !pattern_defined
16872 && DECL_EXPLICIT_INSTANTIATION (d)
16873 && DECL_NOT_REALLY_EXTERN (d))
16876 The definition of a non-exported function template, a
16877 non-exported member function template, or a non-exported
16878 member function or static data member of a class template
16879 shall be present in every translation unit in which it is
16880 explicitly instantiated. */
16881 permerror (input_location, "explicit instantiation of %qD "
16882 "but no definition available", d);
16884 /* ??? Historically, we have instantiated inline functions, even
16885 when marked as "extern template". */
16886 if (!(external_p && TREE_CODE (d) == VAR_DECL))
16887 add_pending_template (d);
16890 /* Tell the repository that D is available in this translation unit
16891 -- and see if it is supposed to be instantiated here. */
16892 if (TREE_PUBLIC (d) && !DECL_REALLY_EXTERN (d) && !repo_emit_p (d))
16894 /* In a PCH file, despite the fact that the repository hasn't
16895 requested instantiation in the PCH it is still possible that
16896 an instantiation will be required in a file that includes the
16899 add_pending_template (d);
16900 /* Instantiate inline functions so that the inliner can do its
16901 job, even though we'll not be emitting a copy of this
16903 if (!(TREE_CODE (d) == FUNCTION_DECL && possibly_inlined_p (d)))
16907 need_push = !cfun || !global_bindings_p ();
16909 push_to_top_level ();
16911 /* Mark D as instantiated so that recursive calls to
16912 instantiate_decl do not try to instantiate it again. */
16913 DECL_TEMPLATE_INSTANTIATED (d) = 1;
16915 /* Regenerate the declaration in case the template has been modified
16916 by a subsequent redeclaration. */
16917 regenerate_decl_from_template (d, td);
16919 /* We already set the file and line above. Reset them now in case
16920 they changed as a result of calling regenerate_decl_from_template. */
16921 input_location = DECL_SOURCE_LOCATION (d);
16923 if (TREE_CODE (d) == VAR_DECL)
16927 /* Clear out DECL_RTL; whatever was there before may not be right
16928 since we've reset the type of the declaration. */
16929 SET_DECL_RTL (d, NULL);
16930 DECL_IN_AGGR_P (d) = 0;
16932 /* The initializer is placed in DECL_INITIAL by
16933 regenerate_decl_from_template. Pull it out so that
16934 cp_finish_decl can process it. */
16935 init = DECL_INITIAL (d);
16936 DECL_INITIAL (d) = NULL_TREE;
16937 DECL_INITIALIZED_P (d) = 0;
16939 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
16940 initializer. That function will defer actual emission until
16941 we have a chance to determine linkage. */
16942 DECL_EXTERNAL (d) = 0;
16944 /* Enter the scope of D so that access-checking works correctly. */
16945 push_nested_class (DECL_CONTEXT (d));
16946 cp_finish_decl (d, init, false, NULL_TREE, 0);
16947 pop_nested_class ();
16949 else if (TREE_CODE (d) == FUNCTION_DECL)
16951 htab_t saved_local_specializations;
16956 /* Save away the current list, in case we are instantiating one
16957 template from within the body of another. */
16958 saved_local_specializations = local_specializations;
16960 /* Set up the list of local specializations. */
16961 local_specializations = htab_create (37,
16962 hash_local_specialization,
16963 eq_local_specializations,
16966 /* Set up context. */
16967 start_preparsed_function (d, NULL_TREE, SF_PRE_PARSED);
16969 /* Create substitution entries for the parameters. */
16970 subst_decl = DECL_TEMPLATE_RESULT (template_for_substitution (d));
16971 tmpl_parm = DECL_ARGUMENTS (subst_decl);
16972 spec_parm = DECL_ARGUMENTS (d);
16973 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d))
16975 register_local_specialization (spec_parm, tmpl_parm);
16976 spec_parm = skip_artificial_parms_for (d, spec_parm);
16977 tmpl_parm = skip_artificial_parms_for (subst_decl, tmpl_parm);
16979 while (tmpl_parm && !FUNCTION_PARAMETER_PACK_P (tmpl_parm))
16981 register_local_specialization (spec_parm, tmpl_parm);
16982 tmpl_parm = DECL_CHAIN (tmpl_parm);
16983 spec_parm = DECL_CHAIN (spec_parm);
16985 if (tmpl_parm && FUNCTION_PARAMETER_PACK_P (tmpl_parm))
16987 /* Register the (value) argument pack as a specialization of
16988 TMPL_PARM, then move on. */
16989 tree argpack = make_fnparm_pack (spec_parm);
16990 register_local_specialization (argpack, tmpl_parm);
16991 tmpl_parm = DECL_CHAIN (tmpl_parm);
16992 spec_parm = NULL_TREE;
16994 gcc_assert (!spec_parm);
16996 /* Substitute into the body of the function. */
16997 tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
16998 tf_warning_or_error, tmpl,
16999 /*integral_constant_expression_p=*/false);
17001 /* Set the current input_location to the end of the function
17002 so that finish_function knows where we are. */
17003 input_location = DECL_STRUCT_FUNCTION (code_pattern)->function_end_locus;
17005 /* We don't need the local specializations any more. */
17006 htab_delete (local_specializations);
17007 local_specializations = saved_local_specializations;
17009 /* Finish the function. */
17010 d = finish_function (0);
17011 expand_or_defer_fn (d);
17014 /* We're not deferring instantiation any more. */
17015 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
17018 pop_from_top_level ();
17021 input_location = saved_loc;
17022 pop_deferring_access_checks ();
17023 pop_tinst_level ();
17025 timevar_pop (TV_PARSE);
17030 /* Run through the list of templates that we wish we could
17031 instantiate, and instantiate any we can. RETRIES is the
17032 number of times we retry pending template instantiation. */
17035 instantiate_pending_templates (int retries)
17038 location_t saved_loc = input_location;
17040 /* Instantiating templates may trigger vtable generation. This in turn
17041 may require further template instantiations. We place a limit here
17042 to avoid infinite loop. */
17043 if (pending_templates && retries >= max_tinst_depth)
17045 tree decl = pending_templates->tinst->decl;
17047 error ("template instantiation depth exceeds maximum of %d"
17048 " instantiating %q+D, possibly from virtual table generation"
17049 " (use -ftemplate-depth= to increase the maximum)",
17050 max_tinst_depth, decl);
17051 if (TREE_CODE (decl) == FUNCTION_DECL)
17052 /* Pretend that we defined it. */
17053 DECL_INITIAL (decl) = error_mark_node;
17059 struct pending_template **t = &pending_templates;
17060 struct pending_template *last = NULL;
17064 tree instantiation = reopen_tinst_level ((*t)->tinst);
17065 bool complete = false;
17067 if (TYPE_P (instantiation))
17071 if (!COMPLETE_TYPE_P (instantiation))
17073 instantiate_class_template (instantiation);
17074 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
17075 for (fn = TYPE_METHODS (instantiation);
17077 fn = TREE_CHAIN (fn))
17078 if (! DECL_ARTIFICIAL (fn))
17079 instantiate_decl (fn,
17081 /*expl_inst_class_mem_p=*/false);
17082 if (COMPLETE_TYPE_P (instantiation))
17086 complete = COMPLETE_TYPE_P (instantiation);
17090 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation)
17091 && !DECL_TEMPLATE_INSTANTIATED (instantiation))
17094 = instantiate_decl (instantiation,
17096 /*expl_inst_class_mem_p=*/false);
17097 if (DECL_TEMPLATE_INSTANTIATED (instantiation))
17101 complete = (DECL_TEMPLATE_SPECIALIZATION (instantiation)
17102 || DECL_TEMPLATE_INSTANTIATED (instantiation));
17106 /* If INSTANTIATION has been instantiated, then we don't
17107 need to consider it again in the future. */
17115 current_tinst_level = NULL;
17117 last_pending_template = last;
17119 while (reconsider);
17121 input_location = saved_loc;
17124 /* Substitute ARGVEC into T, which is a list of initializers for
17125 either base class or a non-static data member. The TREE_PURPOSEs
17126 are DECLs, and the TREE_VALUEs are the initializer values. Used by
17127 instantiate_decl. */
17130 tsubst_initializer_list (tree t, tree argvec)
17132 tree inits = NULL_TREE;
17134 for (; t; t = TREE_CHAIN (t))
17138 tree expanded_bases = NULL_TREE;
17139 tree expanded_arguments = NULL_TREE;
17142 if (TREE_CODE (TREE_PURPOSE (t)) == TYPE_PACK_EXPANSION)
17147 /* Expand the base class expansion type into separate base
17149 expanded_bases = tsubst_pack_expansion (TREE_PURPOSE (t), argvec,
17150 tf_warning_or_error,
17152 if (expanded_bases == error_mark_node)
17155 /* We'll be building separate TREE_LISTs of arguments for
17157 len = TREE_VEC_LENGTH (expanded_bases);
17158 expanded_arguments = make_tree_vec (len);
17159 for (i = 0; i < len; i++)
17160 TREE_VEC_ELT (expanded_arguments, i) = NULL_TREE;
17162 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
17163 expand each argument in the TREE_VALUE of t. */
17164 expr = make_node (EXPR_PACK_EXPANSION);
17165 PACK_EXPANSION_PARAMETER_PACKS (expr) =
17166 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t));
17168 if (TREE_VALUE (t) == void_type_node)
17169 /* VOID_TYPE_NODE is used to indicate
17170 value-initialization. */
17172 for (i = 0; i < len; i++)
17173 TREE_VEC_ELT (expanded_arguments, i) = void_type_node;
17177 /* Substitute parameter packs into each argument in the
17179 in_base_initializer = 1;
17180 for (arg = TREE_VALUE (t); arg; arg = TREE_CHAIN (arg))
17182 tree expanded_exprs;
17184 /* Expand the argument. */
17185 SET_PACK_EXPANSION_PATTERN (expr, TREE_VALUE (arg));
17187 = tsubst_pack_expansion (expr, argvec,
17188 tf_warning_or_error,
17190 if (expanded_exprs == error_mark_node)
17193 /* Prepend each of the expanded expressions to the
17194 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
17195 for (i = 0; i < len; i++)
17197 TREE_VEC_ELT (expanded_arguments, i) =
17198 tree_cons (NULL_TREE,
17199 TREE_VEC_ELT (expanded_exprs, i),
17200 TREE_VEC_ELT (expanded_arguments, i));
17203 in_base_initializer = 0;
17205 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
17206 since we built them backwards. */
17207 for (i = 0; i < len; i++)
17209 TREE_VEC_ELT (expanded_arguments, i) =
17210 nreverse (TREE_VEC_ELT (expanded_arguments, i));
17215 for (i = 0; i < len; ++i)
17217 if (expanded_bases)
17219 decl = TREE_VEC_ELT (expanded_bases, i);
17220 decl = expand_member_init (decl);
17221 init = TREE_VEC_ELT (expanded_arguments, i);
17225 decl = tsubst_copy (TREE_PURPOSE (t), argvec,
17226 tf_warning_or_error, NULL_TREE);
17228 decl = expand_member_init (decl);
17229 if (decl && !DECL_P (decl))
17230 in_base_initializer = 1;
17232 init = tsubst_expr (TREE_VALUE (t), argvec,
17233 tf_warning_or_error, NULL_TREE,
17234 /*integral_constant_expression_p=*/false);
17235 in_base_initializer = 0;
17240 init = build_tree_list (decl, init);
17241 TREE_CHAIN (init) = inits;
17249 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
17252 set_current_access_from_decl (tree decl)
17254 if (TREE_PRIVATE (decl))
17255 current_access_specifier = access_private_node;
17256 else if (TREE_PROTECTED (decl))
17257 current_access_specifier = access_protected_node;
17259 current_access_specifier = access_public_node;
17262 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
17263 is the instantiation (which should have been created with
17264 start_enum) and ARGS are the template arguments to use. */
17267 tsubst_enum (tree tag, tree newtag, tree args)
17271 for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
17276 decl = TREE_VALUE (e);
17277 /* Note that in a template enum, the TREE_VALUE is the
17278 CONST_DECL, not the corresponding INTEGER_CST. */
17279 value = tsubst_expr (DECL_INITIAL (decl),
17280 args, tf_warning_or_error, NULL_TREE,
17281 /*integral_constant_expression_p=*/true);
17283 /* Give this enumeration constant the correct access. */
17284 set_current_access_from_decl (decl);
17286 /* Actually build the enumerator itself. */
17287 build_enumerator (DECL_NAME (decl), value, newtag);
17290 finish_enum (newtag);
17291 DECL_SOURCE_LOCATION (TYPE_NAME (newtag))
17292 = DECL_SOURCE_LOCATION (TYPE_NAME (tag));
17295 /* DECL is a FUNCTION_DECL that is a template specialization. Return
17296 its type -- but without substituting the innermost set of template
17297 arguments. So, innermost set of template parameters will appear in
17301 get_mostly_instantiated_function_type (tree decl)
17309 tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
17310 targs = DECL_TI_ARGS (decl);
17311 tparms = DECL_TEMPLATE_PARMS (tmpl);
17312 parm_depth = TMPL_PARMS_DEPTH (tparms);
17314 /* There should be as many levels of arguments as there are levels
17316 gcc_assert (parm_depth == TMPL_ARGS_DEPTH (targs));
17318 fn_type = TREE_TYPE (tmpl);
17320 if (parm_depth == 1)
17321 /* No substitution is necessary. */
17325 int i, save_access_control;
17328 /* Replace the innermost level of the TARGS with NULL_TREEs to
17329 let tsubst know not to substitute for those parameters. */
17330 partial_args = make_tree_vec (TREE_VEC_LENGTH (targs));
17331 for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i)
17332 SET_TMPL_ARGS_LEVEL (partial_args, i,
17333 TMPL_ARGS_LEVEL (targs, i));
17334 SET_TMPL_ARGS_LEVEL (partial_args,
17335 TMPL_ARGS_DEPTH (targs),
17336 make_tree_vec (DECL_NTPARMS (tmpl)));
17338 /* Disable access control as this function is used only during
17340 save_access_control = flag_access_control;
17341 flag_access_control = 0;
17343 ++processing_template_decl;
17344 /* Now, do the (partial) substitution to figure out the
17345 appropriate function type. */
17346 fn_type = tsubst (fn_type, partial_args, tf_error, NULL_TREE);
17347 --processing_template_decl;
17349 /* Substitute into the template parameters to obtain the real
17350 innermost set of parameters. This step is important if the
17351 innermost set of template parameters contains value
17352 parameters whose types depend on outer template parameters. */
17353 TREE_VEC_LENGTH (partial_args)--;
17354 tparms = tsubst_template_parms (tparms, partial_args, tf_error);
17356 flag_access_control = save_access_control;
17362 /* Return truthvalue if we're processing a template different from
17363 the last one involved in diagnostics. */
17365 problematic_instantiation_changed (void)
17367 return last_template_error_tick != tinst_level_tick;
17370 /* Remember current template involved in diagnostics. */
17372 record_last_problematic_instantiation (void)
17374 last_template_error_tick = tinst_level_tick;
17377 struct tinst_level *
17378 current_instantiation (void)
17380 return current_tinst_level;
17383 /* [temp.param] Check that template non-type parm TYPE is of an allowable
17384 type. Return zero for ok, nonzero for disallowed. Issue error and
17385 warning messages under control of COMPLAIN. */
17388 invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain)
17390 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type))
17392 else if (POINTER_TYPE_P (type))
17394 else if (TYPE_PTR_TO_MEMBER_P (type))
17396 else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
17398 else if (TREE_CODE (type) == TYPENAME_TYPE)
17401 if (complain & tf_error)
17402 error ("%q#T is not a valid type for a template constant parameter", type);
17406 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
17407 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
17410 dependent_type_p_r (tree type)
17416 A type is dependent if it is:
17418 -- a template parameter. Template template parameters are types
17419 for us (since TYPE_P holds true for them) so we handle
17421 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
17422 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
17424 /* -- a qualified-id with a nested-name-specifier which contains a
17425 class-name that names a dependent type or whose unqualified-id
17426 names a dependent type. */
17427 if (TREE_CODE (type) == TYPENAME_TYPE)
17429 /* -- a cv-qualified type where the cv-unqualified type is
17431 type = TYPE_MAIN_VARIANT (type);
17432 /* -- a compound type constructed from any dependent type. */
17433 if (TYPE_PTR_TO_MEMBER_P (type))
17434 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type))
17435 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
17437 else if (TREE_CODE (type) == POINTER_TYPE
17438 || TREE_CODE (type) == REFERENCE_TYPE)
17439 return dependent_type_p (TREE_TYPE (type));
17440 else if (TREE_CODE (type) == FUNCTION_TYPE
17441 || TREE_CODE (type) == METHOD_TYPE)
17445 if (dependent_type_p (TREE_TYPE (type)))
17447 for (arg_type = TYPE_ARG_TYPES (type);
17449 arg_type = TREE_CHAIN (arg_type))
17450 if (dependent_type_p (TREE_VALUE (arg_type)))
17454 /* -- an array type constructed from any dependent type or whose
17455 size is specified by a constant expression that is
17456 value-dependent. */
17457 if (TREE_CODE (type) == ARRAY_TYPE)
17459 if (TYPE_DOMAIN (type)
17460 && dependent_type_p (TYPE_DOMAIN (type)))
17462 return dependent_type_p (TREE_TYPE (type));
17464 else if (TREE_CODE (type) == INTEGER_TYPE
17465 && !TREE_CONSTANT (TYPE_MAX_VALUE (type)))
17467 /* If this is the TYPE_DOMAIN of an array type, consider it
17468 dependent. We already checked for value-dependence in
17469 compute_array_index_type. */
17470 return type_dependent_expression_p (TYPE_MAX_VALUE (type));
17473 /* -- a template-id in which either the template name is a template
17475 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
17477 /* ... or any of the template arguments is a dependent type or
17478 an expression that is type-dependent or value-dependent. */
17479 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
17480 && (any_dependent_template_arguments_p
17481 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
17484 /* All TYPEOF_TYPEs and DECLTYPE_TYPEs are dependent; if the
17485 argument of the `typeof' expression is not type-dependent, then
17486 it should already been have resolved. */
17487 if (TREE_CODE (type) == TYPEOF_TYPE
17488 || TREE_CODE (type) == DECLTYPE_TYPE)
17491 /* A template argument pack is dependent if any of its packed
17493 if (TREE_CODE (type) == TYPE_ARGUMENT_PACK)
17495 tree args = ARGUMENT_PACK_ARGS (type);
17496 int i, len = TREE_VEC_LENGTH (args);
17497 for (i = 0; i < len; ++i)
17498 if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
17502 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
17503 be template parameters. */
17504 if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
17507 /* The standard does not specifically mention types that are local
17508 to template functions or local classes, but they should be
17509 considered dependent too. For example:
17511 template <int I> void f() {
17516 The size of `E' cannot be known until the value of `I' has been
17517 determined. Therefore, `E' must be considered dependent. */
17518 scope = TYPE_CONTEXT (type);
17519 if (scope && TYPE_P (scope))
17520 return dependent_type_p (scope);
17521 else if (scope && TREE_CODE (scope) == FUNCTION_DECL)
17522 return type_dependent_expression_p (scope);
17524 /* Other types are non-dependent. */
17528 /* Returns TRUE if TYPE is dependent, in the sense of
17529 [temp.dep.type]. */
17532 dependent_type_p (tree type)
17534 /* If there are no template parameters in scope, then there can't be
17535 any dependent types. */
17536 if (!processing_template_decl)
17538 /* If we are not processing a template, then nobody should be
17539 providing us with a dependent type. */
17541 gcc_assert (TREE_CODE (type) != TEMPLATE_TYPE_PARM || is_auto (type));
17545 /* If the type is NULL, we have not computed a type for the entity
17546 in question; in that case, the type is dependent. */
17550 /* Erroneous types can be considered non-dependent. */
17551 if (type == error_mark_node)
17554 /* If we have not already computed the appropriate value for TYPE,
17556 if (!TYPE_DEPENDENT_P_VALID (type))
17558 TYPE_DEPENDENT_P (type) = dependent_type_p_r (type);
17559 TYPE_DEPENDENT_P_VALID (type) = 1;
17562 return TYPE_DEPENDENT_P (type);
17565 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
17566 lookup. In other words, a dependent type that is not the current
17570 dependent_scope_p (tree scope)
17572 return (scope && TYPE_P (scope) && dependent_type_p (scope)
17573 && !currently_open_class (scope));
17576 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
17577 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
17581 value_dependent_expression_p (tree expression)
17583 if (!processing_template_decl)
17586 /* A name declared with a dependent type. */
17587 if (DECL_P (expression) && type_dependent_expression_p (expression))
17590 switch (TREE_CODE (expression))
17592 case IDENTIFIER_NODE:
17593 /* A name that has not been looked up -- must be dependent. */
17596 case TEMPLATE_PARM_INDEX:
17597 /* A non-type template parm. */
17601 /* A non-type template parm. */
17602 if (DECL_TEMPLATE_PARM_P (expression))
17604 return value_dependent_expression_p (DECL_INITIAL (expression));
17607 /* A constant with integral or enumeration type and is initialized
17608 with an expression that is value-dependent. */
17609 if (DECL_INITIAL (expression)
17610 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression))
17611 && value_dependent_expression_p (DECL_INITIAL (expression)))
17615 case DYNAMIC_CAST_EXPR:
17616 case STATIC_CAST_EXPR:
17617 case CONST_CAST_EXPR:
17618 case REINTERPRET_CAST_EXPR:
17620 /* These expressions are value-dependent if the type to which
17621 the cast occurs is dependent or the expression being casted
17622 is value-dependent. */
17624 tree type = TREE_TYPE (expression);
17626 if (dependent_type_p (type))
17629 /* A functional cast has a list of operands. */
17630 expression = TREE_OPERAND (expression, 0);
17633 /* If there are no operands, it must be an expression such
17634 as "int()". This should not happen for aggregate types
17635 because it would form non-constant expressions. */
17636 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
17641 if (TREE_CODE (expression) == TREE_LIST)
17642 return any_value_dependent_elements_p (expression);
17644 return value_dependent_expression_p (expression);
17649 /* A `sizeof' expression is value-dependent if the operand is
17650 type-dependent or is a pack expansion. */
17651 expression = TREE_OPERAND (expression, 0);
17652 if (PACK_EXPANSION_P (expression))
17654 else if (TYPE_P (expression))
17655 return dependent_type_p (expression);
17656 return type_dependent_expression_p (expression);
17658 case NOEXCEPT_EXPR:
17659 expression = TREE_OPERAND (expression, 0);
17660 /* FIXME why check value-dependency? */
17661 return (type_dependent_expression_p (expression)
17662 || value_dependent_expression_p (expression));
17666 tree name = TREE_OPERAND (expression, 1);
17667 return value_dependent_expression_p (name);
17670 case COMPONENT_REF:
17671 return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
17672 || value_dependent_expression_p (TREE_OPERAND (expression, 1)));
17675 /* A CALL_EXPR may appear in a constant expression if it is a
17676 call to a builtin function, e.g., __builtin_constant_p. All
17677 such calls are value-dependent. */
17680 case NONTYPE_ARGUMENT_PACK:
17681 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
17682 is value-dependent. */
17684 tree values = ARGUMENT_PACK_ARGS (expression);
17685 int i, len = TREE_VEC_LENGTH (values);
17687 for (i = 0; i < len; ++i)
17688 if (value_dependent_expression_p (TREE_VEC_ELT (values, i)))
17696 tree type2 = TRAIT_EXPR_TYPE2 (expression);
17697 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression))
17698 || (type2 ? dependent_type_p (type2) : false));
17702 return ((value_dependent_expression_p (TREE_OPERAND (expression, 0)))
17703 || (value_dependent_expression_p (TREE_OPERAND (expression, 2))));
17707 tree op = TREE_OPERAND (expression, 0);
17708 return (value_dependent_expression_p (op)
17709 || has_value_dependent_address (op));
17713 /* A constant expression is value-dependent if any subexpression is
17714 value-dependent. */
17715 switch (TREE_CODE_CLASS (TREE_CODE (expression)))
17717 case tcc_reference:
17719 return (value_dependent_expression_p
17720 (TREE_OPERAND (expression, 0)));
17722 case tcc_comparison:
17724 return ((value_dependent_expression_p
17725 (TREE_OPERAND (expression, 0)))
17726 || (value_dependent_expression_p
17727 (TREE_OPERAND (expression, 1))));
17729 case tcc_expression:
17733 for (i = 0; i < TREE_OPERAND_LENGTH (expression); ++i)
17734 /* In some cases, some of the operands may be missing.
17735 (For example, in the case of PREDECREMENT_EXPR, the
17736 amount to increment by may be missing.) That doesn't
17737 make the expression dependent. */
17738 if (TREE_OPERAND (expression, i)
17739 && (value_dependent_expression_p
17740 (TREE_OPERAND (expression, i))))
17750 /* The expression is not value-dependent. */
17754 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
17755 [temp.dep.expr]. */
17758 type_dependent_expression_p (tree expression)
17760 if (!processing_template_decl)
17763 if (expression == error_mark_node)
17766 /* An unresolved name is always dependent. */
17767 if (TREE_CODE (expression) == IDENTIFIER_NODE
17768 || TREE_CODE (expression) == USING_DECL)
17771 /* Some expression forms are never type-dependent. */
17772 if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR
17773 || TREE_CODE (expression) == SIZEOF_EXPR
17774 || TREE_CODE (expression) == ALIGNOF_EXPR
17775 || TREE_CODE (expression) == NOEXCEPT_EXPR
17776 || TREE_CODE (expression) == TRAIT_EXPR
17777 || TREE_CODE (expression) == TYPEID_EXPR
17778 || TREE_CODE (expression) == DELETE_EXPR
17779 || TREE_CODE (expression) == VEC_DELETE_EXPR
17780 || TREE_CODE (expression) == THROW_EXPR)
17783 /* The types of these expressions depends only on the type to which
17784 the cast occurs. */
17785 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
17786 || TREE_CODE (expression) == STATIC_CAST_EXPR
17787 || TREE_CODE (expression) == CONST_CAST_EXPR
17788 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
17789 || TREE_CODE (expression) == CAST_EXPR)
17790 return dependent_type_p (TREE_TYPE (expression));
17792 /* The types of these expressions depends only on the type created
17793 by the expression. */
17794 if (TREE_CODE (expression) == NEW_EXPR
17795 || TREE_CODE (expression) == VEC_NEW_EXPR)
17797 /* For NEW_EXPR tree nodes created inside a template, either
17798 the object type itself or a TREE_LIST may appear as the
17800 tree type = TREE_OPERAND (expression, 1);
17801 if (TREE_CODE (type) == TREE_LIST)
17802 /* This is an array type. We need to check array dimensions
17804 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type)))
17805 || value_dependent_expression_p
17806 (TREE_OPERAND (TREE_VALUE (type), 1));
17808 return dependent_type_p (type);
17811 if (TREE_CODE (expression) == SCOPE_REF)
17813 tree scope = TREE_OPERAND (expression, 0);
17814 tree name = TREE_OPERAND (expression, 1);
17816 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
17817 contains an identifier associated by name lookup with one or more
17818 declarations declared with a dependent type, or...a
17819 nested-name-specifier or qualified-id that names a member of an
17820 unknown specialization. */
17821 return (type_dependent_expression_p (name)
17822 || dependent_scope_p (scope));
17825 if (TREE_CODE (expression) == FUNCTION_DECL
17826 && DECL_LANG_SPECIFIC (expression)
17827 && DECL_TEMPLATE_INFO (expression)
17828 && (any_dependent_template_arguments_p
17829 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
17832 if (TREE_CODE (expression) == TEMPLATE_DECL
17833 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression))
17836 if (TREE_CODE (expression) == STMT_EXPR)
17837 expression = stmt_expr_value_expr (expression);
17839 if (BRACE_ENCLOSED_INITIALIZER_P (expression))
17844 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression), i, elt)
17846 if (type_dependent_expression_p (elt))
17852 /* A static data member of the current instantiation with incomplete
17853 array type is type-dependent, as the definition and specializations
17854 can have different bounds. */
17855 if (TREE_CODE (expression) == VAR_DECL
17856 && DECL_CLASS_SCOPE_P (expression)
17857 && dependent_type_p (DECL_CONTEXT (expression))
17858 && VAR_HAD_UNKNOWN_BOUND (expression))
17861 if (TREE_TYPE (expression) == unknown_type_node)
17863 if (TREE_CODE (expression) == ADDR_EXPR)
17864 return type_dependent_expression_p (TREE_OPERAND (expression, 0));
17865 if (TREE_CODE (expression) == COMPONENT_REF
17866 || TREE_CODE (expression) == OFFSET_REF)
17868 if (type_dependent_expression_p (TREE_OPERAND (expression, 0)))
17870 expression = TREE_OPERAND (expression, 1);
17871 if (TREE_CODE (expression) == IDENTIFIER_NODE)
17874 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
17875 if (TREE_CODE (expression) == SCOPE_REF)
17878 if (TREE_CODE (expression) == BASELINK)
17879 expression = BASELINK_FUNCTIONS (expression);
17881 if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
17883 if (any_dependent_template_arguments_p
17884 (TREE_OPERAND (expression, 1)))
17886 expression = TREE_OPERAND (expression, 0);
17888 gcc_assert (TREE_CODE (expression) == OVERLOAD
17889 || TREE_CODE (expression) == FUNCTION_DECL);
17893 if (type_dependent_expression_p (OVL_CURRENT (expression)))
17895 expression = OVL_NEXT (expression);
17900 gcc_assert (TREE_CODE (expression) != TYPE_DECL);
17902 return (dependent_type_p (TREE_TYPE (expression)));
17905 /* Like type_dependent_expression_p, but it also works while not processing
17906 a template definition, i.e. during substitution or mangling. */
17909 type_dependent_expression_p_push (tree expr)
17912 ++processing_template_decl;
17913 b = type_dependent_expression_p (expr);
17914 --processing_template_decl;
17918 /* Returns TRUE if ARGS contains a type-dependent expression. */
17921 any_type_dependent_arguments_p (const VEC(tree,gc) *args)
17926 for (i = 0; VEC_iterate (tree, args, i, arg); ++i)
17928 if (type_dependent_expression_p (arg))
17934 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
17935 expressions) contains any value-dependent expressions. */
17938 any_value_dependent_elements_p (const_tree list)
17940 for (; list; list = TREE_CHAIN (list))
17941 if (value_dependent_expression_p (TREE_VALUE (list)))
17947 /* Returns TRUE if the ARG (a template argument) is dependent. */
17950 dependent_template_arg_p (tree arg)
17952 if (!processing_template_decl)
17955 if (TREE_CODE (arg) == TEMPLATE_DECL
17956 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
17957 return dependent_template_p (arg);
17958 else if (ARGUMENT_PACK_P (arg))
17960 tree args = ARGUMENT_PACK_ARGS (arg);
17961 int i, len = TREE_VEC_LENGTH (args);
17962 for (i = 0; i < len; ++i)
17964 if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
17970 else if (TYPE_P (arg))
17971 return dependent_type_p (arg);
17973 return (type_dependent_expression_p (arg)
17974 || value_dependent_expression_p (arg));
17977 /* Returns true if ARGS (a collection of template arguments) contains
17978 any types that require structural equality testing. */
17981 any_template_arguments_need_structural_equality_p (tree args)
17988 if (args == error_mark_node)
17991 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
17993 tree level = TMPL_ARGS_LEVEL (args, i + 1);
17994 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
17996 tree arg = TREE_VEC_ELT (level, j);
17997 tree packed_args = NULL_TREE;
18000 if (ARGUMENT_PACK_P (arg))
18002 /* Look inside the argument pack. */
18003 packed_args = ARGUMENT_PACK_ARGS (arg);
18004 len = TREE_VEC_LENGTH (packed_args);
18007 for (k = 0; k < len; ++k)
18010 arg = TREE_VEC_ELT (packed_args, k);
18012 if (error_operand_p (arg))
18014 else if (TREE_CODE (arg) == TEMPLATE_DECL
18015 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
18017 else if (TYPE_P (arg) && TYPE_STRUCTURAL_EQUALITY_P (arg))
18019 else if (!TYPE_P (arg) && TREE_TYPE (arg)
18020 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg)))
18029 /* Returns true if ARGS (a collection of template arguments) contains
18030 any dependent arguments. */
18033 any_dependent_template_arguments_p (const_tree args)
18040 if (args == error_mark_node)
18043 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
18045 const_tree level = TMPL_ARGS_LEVEL (args, i + 1);
18046 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
18047 if (dependent_template_arg_p (TREE_VEC_ELT (level, j)))
18054 /* Returns TRUE if the template TMPL is dependent. */
18057 dependent_template_p (tree tmpl)
18059 if (TREE_CODE (tmpl) == OVERLOAD)
18063 if (dependent_template_p (OVL_FUNCTION (tmpl)))
18065 tmpl = OVL_CHAIN (tmpl);
18070 /* Template template parameters are dependent. */
18071 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
18072 || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
18074 /* So are names that have not been looked up. */
18075 if (TREE_CODE (tmpl) == SCOPE_REF
18076 || TREE_CODE (tmpl) == IDENTIFIER_NODE)
18078 /* So are member templates of dependent classes. */
18079 if (TYPE_P (CP_DECL_CONTEXT (tmpl)))
18080 return dependent_type_p (DECL_CONTEXT (tmpl));
18084 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
18087 dependent_template_id_p (tree tmpl, tree args)
18089 return (dependent_template_p (tmpl)
18090 || any_dependent_template_arguments_p (args));
18093 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
18097 dependent_omp_for_p (tree declv, tree initv, tree condv, tree incrv)
18101 if (!processing_template_decl)
18104 for (i = 0; i < TREE_VEC_LENGTH (declv); i++)
18106 tree decl = TREE_VEC_ELT (declv, i);
18107 tree init = TREE_VEC_ELT (initv, i);
18108 tree cond = TREE_VEC_ELT (condv, i);
18109 tree incr = TREE_VEC_ELT (incrv, i);
18111 if (type_dependent_expression_p (decl))
18114 if (init && type_dependent_expression_p (init))
18117 if (type_dependent_expression_p (cond))
18120 if (COMPARISON_CLASS_P (cond)
18121 && (type_dependent_expression_p (TREE_OPERAND (cond, 0))
18122 || type_dependent_expression_p (TREE_OPERAND (cond, 1))))
18125 if (TREE_CODE (incr) == MODOP_EXPR)
18127 if (type_dependent_expression_p (TREE_OPERAND (incr, 0))
18128 || type_dependent_expression_p (TREE_OPERAND (incr, 2)))
18131 else if (type_dependent_expression_p (incr))
18133 else if (TREE_CODE (incr) == MODIFY_EXPR)
18135 if (type_dependent_expression_p (TREE_OPERAND (incr, 0)))
18137 else if (BINARY_CLASS_P (TREE_OPERAND (incr, 1)))
18139 tree t = TREE_OPERAND (incr, 1);
18140 if (type_dependent_expression_p (TREE_OPERAND (t, 0))
18141 || type_dependent_expression_p (TREE_OPERAND (t, 1)))
18150 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
18151 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
18152 no such TYPE can be found. Note that this function peers inside
18153 uninstantiated templates and therefore should be used only in
18154 extremely limited situations. ONLY_CURRENT_P restricts this
18155 peering to the currently open classes hierarchy (which is required
18156 when comparing types). */
18159 resolve_typename_type (tree type, bool only_current_p)
18168 gcc_assert (TREE_CODE (type) == TYPENAME_TYPE);
18170 scope = TYPE_CONTEXT (type);
18171 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
18172 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
18173 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
18174 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
18175 identifier of the TYPENAME_TYPE anymore.
18176 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
18177 TYPENAME_TYPE instead, we avoid messing up with a possible
18178 typedef variant case. */
18179 name = TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
18181 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
18182 it first before we can figure out what NAME refers to. */
18183 if (TREE_CODE (scope) == TYPENAME_TYPE)
18184 scope = resolve_typename_type (scope, only_current_p);
18185 /* If we don't know what SCOPE refers to, then we cannot resolve the
18187 if (TREE_CODE (scope) == TYPENAME_TYPE)
18189 /* If the SCOPE is a template type parameter, we have no way of
18190 resolving the name. */
18191 if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
18193 /* If the SCOPE is not the current instantiation, there's no reason
18194 to look inside it. */
18195 if (only_current_p && !currently_open_class (scope))
18197 /* If this is a typedef, we don't want to look inside (c++/11987). */
18198 if (typedef_variant_p (type))
18200 /* If SCOPE isn't the template itself, it will not have a valid
18201 TYPE_FIELDS list. */
18202 if (same_type_p (scope, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope)))
18203 /* scope is either the template itself or a compatible instantiation
18204 like X<T>, so look up the name in the original template. */
18205 scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope);
18207 /* scope is a partial instantiation, so we can't do the lookup or we
18208 will lose the template arguments. */
18210 /* Enter the SCOPE so that name lookup will be resolved as if we
18211 were in the class definition. In particular, SCOPE will no
18212 longer be considered a dependent type. */
18213 pushed_scope = push_scope (scope);
18214 /* Look up the declaration. */
18215 decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true);
18217 result = NULL_TREE;
18219 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
18220 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
18223 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE
18224 && TREE_CODE (decl) == TYPE_DECL)
18226 result = TREE_TYPE (decl);
18227 if (result == error_mark_node)
18228 result = NULL_TREE;
18230 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR
18231 && DECL_CLASS_TEMPLATE_P (decl))
18235 /* Obtain the template and the arguments. */
18236 tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0);
18237 args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1);
18238 /* Instantiate the template. */
18239 result = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE,
18240 /*entering_scope=*/0,
18241 tf_error | tf_user);
18242 if (result == error_mark_node)
18243 result = NULL_TREE;
18246 /* Leave the SCOPE. */
18248 pop_scope (pushed_scope);
18250 /* If we failed to resolve it, return the original typename. */
18254 /* If lookup found a typename type, resolve that too. */
18255 if (TREE_CODE (result) == TYPENAME_TYPE && !TYPENAME_IS_RESOLVING_P (result))
18257 /* Ill-formed programs can cause infinite recursion here, so we
18258 must catch that. */
18259 TYPENAME_IS_RESOLVING_P (type) = 1;
18260 result = resolve_typename_type (result, only_current_p);
18261 TYPENAME_IS_RESOLVING_P (type) = 0;
18264 /* Qualify the resulting type. */
18265 quals = cp_type_quals (type);
18267 result = cp_build_qualified_type (result, cp_type_quals (result) | quals);
18272 /* EXPR is an expression which is not type-dependent. Return a proxy
18273 for EXPR that can be used to compute the types of larger
18274 expressions containing EXPR. */
18277 build_non_dependent_expr (tree expr)
18281 /* Preserve null pointer constants so that the type of things like
18282 "p == 0" where "p" is a pointer can be determined. */
18283 if (null_ptr_cst_p (expr))
18285 /* Preserve OVERLOADs; the functions must be available to resolve
18288 if (TREE_CODE (inner_expr) == STMT_EXPR)
18289 inner_expr = stmt_expr_value_expr (inner_expr);
18290 if (TREE_CODE (inner_expr) == ADDR_EXPR)
18291 inner_expr = TREE_OPERAND (inner_expr, 0);
18292 if (TREE_CODE (inner_expr) == COMPONENT_REF)
18293 inner_expr = TREE_OPERAND (inner_expr, 1);
18294 if (is_overloaded_fn (inner_expr)
18295 || TREE_CODE (inner_expr) == OFFSET_REF)
18297 /* There is no need to return a proxy for a variable. */
18298 if (TREE_CODE (expr) == VAR_DECL)
18300 /* Preserve string constants; conversions from string constants to
18301 "char *" are allowed, even though normally a "const char *"
18302 cannot be used to initialize a "char *". */
18303 if (TREE_CODE (expr) == STRING_CST)
18305 /* Preserve arithmetic constants, as an optimization -- there is no
18306 reason to create a new node. */
18307 if (TREE_CODE (expr) == INTEGER_CST || TREE_CODE (expr) == REAL_CST)
18309 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
18310 There is at least one place where we want to know that a
18311 particular expression is a throw-expression: when checking a ?:
18312 expression, there are special rules if the second or third
18313 argument is a throw-expression. */
18314 if (TREE_CODE (expr) == THROW_EXPR)
18317 if (TREE_CODE (expr) == COND_EXPR)
18318 return build3 (COND_EXPR,
18320 TREE_OPERAND (expr, 0),
18321 (TREE_OPERAND (expr, 1)
18322 ? build_non_dependent_expr (TREE_OPERAND (expr, 1))
18323 : build_non_dependent_expr (TREE_OPERAND (expr, 0))),
18324 build_non_dependent_expr (TREE_OPERAND (expr, 2)));
18325 if (TREE_CODE (expr) == COMPOUND_EXPR
18326 && !COMPOUND_EXPR_OVERLOADED (expr))
18327 return build2 (COMPOUND_EXPR,
18329 TREE_OPERAND (expr, 0),
18330 build_non_dependent_expr (TREE_OPERAND (expr, 1)));
18332 /* If the type is unknown, it can't really be non-dependent */
18333 gcc_assert (TREE_TYPE (expr) != unknown_type_node);
18335 /* Otherwise, build a NON_DEPENDENT_EXPR.
18337 REFERENCE_TYPEs are not stripped for expressions in templates
18338 because doing so would play havoc with mangling. Consider, for
18341 template <typename T> void f<T& g>() { g(); }
18343 In the body of "f", the expression for "g" will have
18344 REFERENCE_TYPE, even though the standard says that it should
18345 not. The reason is that we must preserve the syntactic form of
18346 the expression so that mangling (say) "f<g>" inside the body of
18347 "f" works out correctly. Therefore, the REFERENCE_TYPE is
18349 return build1 (NON_DEPENDENT_EXPR, non_reference (TREE_TYPE (expr)), expr);
18352 /* ARGS is a vector of expressions as arguments to a function call.
18353 Replace the arguments with equivalent non-dependent expressions.
18354 This modifies ARGS in place. */
18357 make_args_non_dependent (VEC(tree,gc) *args)
18362 for (ix = 0; VEC_iterate (tree, args, ix, arg); ++ix)
18364 tree newarg = build_non_dependent_expr (arg);
18366 VEC_replace (tree, args, ix, newarg);
18370 /* Returns a type which represents 'auto'. We use a TEMPLATE_TYPE_PARM
18371 with a level one deeper than the actual template parms. */
18376 tree au = cxx_make_type (TEMPLATE_TYPE_PARM);
18377 TYPE_NAME (au) = build_decl (BUILTINS_LOCATION,
18378 TYPE_DECL, get_identifier ("auto"), au);
18379 TYPE_STUB_DECL (au) = TYPE_NAME (au);
18380 TEMPLATE_TYPE_PARM_INDEX (au) = build_template_parm_index
18381 (0, processing_template_decl + 1, processing_template_decl + 1,
18382 TYPE_NAME (au), NULL_TREE);
18383 TYPE_CANONICAL (au) = canonical_type_parameter (au);
18384 DECL_ARTIFICIAL (TYPE_NAME (au)) = 1;
18385 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au));
18390 /* Given type ARG, return std::initializer_list<ARG>. */
18395 tree std_init_list = namespace_binding
18396 (get_identifier ("initializer_list"), std_node);
18398 if (!std_init_list || !DECL_CLASS_TEMPLATE_P (std_init_list))
18400 error ("deducing from brace-enclosed initializer list requires "
18401 "#include <initializer_list>");
18402 return error_mark_node;
18404 argvec = make_tree_vec (1);
18405 TREE_VEC_ELT (argvec, 0) = arg;
18406 return lookup_template_class (std_init_list, argvec, NULL_TREE,
18407 NULL_TREE, 0, tf_warning_or_error);
18410 /* Replace auto in TYPE with std::initializer_list<auto>. */
18413 listify_autos (tree type, tree auto_node)
18415 tree init_auto = listify (auto_node);
18416 tree argvec = make_tree_vec (1);
18417 TREE_VEC_ELT (argvec, 0) = init_auto;
18418 if (processing_template_decl)
18419 argvec = add_to_template_args (current_template_args (), argvec);
18420 return tsubst (type, argvec, tf_warning_or_error, NULL_TREE);
18423 /* walk_tree helper for do_auto_deduction. */
18426 contains_auto_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
18429 /* Is this a variable with the type we're looking for? */
18431 && TREE_TYPE (*tp) == type)
18437 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
18438 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
18441 do_auto_deduction (tree type, tree init, tree auto_node)
18443 tree parms, tparms, targs;
18448 /* The name of the object being declared shall not appear in the
18449 initializer expression. */
18450 decl = cp_walk_tree_without_duplicates (&init, contains_auto_r, type);
18453 error ("variable %q#D with %<auto%> type used in its own "
18454 "initializer", decl);
18455 return error_mark_node;
18458 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
18459 with either a new invented type template parameter U or, if the
18460 initializer is a braced-init-list (8.5.4), with
18461 std::initializer_list<U>. */
18462 if (BRACE_ENCLOSED_INITIALIZER_P (init))
18463 type = listify_autos (type, auto_node);
18465 parms = build_tree_list (NULL_TREE, type);
18467 tparms = make_tree_vec (1);
18468 targs = make_tree_vec (1);
18469 TREE_VEC_ELT (tparms, 0)
18470 = build_tree_list (NULL_TREE, TYPE_NAME (auto_node));
18471 val = type_unification_real (tparms, targs, parms, args, 1, 0,
18472 DEDUCE_CALL, LOOKUP_NORMAL);
18475 error ("unable to deduce %qT from %qE", type, init);
18476 return error_mark_node;
18479 /* If the list of declarators contains more than one declarator, the type
18480 of each declared variable is determined as described above. If the
18481 type deduced for the template parameter U is not the same in each
18482 deduction, the program is ill-formed. */
18483 if (TREE_TYPE (auto_node)
18484 && !same_type_p (TREE_TYPE (auto_node), TREE_VEC_ELT (targs, 0)))
18486 error ("inconsistent deduction for %qT: %qT and then %qT",
18487 auto_node, TREE_TYPE (auto_node), TREE_VEC_ELT (targs, 0));
18488 return error_mark_node;
18490 TREE_TYPE (auto_node) = TREE_VEC_ELT (targs, 0);
18492 if (processing_template_decl)
18493 targs = add_to_template_args (current_template_args (), targs);
18494 return tsubst (type, targs, tf_warning_or_error, NULL_TREE);
18497 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
18501 splice_late_return_type (tree type, tree late_return_type)
18505 if (late_return_type == NULL_TREE)
18507 argvec = make_tree_vec (1);
18508 TREE_VEC_ELT (argvec, 0) = late_return_type;
18509 if (processing_template_decl)
18510 argvec = add_to_template_args (current_template_args (), argvec);
18511 return tsubst (type, argvec, tf_warning_or_error, NULL_TREE);
18514 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto'. */
18517 is_auto (const_tree type)
18519 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
18520 && TYPE_IDENTIFIER (type) == get_identifier ("auto"))
18526 /* Returns true iff TYPE contains a use of 'auto'. Since auto can only
18527 appear as a type-specifier for the declaration in question, we don't
18528 have to look through the whole type. */
18531 type_uses_auto (tree type)
18533 enum tree_code code;
18534 if (is_auto (type))
18537 code = TREE_CODE (type);
18539 if (code == POINTER_TYPE || code == REFERENCE_TYPE
18540 || code == OFFSET_TYPE || code == FUNCTION_TYPE
18541 || code == METHOD_TYPE || code == ARRAY_TYPE)
18542 return type_uses_auto (TREE_TYPE (type));
18544 if (TYPE_PTRMEMFUNC_P (type))
18545 return type_uses_auto (TREE_TYPE (TREE_TYPE
18546 (TYPE_PTRMEMFUNC_FN_TYPE (type))));
18551 /* For a given template T, return the vector of typedefs referenced
18552 in T for which access check is needed at T instantiation time.
18553 T is either a FUNCTION_DECL or a RECORD_TYPE.
18554 Those typedefs were added to T by the function
18555 append_type_to_template_for_access_check. */
18557 VEC(qualified_typedef_usage_t,gc)*
18558 get_types_needing_access_check (tree t)
18561 VEC(qualified_typedef_usage_t,gc) *result = NULL;
18563 if (!t || t == error_mark_node)
18566 if (!(ti = get_template_info (t)))
18569 if (CLASS_TYPE_P (t)
18570 || TREE_CODE (t) == FUNCTION_DECL)
18572 if (!TI_TEMPLATE (ti))
18575 result = TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti);
18581 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
18582 tied to T. That list of typedefs will be access checked at
18583 T instantiation time.
18584 T is either a FUNCTION_DECL or a RECORD_TYPE.
18585 TYPE_DECL is a TYPE_DECL node representing a typedef.
18586 SCOPE is the scope through which TYPE_DECL is accessed.
18587 LOCATION is the location of the usage point of TYPE_DECL.
18589 This function is a subroutine of
18590 append_type_to_template_for_access_check. */
18593 append_type_to_template_for_access_check_1 (tree t,
18596 location_t location)
18598 qualified_typedef_usage_t typedef_usage;
18601 if (!t || t == error_mark_node)
18604 gcc_assert ((TREE_CODE (t) == FUNCTION_DECL
18605 || CLASS_TYPE_P (t))
18607 && TREE_CODE (type_decl) == TYPE_DECL
18610 if (!(ti = get_template_info (t)))
18613 gcc_assert (TI_TEMPLATE (ti));
18615 typedef_usage.typedef_decl = type_decl;
18616 typedef_usage.context = scope;
18617 typedef_usage.locus = location;
18619 VEC_safe_push (qualified_typedef_usage_t, gc,
18620 TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti),
18624 /* Append TYPE_DECL to the template TEMPL.
18625 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
18626 At TEMPL instanciation time, TYPE_DECL will be checked to see
18627 if it can be accessed through SCOPE.
18628 LOCATION is the location of the usage point of TYPE_DECL.
18630 e.g. consider the following code snippet:
18637 template<class U> struct S
18639 C::myint mi; // <-- usage point of the typedef C::myint
18644 At S<char> instantiation time, we need to check the access of C::myint
18645 In other words, we need to check the access of the myint typedef through
18646 the C scope. For that purpose, this function will add the myint typedef
18647 and the scope C through which its being accessed to a list of typedefs
18648 tied to the template S. That list will be walked at template instantiation
18649 time and access check performed on each typedefs it contains.
18650 Note that this particular code snippet should yield an error because
18651 myint is private to C. */
18654 append_type_to_template_for_access_check (tree templ,
18657 location_t location)
18659 qualified_typedef_usage_t *iter;
18662 gcc_assert (type_decl && (TREE_CODE (type_decl) == TYPE_DECL));
18664 /* Make sure we don't append the type to the template twice. */
18666 VEC_iterate (qualified_typedef_usage_t,
18667 get_types_needing_access_check (templ),
18670 if (iter->typedef_decl == type_decl && scope == iter->context)
18673 append_type_to_template_for_access_check_1 (templ, type_decl,
18677 /* Set up the hash tables for template instantiations. */
18680 init_template_processing (void)
18682 decl_specializations = htab_create_ggc (37,
18683 hash_specialization,
18684 eq_specializations,
18686 type_specializations = htab_create_ggc (37,
18687 hash_specialization,
18688 eq_specializations,
18692 /* Print stats about the template hash tables for -fstats. */
18695 print_template_statistics (void)
18697 fprintf (stderr, "decl_specializations: size %ld, %ld elements, "
18698 "%f collisions\n", (long) htab_size (decl_specializations),
18699 (long) htab_elements (decl_specializations),
18700 htab_collisions (decl_specializations));
18701 fprintf (stderr, "type_specializations: size %ld, %ld elements, "
18702 "%f collisions\n", (long) htab_size (type_specializations),
18703 (long) htab_elements (type_specializations),
18704 htab_collisions (type_specializations));
18707 #include "gt-cp-pt.h"