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 Free Software Foundation, Inc.
4 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
5 Rewritten by Jason Merrill (jason@cygnus.com).
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 /* Known bugs or deficiencies include:
25 all methods must be provided in header files; can't use a source
26 file that contains only the method templates and "just win". */
30 #include "coretypes.h"
34 #include "pointer-set.h"
38 #include "cp-objcp-common.h"
39 #include "tree-inline.h"
46 #include "tree-iterator.h"
49 /* The type of functions taking a tree, and some additional data, and
51 typedef int (*tree_fn_t) (tree, void*);
53 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
54 instantiations have been deferred, either because their definitions
55 were not yet available, or because we were putting off doing the work. */
56 struct pending_template GTY (()) {
57 struct pending_template *next;
58 struct tinst_level *tinst;
61 static GTY(()) struct pending_template *pending_templates;
62 static GTY(()) struct pending_template *last_pending_template;
64 int processing_template_parmlist;
65 static int template_header_count;
67 static GTY(()) tree saved_trees;
68 static VEC(int,heap) *inline_parm_levels;
70 static GTY(()) struct tinst_level *current_tinst_level;
72 static GTY(()) tree saved_access_scope;
74 /* Live only within one (recursive) call to tsubst_expr. We use
75 this to pass the statement expression node from the STMT_EXPR
76 to the EXPR_STMT that is its result. */
77 static tree cur_stmt_expr;
79 /* A map from local variable declarations in the body of the template
80 presently being instantiated to the corresponding instantiated
82 static htab_t local_specializations;
84 /* Contains canonical template parameter types. The vector is indexed by
85 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
86 TREE_LIST, whose TREE_VALUEs contain the canonical template
87 parameters of various types and levels. */
88 static GTY(()) VEC(tree,gc) *canonical_template_parms;
90 #define UNIFY_ALLOW_NONE 0
91 #define UNIFY_ALLOW_MORE_CV_QUAL 1
92 #define UNIFY_ALLOW_LESS_CV_QUAL 2
93 #define UNIFY_ALLOW_DERIVED 4
94 #define UNIFY_ALLOW_INTEGER 8
95 #define UNIFY_ALLOW_OUTER_LEVEL 16
96 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
97 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
99 static void push_access_scope (tree);
100 static void pop_access_scope (tree);
101 static bool resolve_overloaded_unification (tree, tree, tree, tree,
102 unification_kind_t, int);
103 static int try_one_overload (tree, tree, tree, tree, tree,
104 unification_kind_t, int, bool);
105 static int unify (tree, tree, tree, tree, int);
106 static void add_pending_template (tree);
107 static int push_tinst_level (tree);
108 static void pop_tinst_level (void);
109 static tree reopen_tinst_level (struct tinst_level *);
110 static tree tsubst_initializer_list (tree, tree);
111 static tree get_class_bindings (tree, tree, tree);
112 static tree coerce_template_parms (tree, tree, tree, tsubst_flags_t,
114 static void tsubst_enum (tree, tree, tree);
115 static tree add_to_template_args (tree, tree);
116 static tree add_outermost_template_args (tree, tree);
117 static bool check_instantiated_args (tree, tree, tsubst_flags_t);
118 static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*,
120 static int type_unification_real (tree, tree, tree, tree,
121 int, unification_kind_t, int);
122 static void note_template_header (int);
123 static tree convert_nontype_argument_function (tree, tree);
124 static tree convert_nontype_argument (tree, tree);
125 static tree convert_template_argument (tree, tree, tree,
126 tsubst_flags_t, int, tree);
127 static int for_each_template_parm (tree, tree_fn_t, void*,
128 struct pointer_set_t*);
129 static tree expand_template_argument_pack (tree);
130 static tree build_template_parm_index (int, int, int, tree, tree);
131 static bool inline_needs_template_parms (tree);
132 static void push_inline_template_parms_recursive (tree, int);
133 static tree retrieve_local_specialization (tree);
134 static void register_local_specialization (tree, tree);
135 static tree reduce_template_parm_level (tree, tree, int, tree, tsubst_flags_t);
136 static int mark_template_parm (tree, void *);
137 static int template_parm_this_level_p (tree, void *);
138 static tree tsubst_friend_function (tree, tree);
139 static tree tsubst_friend_class (tree, tree);
140 static int can_complete_type_without_circularity (tree);
141 static tree get_bindings (tree, tree, tree, bool);
142 static int template_decl_level (tree);
143 static int check_cv_quals_for_unify (int, tree, tree);
144 static void template_parm_level_and_index (tree, int*, int*);
145 static int unify_pack_expansion (tree, tree, tree, tree, int, bool, bool);
146 static tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree);
147 static tree tsubst_template_args (tree, tree, tsubst_flags_t, tree);
148 static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
149 static void regenerate_decl_from_template (tree, tree);
150 static tree most_specialized_class (tree, tree);
151 static tree tsubst_aggr_type (tree, tree, tsubst_flags_t, tree, int);
152 static tree tsubst_arg_types (tree, tree, tsubst_flags_t, tree);
153 static tree tsubst_function_type (tree, tree, tsubst_flags_t, tree);
154 static bool check_specialization_scope (void);
155 static tree process_partial_specialization (tree);
156 static void set_current_access_from_decl (tree);
157 static tree get_template_base (tree, tree, tree, tree);
158 static tree try_class_unification (tree, tree, tree, tree);
159 static int coerce_template_template_parms (tree, tree, tsubst_flags_t,
161 static int template_args_equal (tree, tree);
162 static void tsubst_default_arguments (tree);
163 static tree for_each_template_parm_r (tree *, int *, void *);
164 static tree copy_default_args_to_explicit_spec_1 (tree, tree);
165 static void copy_default_args_to_explicit_spec (tree);
166 static int invalid_nontype_parm_type_p (tree, tsubst_flags_t);
167 static int eq_local_specializations (const void *, const void *);
168 static bool dependent_template_arg_p (tree);
169 static bool any_template_arguments_need_structural_equality_p (tree);
170 static bool dependent_type_p_r (tree);
171 static tree tsubst (tree, tree, tsubst_flags_t, tree);
172 static tree tsubst_expr (tree, tree, tsubst_flags_t, tree, bool);
173 static tree tsubst_copy (tree, tree, tsubst_flags_t, tree);
174 static tree tsubst_pack_expansion (tree, tree, tsubst_flags_t, tree);
176 /* Make the current scope suitable for access checking when we are
177 processing T. T can be FUNCTION_DECL for instantiated function
178 template, or VAR_DECL for static member variable (need by
179 instantiate_decl). */
182 push_access_scope (tree t)
184 gcc_assert (TREE_CODE (t) == FUNCTION_DECL
185 || TREE_CODE (t) == VAR_DECL);
187 if (DECL_FRIEND_CONTEXT (t))
188 push_nested_class (DECL_FRIEND_CONTEXT (t));
189 else if (DECL_CLASS_SCOPE_P (t))
190 push_nested_class (DECL_CONTEXT (t));
192 push_to_top_level ();
194 if (TREE_CODE (t) == FUNCTION_DECL)
196 saved_access_scope = tree_cons
197 (NULL_TREE, current_function_decl, saved_access_scope);
198 current_function_decl = t;
202 /* Restore the scope set up by push_access_scope. T is the node we
206 pop_access_scope (tree t)
208 if (TREE_CODE (t) == FUNCTION_DECL)
210 current_function_decl = TREE_VALUE (saved_access_scope);
211 saved_access_scope = TREE_CHAIN (saved_access_scope);
214 if (DECL_FRIEND_CONTEXT (t) || DECL_CLASS_SCOPE_P (t))
217 pop_from_top_level ();
220 /* Do any processing required when DECL (a member template
221 declaration) is finished. Returns the TEMPLATE_DECL corresponding
222 to DECL, unless it is a specialization, in which case the DECL
223 itself is returned. */
226 finish_member_template_decl (tree decl)
228 if (decl == error_mark_node)
229 return error_mark_node;
231 gcc_assert (DECL_P (decl));
233 if (TREE_CODE (decl) == TYPE_DECL)
237 type = TREE_TYPE (decl);
238 if (IS_AGGR_TYPE (type)
239 && CLASSTYPE_TEMPLATE_INFO (type)
240 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
242 tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
243 check_member_template (tmpl);
248 else if (TREE_CODE (decl) == FIELD_DECL)
249 error ("data member %qD cannot be a member template", decl);
250 else if (DECL_TEMPLATE_INFO (decl))
252 if (!DECL_TEMPLATE_SPECIALIZATION (decl))
254 check_member_template (DECL_TI_TEMPLATE (decl));
255 return DECL_TI_TEMPLATE (decl);
261 error ("invalid member template declaration %qD", decl);
263 return error_mark_node;
266 /* Return the template info node corresponding to T, whatever T is. */
269 get_template_info (tree t)
271 tree tinfo = NULL_TREE;
273 if (DECL_P (t) && DECL_LANG_SPECIFIC (t))
274 tinfo = DECL_TEMPLATE_INFO (t);
276 if (!tinfo && TREE_CODE (t) == TYPE_DECL)
279 if (TAGGED_TYPE_P (t))
280 tinfo = TYPE_TEMPLATE_INFO (t);
285 /* Returns the template nesting level of the indicated class TYPE.
295 A<T>::B<U> has depth two, while A<T> has depth one.
296 Both A<T>::B<int> and A<int>::B<U> have depth one, if
297 they are instantiations, not specializations.
299 This function is guaranteed to return 0 if passed NULL_TREE so
300 that, for example, `template_class_depth (current_class_type)' is
304 template_class_depth (tree type)
309 type && TREE_CODE (type) != NAMESPACE_DECL;
310 type = (TREE_CODE (type) == FUNCTION_DECL)
311 ? CP_DECL_CONTEXT (type) : TYPE_CONTEXT (type))
313 tree tinfo = get_template_info (type);
315 if (tinfo && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo))
316 && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo))))
323 /* Subroutine of maybe_begin_member_template_processing.
324 Returns true if processing DECL needs us to push template parms. */
327 inline_needs_template_parms (tree decl)
329 if (! DECL_TEMPLATE_INFO (decl))
332 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl)))
333 > (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl)));
336 /* Subroutine of maybe_begin_member_template_processing.
337 Push the template parms in PARMS, starting from LEVELS steps into the
338 chain, and ending at the beginning, since template parms are listed
342 push_inline_template_parms_recursive (tree parmlist, int levels)
344 tree parms = TREE_VALUE (parmlist);
348 push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1);
350 ++processing_template_decl;
351 current_template_parms
352 = tree_cons (size_int (processing_template_decl),
353 parms, current_template_parms);
354 TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1;
356 begin_scope (TREE_VEC_LENGTH (parms) ? sk_template_parms : sk_template_spec,
358 for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
360 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
362 if (parm == error_mark_node)
365 gcc_assert (DECL_P (parm));
367 switch (TREE_CODE (parm))
376 /* Make a CONST_DECL as is done in process_template_parm.
377 It is ugly that we recreate this here; the original
378 version built in process_template_parm is no longer
380 tree decl = build_decl (CONST_DECL, DECL_NAME (parm),
382 DECL_ARTIFICIAL (decl) = 1;
383 TREE_CONSTANT (decl) = 1;
384 TREE_INVARIANT (decl) = 1;
385 TREE_READONLY (decl) = 1;
386 DECL_INITIAL (decl) = DECL_INITIAL (parm);
387 SET_DECL_TEMPLATE_PARM_P (decl);
398 /* Restore the template parameter context for a member template or
399 a friend template defined in a class definition. */
402 maybe_begin_member_template_processing (tree decl)
407 if (inline_needs_template_parms (decl))
409 parms = DECL_TEMPLATE_PARMS (most_general_template (decl));
410 levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl;
412 if (DECL_TEMPLATE_SPECIALIZATION (decl))
415 parms = TREE_CHAIN (parms);
418 push_inline_template_parms_recursive (parms, levels);
421 /* Remember how many levels of template parameters we pushed so that
422 we can pop them later. */
423 VEC_safe_push (int, heap, inline_parm_levels, levels);
426 /* Undo the effects of maybe_begin_member_template_processing. */
429 maybe_end_member_template_processing (void)
434 if (VEC_length (int, inline_parm_levels) == 0)
437 last = VEC_pop (int, inline_parm_levels);
438 for (i = 0; i < last; ++i)
440 --processing_template_decl;
441 current_template_parms = TREE_CHAIN (current_template_parms);
446 /* Return a new template argument vector which contains all of ARGS,
447 but has as its innermost set of arguments the EXTRA_ARGS. */
450 add_to_template_args (tree args, tree extra_args)
457 extra_depth = TMPL_ARGS_DEPTH (extra_args);
458 new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth);
460 for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i)
461 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));
463 for (j = 1; j <= extra_depth; ++j, ++i)
464 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));
469 /* Like add_to_template_args, but only the outermost ARGS are added to
470 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
471 (EXTRA_ARGS) levels are added. This function is used to combine
472 the template arguments from a partial instantiation with the
473 template arguments used to attain the full instantiation from the
474 partial instantiation. */
477 add_outermost_template_args (tree args, tree extra_args)
481 /* If there are more levels of EXTRA_ARGS than there are ARGS,
482 something very fishy is going on. */
483 gcc_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args));
485 /* If *all* the new arguments will be the EXTRA_ARGS, just return
487 if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
490 /* For the moment, we make ARGS look like it contains fewer levels. */
491 TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);
493 new_args = add_to_template_args (args, extra_args);
495 /* Now, we restore ARGS to its full dimensions. */
496 TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);
501 /* Return the N levels of innermost template arguments from the ARGS. */
504 get_innermost_template_args (tree args, int n)
512 /* If N is 1, just return the innermost set of template arguments. */
514 return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args));
516 /* If we're not removing anything, just return the arguments we were
518 extra_levels = TMPL_ARGS_DEPTH (args) - n;
519 gcc_assert (extra_levels >= 0);
520 if (extra_levels == 0)
523 /* Make a new set of arguments, not containing the outer arguments. */
524 new_args = make_tree_vec (n);
525 for (i = 1; i <= n; ++i)
526 SET_TMPL_ARGS_LEVEL (new_args, i,
527 TMPL_ARGS_LEVEL (args, i + extra_levels));
532 /* The inverse of get_innermost_template_args: Return all but the innermost
533 EXTRA_LEVELS levels of template arguments from the ARGS. */
536 strip_innermost_template_args (tree args, int extra_levels)
539 int n = TMPL_ARGS_DEPTH (args) - extra_levels;
544 /* If N is 1, just return the outermost set of template arguments. */
546 return TMPL_ARGS_LEVEL (args, 1);
548 /* If we're not removing anything, just return the arguments we were
550 gcc_assert (extra_levels >= 0);
551 if (extra_levels == 0)
554 /* Make a new set of arguments, not containing the inner arguments. */
555 new_args = make_tree_vec (n);
556 for (i = 1; i <= n; ++i)
557 SET_TMPL_ARGS_LEVEL (new_args, i,
558 TMPL_ARGS_LEVEL (args, i));
563 /* We've got a template header coming up; push to a new level for storing
567 begin_template_parm_list (void)
569 /* We use a non-tag-transparent scope here, which causes pushtag to
570 put tags in this scope, rather than in the enclosing class or
571 namespace scope. This is the right thing, since we want
572 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
573 global template class, push_template_decl handles putting the
574 TEMPLATE_DECL into top-level scope. For a nested template class,
577 template <class T> struct S1 {
578 template <class T> struct S2 {};
581 pushtag contains special code to call pushdecl_with_scope on the
582 TEMPLATE_DECL for S2. */
583 begin_scope (sk_template_parms, NULL);
584 ++processing_template_decl;
585 ++processing_template_parmlist;
586 note_template_header (0);
589 /* This routine is called when a specialization is declared. If it is
590 invalid to declare a specialization here, an error is reported and
591 false is returned, otherwise this routine will return true. */
594 check_specialization_scope (void)
596 tree scope = current_scope ();
600 An explicit specialization shall be declared in the namespace of
601 which the template is a member, or, for member templates, in the
602 namespace of which the enclosing class or enclosing class
603 template is a member. An explicit specialization of a member
604 function, member class or static data member of a class template
605 shall be declared in the namespace of which the class template
607 if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
609 error ("explicit specialization in non-namespace scope %qD", scope);
615 In an explicit specialization declaration for a member of a class
616 template or a member template that appears in namespace scope,
617 the member template and some of its enclosing class templates may
618 remain unspecialized, except that the declaration shall not
619 explicitly specialize a class member template if its enclosing
620 class templates are not explicitly specialized as well. */
621 if (current_template_parms)
623 error ("enclosing class templates are not explicitly specialized");
630 /* We've just seen template <>. */
633 begin_specialization (void)
635 begin_scope (sk_template_spec, NULL);
636 note_template_header (1);
637 return check_specialization_scope ();
640 /* Called at then end of processing a declaration preceded by
644 end_specialization (void)
647 reset_specialization ();
650 /* Any template <>'s that we have seen thus far are not referring to a
651 function specialization. */
654 reset_specialization (void)
656 processing_specialization = 0;
657 template_header_count = 0;
660 /* We've just seen a template header. If SPECIALIZATION is nonzero,
661 it was of the form template <>. */
664 note_template_header (int specialization)
666 processing_specialization = specialization;
667 template_header_count++;
670 /* We're beginning an explicit instantiation. */
673 begin_explicit_instantiation (void)
675 gcc_assert (!processing_explicit_instantiation);
676 processing_explicit_instantiation = true;
681 end_explicit_instantiation (void)
683 gcc_assert (processing_explicit_instantiation);
684 processing_explicit_instantiation = false;
687 /* An explicit specialization or partial specialization TMPL is being
688 declared. Check that the namespace in which the specialization is
689 occurring is permissible. Returns false iff it is invalid to
690 specialize TMPL in the current namespace. */
693 check_specialization_namespace (tree tmpl)
695 tree tpl_ns = decl_namespace_context (tmpl);
699 An explicit specialization shall be declared in the namespace of
700 which the template is a member, or, for member templates, in the
701 namespace of which the enclosing class or enclosing class
702 template is a member. An explicit specialization of a member
703 function, member class or static data member of a class template
704 shall be declared in the namespace of which the class template is
706 if (is_associated_namespace (current_namespace, tpl_ns))
707 /* Same or super-using namespace. */
711 pedwarn ("specialization of %qD in different namespace", tmpl);
712 pedwarn (" from definition of %q+#D", tmpl);
717 /* SPEC is an explicit instantiation. Check that it is valid to
718 perform this explicit instantiation in the current namespace. */
721 check_explicit_instantiation_namespace (tree spec)
725 /* DR 275: An explicit instantiation shall appear in an enclosing
726 namespace of its template. */
727 ns = decl_namespace_context (spec);
728 if (!is_ancestor (current_namespace, ns))
729 pedwarn ("explicit instantiation of %qD in namespace %qD "
730 "(which does not enclose namespace %qD)",
731 spec, current_namespace, ns);
734 /* The TYPE is being declared. If it is a template type, that means it
735 is a partial specialization. Do appropriate error-checking. */
738 maybe_process_partial_specialization (tree type)
742 if (type == error_mark_node)
743 return error_mark_node;
745 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
747 error ("name of class shadows template template parameter %qD",
749 return error_mark_node;
752 context = TYPE_CONTEXT (type);
754 if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type))
756 /* This is for ordinary explicit specialization and partial
757 specialization of a template class such as:
759 template <> class C<int>;
763 template <class T> class C<T*>;
765 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
767 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
768 && !COMPLETE_TYPE_P (type))
770 check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type));
771 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
772 if (processing_template_decl)
773 push_template_decl (TYPE_MAIN_DECL (type));
775 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
776 error ("specialization of %qT after instantiation", type);
778 else if (CLASS_TYPE_P (type)
779 && !CLASSTYPE_USE_TEMPLATE (type)
780 && CLASSTYPE_TEMPLATE_INFO (type)
781 && context && CLASS_TYPE_P (context)
782 && CLASSTYPE_TEMPLATE_INFO (context))
784 /* This is for an explicit specialization of member class
785 template according to [temp.expl.spec/18]:
787 template <> template <class U> class C<int>::D;
789 The context `C<int>' must be an implicit instantiation.
790 Otherwise this is just a member class template declared
793 template <> class C<int> { template <class U> class D; };
794 template <> template <class U> class C<int>::D;
796 In the first case, `C<int>::D' is a specialization of `C<T>::D'
797 while in the second case, `C<int>::D' is a primary template
798 and `C<T>::D' may not exist. */
800 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context)
801 && !COMPLETE_TYPE_P (type))
805 if (current_namespace
806 != decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type)))
808 pedwarn ("specializing %q#T in different namespace", type);
809 pedwarn (" from definition of %q+#D",
810 CLASSTYPE_TI_TEMPLATE (type));
813 /* Check for invalid specialization after instantiation:
815 template <> template <> class C<int>::D<int>;
816 template <> template <class U> class C<int>::D; */
818 for (t = DECL_TEMPLATE_INSTANTIATIONS
819 (most_general_template (CLASSTYPE_TI_TEMPLATE (type)));
820 t; t = TREE_CHAIN (t))
821 if (TREE_VALUE (t) != type
822 && TYPE_CONTEXT (TREE_VALUE (t)) == context)
823 error ("specialization %qT after instantiation %qT",
824 type, TREE_VALUE (t));
826 /* Mark TYPE as a specialization. And as a result, we only
827 have one level of template argument for the innermost
829 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
830 CLASSTYPE_TI_ARGS (type)
831 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
834 else if (processing_specialization)
836 error ("explicit specialization of non-template %qT", type);
837 return error_mark_node;
843 /* Returns nonzero if we can optimize the retrieval of specializations
844 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
845 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
848 optimize_specialization_lookup_p (tree tmpl)
850 return (DECL_FUNCTION_TEMPLATE_P (tmpl)
851 && DECL_CLASS_SCOPE_P (tmpl)
852 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
854 && CLASS_TYPE_P (DECL_CONTEXT (tmpl))
855 /* The optimized lookup depends on the fact that the
856 template arguments for the member function template apply
857 purely to the containing class, which is not true if the
858 containing class is an explicit or partial
860 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl))
861 && !DECL_MEMBER_TEMPLATE_P (tmpl)
862 && !DECL_CONV_FN_P (tmpl)
863 /* It is possible to have a template that is not a member
864 template and is not a member of a template class:
866 template <typename T>
867 struct S { friend A::f(); };
869 Here, the friend function is a template, but the context does
870 not have template information. The optimized lookup relies
871 on having ARGS be the template arguments for both the class
872 and the function template. */
873 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl)));
876 /* Retrieve the specialization (in the sense of [temp.spec] - a
877 specialization is either an instantiation or an explicit
878 specialization) of TMPL for the given template ARGS. If there is
879 no such specialization, return NULL_TREE. The ARGS are a vector of
880 arguments, or a vector of vectors of arguments, in the case of
881 templates with more than one level of parameters.
883 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
884 then we search for a partial specialization matching ARGS. This
885 parameter is ignored if TMPL is not a class template. */
888 retrieve_specialization (tree tmpl, tree args,
889 bool class_specializations_p)
891 if (args == error_mark_node)
894 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
896 /* There should be as many levels of arguments as there are
897 levels of parameters. */
898 gcc_assert (TMPL_ARGS_DEPTH (args)
899 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)));
901 if (optimize_specialization_lookup_p (tmpl))
904 tree class_specialization;
905 VEC(tree,gc) *methods;
909 /* The template arguments actually apply to the containing
910 class. Find the class specialization with those
912 class_template = CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl));
914 = retrieve_specialization (class_template, args,
915 /*class_specializations_p=*/false);
916 if (!class_specialization)
918 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
919 for the specialization. */
920 idx = class_method_index_for_fn (class_specialization, tmpl);
923 /* Iterate through the methods with the indicated name, looking
924 for the one that has an instance of TMPL. */
925 methods = CLASSTYPE_METHOD_VEC (class_specialization);
926 for (fns = VEC_index (tree, methods, idx); fns; fns = OVL_NEXT (fns))
928 tree fn = OVL_CURRENT (fns);
929 if (DECL_TEMPLATE_INFO (fn) && DECL_TI_TEMPLATE (fn) == tmpl)
939 /* Class templates store their instantiations on the
940 DECL_TEMPLATE_INSTANTIATIONS list; other templates use the
941 DECL_TEMPLATE_SPECIALIZATIONS list. */
942 if (!class_specializations_p
943 && TREE_CODE (DECL_TEMPLATE_RESULT (tmpl)) == TYPE_DECL
944 && TAGGED_TYPE_P (TREE_TYPE (tmpl)))
945 sp = &DECL_TEMPLATE_INSTANTIATIONS (tmpl);
947 sp = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
949 /* Iterate through the list until we find a matching template. */
950 while (*sp != NULL_TREE)
954 if (comp_template_args (TREE_PURPOSE (spec), args))
956 /* Use the move-to-front heuristic to speed up future
960 *sp = TREE_CHAIN (*sp);
961 TREE_CHAIN (spec) = *head;
964 return TREE_VALUE (spec);
966 sp = &TREE_CHAIN (spec);
973 /* Like retrieve_specialization, but for local declarations. */
976 retrieve_local_specialization (tree tmpl)
978 tree spec = (tree) htab_find_with_hash (local_specializations, tmpl,
979 htab_hash_pointer (tmpl));
980 return spec ? TREE_PURPOSE (spec) : NULL_TREE;
983 /* Returns nonzero iff DECL is a specialization of TMPL. */
986 is_specialization_of (tree decl, tree tmpl)
990 if (TREE_CODE (decl) == FUNCTION_DECL)
994 t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
1000 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
1002 for (t = TREE_TYPE (decl);
1004 t = CLASSTYPE_USE_TEMPLATE (t)
1005 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
1006 if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl)))
1013 /* Returns nonzero iff DECL is a specialization of friend declaration
1014 FRIEND according to [temp.friend]. */
1017 is_specialization_of_friend (tree decl, tree friend)
1019 bool need_template = true;
1022 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
1023 || TREE_CODE (decl) == TYPE_DECL);
1025 /* For [temp.friend/6] when FRIEND is an ordinary member function
1026 of a template class, we want to check if DECL is a specialization
1028 if (TREE_CODE (friend) == FUNCTION_DECL
1029 && DECL_TEMPLATE_INFO (friend)
1030 && !DECL_USE_TEMPLATE (friend))
1032 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1033 friend = DECL_TI_TEMPLATE (friend);
1034 need_template = false;
1036 else if (TREE_CODE (friend) == TEMPLATE_DECL
1037 && !PRIMARY_TEMPLATE_P (friend))
1038 need_template = false;
1040 /* There is nothing to do if this is not a template friend. */
1041 if (TREE_CODE (friend) != TEMPLATE_DECL)
1044 if (is_specialization_of (decl, friend))
1048 A member of a class template may be declared to be a friend of a
1049 non-template class. In this case, the corresponding member of
1050 every specialization of the class template is a friend of the
1051 class granting friendship.
1053 For example, given a template friend declaration
1055 template <class T> friend void A<T>::f();
1057 the member function below is considered a friend
1059 template <> struct A<int> {
1063 For this type of template friend, TEMPLATE_DEPTH below will be
1064 nonzero. To determine if DECL is a friend of FRIEND, we first
1065 check if the enclosing class is a specialization of another. */
1067 template_depth = template_class_depth (DECL_CONTEXT (friend));
1069 && DECL_CLASS_SCOPE_P (decl)
1070 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)),
1071 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend))))
1073 /* Next, we check the members themselves. In order to handle
1074 a few tricky cases, such as when FRIEND's are
1076 template <class T> friend void A<T>::g(T t);
1077 template <class T> template <T t> friend void A<T>::h();
1081 void A<int>::g(int);
1082 template <int> void A<int>::h();
1084 we need to figure out ARGS, the template arguments from
1085 the context of DECL. This is required for template substitution
1086 of `T' in the function parameter of `g' and template parameter
1087 of `h' in the above examples. Here ARGS corresponds to `int'. */
1089 tree context = DECL_CONTEXT (decl);
1090 tree args = NULL_TREE;
1091 int current_depth = 0;
1093 while (current_depth < template_depth)
1095 if (CLASSTYPE_TEMPLATE_INFO (context))
1097 if (current_depth == 0)
1098 args = TYPE_TI_ARGS (context);
1100 args = add_to_template_args (TYPE_TI_ARGS (context), args);
1103 context = TYPE_CONTEXT (context);
1106 if (TREE_CODE (decl) == FUNCTION_DECL)
1111 tree friend_args_type;
1112 tree decl_args_type;
1114 /* Make sure that both DECL and FRIEND are templates or
1116 is_template = DECL_TEMPLATE_INFO (decl)
1117 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl));
1118 if (need_template ^ is_template)
1120 else if (is_template)
1122 /* If both are templates, check template parameter list. */
1124 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
1126 if (!comp_template_parms
1127 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)),
1131 decl_type = TREE_TYPE (DECL_TI_TEMPLATE (decl));
1134 decl_type = TREE_TYPE (decl);
1136 friend_type = tsubst_function_type (TREE_TYPE (friend), args,
1137 tf_none, NULL_TREE);
1138 if (friend_type == error_mark_node)
1141 /* Check if return types match. */
1142 if (!same_type_p (TREE_TYPE (decl_type), TREE_TYPE (friend_type)))
1145 /* Check if function parameter types match, ignoring the
1146 `this' parameter. */
1147 friend_args_type = TYPE_ARG_TYPES (friend_type);
1148 decl_args_type = TYPE_ARG_TYPES (decl_type);
1149 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend))
1150 friend_args_type = TREE_CHAIN (friend_args_type);
1151 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1152 decl_args_type = TREE_CHAIN (decl_args_type);
1154 return compparms (decl_args_type, friend_args_type);
1158 /* DECL is a TYPE_DECL */
1160 tree decl_type = TREE_TYPE (decl);
1162 /* Make sure that both DECL and FRIEND are templates or
1165 = CLASSTYPE_TEMPLATE_INFO (decl_type)
1166 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type));
1168 if (need_template ^ is_template)
1170 else if (is_template)
1173 /* If both are templates, check the name of the two
1174 TEMPLATE_DECL's first because is_friend didn't. */
1175 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type))
1176 != DECL_NAME (friend))
1179 /* Now check template parameter list. */
1181 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
1183 return comp_template_parms
1184 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type)),
1188 return (DECL_NAME (decl)
1189 == DECL_NAME (friend));
1195 /* Register the specialization SPEC as a specialization of TMPL with
1196 the indicated ARGS. IS_FRIEND indicates whether the specialization
1197 is actually just a friend declaration. Returns SPEC, or an
1198 equivalent prior declaration, if available. */
1201 register_specialization (tree spec, tree tmpl, tree args, bool is_friend)
1205 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
1207 if (TREE_CODE (spec) == FUNCTION_DECL
1208 && uses_template_parms (DECL_TI_ARGS (spec)))
1209 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1210 register it; we want the corresponding TEMPLATE_DECL instead.
1211 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1212 the more obvious `uses_template_parms (spec)' to avoid problems
1213 with default function arguments. In particular, given
1214 something like this:
1216 template <class T> void f(T t1, T t = T())
1218 the default argument expression is not substituted for in an
1219 instantiation unless and until it is actually needed. */
1222 fn = retrieve_specialization (tmpl, args,
1223 /*class_specializations_p=*/false);
1224 /* We can sometimes try to re-register a specialization that we've
1225 already got. In particular, regenerate_decl_from_template calls
1226 duplicate_decls which will update the specialization list. But,
1227 we'll still get called again here anyhow. It's more convenient
1228 to simply allow this than to try to prevent it. */
1231 else if (fn && DECL_TEMPLATE_SPECIALIZATION (spec))
1233 if (DECL_TEMPLATE_INSTANTIATION (fn))
1236 || DECL_EXPLICIT_INSTANTIATION (fn))
1238 error ("specialization of %qD after instantiation",
1240 return error_mark_node;
1245 /* This situation should occur only if the first
1246 specialization is an implicit instantiation, the
1247 second is an explicit specialization, and the
1248 implicit instantiation has not yet been used. That
1249 situation can occur if we have implicitly
1250 instantiated a member function and then specialized
1253 We can also wind up here if a friend declaration that
1254 looked like an instantiation turns out to be a
1257 template <class T> void foo(T);
1258 class S { friend void foo<>(int) };
1259 template <> void foo(int);
1261 We transform the existing DECL in place so that any
1262 pointers to it become pointers to the updated
1265 If there was a definition for the template, but not
1266 for the specialization, we want this to look as if
1267 there were no definition, and vice versa. */
1268 DECL_INITIAL (fn) = NULL_TREE;
1269 duplicate_decls (spec, fn, is_friend);
1270 /* The call to duplicate_decls will have applied
1273 An explicit specialization of a function template
1274 is inline only if it is explicitly declared to be,
1275 and independently of whether its function template
1278 to the primary function; now copy the inline bits to
1279 the various clones. */
1280 FOR_EACH_CLONE (clone, fn)
1282 DECL_DECLARED_INLINE_P (clone)
1283 = DECL_DECLARED_INLINE_P (fn);
1287 check_specialization_namespace (fn);
1292 else if (DECL_TEMPLATE_SPECIALIZATION (fn))
1294 if (!duplicate_decls (spec, fn, is_friend) && DECL_INITIAL (spec))
1295 /* Dup decl failed, but this is a new definition. Set the
1296 line number so any errors match this new
1298 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec);
1304 /* A specialization must be declared in the same namespace as the
1305 template it is specializing. */
1306 if (DECL_TEMPLATE_SPECIALIZATION (spec)
1307 && !check_specialization_namespace (tmpl))
1308 DECL_CONTEXT (spec) = FROB_CONTEXT (decl_namespace_context (tmpl));
1310 if (!optimize_specialization_lookup_p (tmpl))
1311 DECL_TEMPLATE_SPECIALIZATIONS (tmpl)
1312 = tree_cons (args, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl));
1317 /* Unregister the specialization SPEC as a specialization of TMPL.
1318 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1319 if the SPEC was listed as a specialization of TMPL. */
1322 reregister_specialization (tree spec, tree tmpl, tree new_spec)
1326 for (s = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
1328 s = &TREE_CHAIN (*s))
1329 if (TREE_VALUE (*s) == spec)
1332 *s = TREE_CHAIN (*s);
1334 TREE_VALUE (*s) = new_spec;
1341 /* Compare an entry in the local specializations hash table P1 (which
1342 is really a pointer to a TREE_LIST) with P2 (which is really a
1346 eq_local_specializations (const void *p1, const void *p2)
1348 return TREE_VALUE ((const_tree) p1) == (const_tree) p2;
1351 /* Hash P1, an entry in the local specializations table. */
1354 hash_local_specialization (const void* p1)
1356 return htab_hash_pointer (TREE_VALUE ((const_tree) p1));
1359 /* Like register_specialization, but for local declarations. We are
1360 registering SPEC, an instantiation of TMPL. */
1363 register_local_specialization (tree spec, tree tmpl)
1367 slot = htab_find_slot_with_hash (local_specializations, tmpl,
1368 htab_hash_pointer (tmpl), INSERT);
1369 *slot = build_tree_list (spec, tmpl);
1372 /* TYPE is a class type. Returns true if TYPE is an explicitly
1373 specialized class. */
1376 explicit_class_specialization_p (tree type)
1378 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
1380 return !uses_template_parms (CLASSTYPE_TI_ARGS (type));
1383 /* Print the list of candidate FNS in an error message. */
1386 print_candidates (tree fns)
1390 const char *str = "candidates are:";
1392 for (fn = fns; fn != NULL_TREE; fn = TREE_CHAIN (fn))
1396 for (f = TREE_VALUE (fn); f; f = OVL_NEXT (f))
1397 error ("%s %+#D", str, OVL_CURRENT (f));
1402 /* Returns the template (one of the functions given by TEMPLATE_ID)
1403 which can be specialized to match the indicated DECL with the
1404 explicit template args given in TEMPLATE_ID. The DECL may be
1405 NULL_TREE if none is available. In that case, the functions in
1406 TEMPLATE_ID are non-members.
1408 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1409 specialization of a member template.
1411 The TEMPLATE_COUNT is the number of references to qualifying
1412 template classes that appeared in the name of the function. See
1413 check_explicit_specialization for a more accurate description.
1415 TSK indicates what kind of template declaration (if any) is being
1416 declared. TSK_TEMPLATE indicates that the declaration given by
1417 DECL, though a FUNCTION_DECL, has template parameters, and is
1418 therefore a template function.
1420 The template args (those explicitly specified and those deduced)
1421 are output in a newly created vector *TARGS_OUT.
1423 If it is impossible to determine the result, an error message is
1424 issued. The error_mark_node is returned to indicate failure. */
1427 determine_specialization (tree template_id,
1430 int need_member_template,
1436 tree explicit_targs;
1437 tree candidates = NULL_TREE;
1438 /* A TREE_LIST of templates of which DECL may be a specialization.
1439 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1440 corresponding TREE_PURPOSE is the set of template arguments that,
1441 when used to instantiate the template, would produce a function
1442 with the signature of DECL. */
1443 tree templates = NULL_TREE;
1445 struct cp_binding_level *b;
1447 *targs_out = NULL_TREE;
1449 if (template_id == error_mark_node || decl == error_mark_node)
1450 return error_mark_node;
1452 fns = TREE_OPERAND (template_id, 0);
1453 explicit_targs = TREE_OPERAND (template_id, 1);
1455 if (fns == error_mark_node)
1456 return error_mark_node;
1458 /* Check for baselinks. */
1459 if (BASELINK_P (fns))
1460 fns = BASELINK_FUNCTIONS (fns);
1462 if (!is_overloaded_fn (fns))
1464 error ("%qD is not a function template", fns);
1465 return error_mark_node;
1468 /* Count the number of template headers specified for this
1471 for (b = current_binding_level;
1472 b->kind == sk_template_parms;
1476 for (; fns; fns = OVL_NEXT (fns))
1478 tree fn = OVL_CURRENT (fns);
1480 if (TREE_CODE (fn) == TEMPLATE_DECL)
1482 tree decl_arg_types;
1485 /* In case of explicit specialization, we need to check if
1486 the number of template headers appearing in the specialization
1487 is correct. This is usually done in check_explicit_specialization,
1488 but the check done there cannot be exhaustive when specializing
1489 member functions. Consider the following code:
1491 template <> void A<int>::f(int);
1492 template <> template <> void A<int>::f(int);
1494 Assuming that A<int> is not itself an explicit specialization
1495 already, the first line specializes "f" which is a non-template
1496 member function, whilst the second line specializes "f" which
1497 is a template member function. So both lines are syntactically
1498 correct, and check_explicit_specialization does not reject
1501 Here, we can do better, as we are matching the specialization
1502 against the declarations. We count the number of template
1503 headers, and we check if they match TEMPLATE_COUNT + 1
1504 (TEMPLATE_COUNT is the number of qualifying template classes,
1505 plus there must be another header for the member template
1508 Notice that if header_count is zero, this is not a
1509 specialization but rather a template instantiation, so there
1510 is no check we can perform here. */
1511 if (header_count && header_count != template_count + 1)
1514 /* Check that the number of template arguments at the
1515 innermost level for DECL is the same as for FN. */
1516 if (current_binding_level->kind == sk_template_parms
1517 && !current_binding_level->explicit_spec_p
1518 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn))
1519 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
1520 (current_template_parms))))
1523 /* DECL might be a specialization of FN. */
1524 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1525 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
1527 /* For a non-static member function, we need to make sure
1528 that the const qualification is the same. Since
1529 get_bindings does not try to merge the "this" parameter,
1530 we must do the comparison explicitly. */
1531 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1532 && !same_type_p (TREE_VALUE (fn_arg_types),
1533 TREE_VALUE (decl_arg_types)))
1536 /* Skip the "this" parameter and, for constructors of
1537 classes with virtual bases, the VTT parameter. A
1538 full specialization of a constructor will have a VTT
1539 parameter, but a template never will. */
1541 = skip_artificial_parms_for (decl, decl_arg_types);
1543 = skip_artificial_parms_for (fn, fn_arg_types);
1545 /* Check that the number of function parameters matches.
1547 template <class T> void f(int i = 0);
1548 template <> void f<int>();
1549 The specialization f<int> is invalid but is not caught
1550 by get_bindings below. */
1551 if (list_length (fn_arg_types) != list_length (decl_arg_types))
1554 /* Function templates cannot be specializations; there are
1555 no partial specializations of functions. Therefore, if
1556 the type of DECL does not match FN, there is no
1558 if (tsk == tsk_template)
1560 if (compparms (fn_arg_types, decl_arg_types))
1561 candidates = tree_cons (NULL_TREE, fn, candidates);
1565 /* See whether this function might be a specialization of this
1567 targs = get_bindings (fn, decl, explicit_targs, /*check_ret=*/true);
1570 /* We cannot deduce template arguments that when used to
1571 specialize TMPL will produce DECL. */
1574 /* Save this template, and the arguments deduced. */
1575 templates = tree_cons (targs, fn, templates);
1577 else if (need_member_template)
1578 /* FN is an ordinary member function, and we need a
1579 specialization of a member template. */
1581 else if (TREE_CODE (fn) != FUNCTION_DECL)
1582 /* We can get IDENTIFIER_NODEs here in certain erroneous
1585 else if (!DECL_FUNCTION_MEMBER_P (fn))
1586 /* This is just an ordinary non-member function. Nothing can
1587 be a specialization of that. */
1589 else if (DECL_ARTIFICIAL (fn))
1590 /* Cannot specialize functions that are created implicitly. */
1594 tree decl_arg_types;
1596 /* This is an ordinary member function. However, since
1597 we're here, we can assume it's enclosing class is a
1598 template class. For example,
1600 template <typename T> struct S { void f(); };
1601 template <> void S<int>::f() {}
1603 Here, S<int>::f is a non-template, but S<int> is a
1604 template class. If FN has the same type as DECL, we
1605 might be in business. */
1607 if (!DECL_TEMPLATE_INFO (fn))
1608 /* Its enclosing class is an explicit specialization
1609 of a template class. This is not a candidate. */
1612 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
1613 TREE_TYPE (TREE_TYPE (fn))))
1614 /* The return types differ. */
1617 /* Adjust the type of DECL in case FN is a static member. */
1618 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1619 if (DECL_STATIC_FUNCTION_P (fn)
1620 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1621 decl_arg_types = TREE_CHAIN (decl_arg_types);
1623 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1626 candidates = tree_cons (NULL_TREE, fn, candidates);
1630 if (templates && TREE_CHAIN (templates))
1636 It is possible for a specialization with a given function
1637 signature to be instantiated from more than one function
1638 template. In such cases, explicit specification of the
1639 template arguments must be used to uniquely identify the
1640 function template specialization being specialized.
1642 Note that here, there's no suggestion that we're supposed to
1643 determine which of the candidate templates is most
1644 specialized. However, we, also have:
1648 Partial ordering of overloaded function template
1649 declarations is used in the following contexts to select
1650 the function template to which a function template
1651 specialization refers:
1653 -- when an explicit specialization refers to a function
1656 So, we do use the partial ordering rules, at least for now.
1657 This extension can only serve to make invalid programs valid,
1658 so it's safe. And, there is strong anecdotal evidence that
1659 the committee intended the partial ordering rules to apply;
1660 the EDG front end has that behavior, and John Spicer claims
1661 that the committee simply forgot to delete the wording in
1662 [temp.expl.spec]. */
1663 tree tmpl = most_specialized_instantiation (templates);
1664 if (tmpl != error_mark_node)
1667 TREE_CHAIN (templates) = NULL_TREE;
1671 if (templates == NULL_TREE && candidates == NULL_TREE)
1673 error ("template-id %qD for %q+D does not match any template "
1674 "declaration", template_id, decl);
1675 return error_mark_node;
1677 else if ((templates && TREE_CHAIN (templates))
1678 || (candidates && TREE_CHAIN (candidates))
1679 || (templates && candidates))
1681 error ("ambiguous template specialization %qD for %q+D",
1683 chainon (candidates, templates);
1684 print_candidates (candidates);
1685 return error_mark_node;
1688 /* We have one, and exactly one, match. */
1691 tree fn = TREE_VALUE (candidates);
1692 /* DECL is a re-declaration of a template function. */
1693 if (TREE_CODE (fn) == TEMPLATE_DECL)
1695 /* It was a specialization of an ordinary member function in a
1697 *targs_out = copy_node (DECL_TI_ARGS (fn));
1698 return DECL_TI_TEMPLATE (fn);
1701 /* It was a specialization of a template. */
1702 targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates)));
1703 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs))
1705 *targs_out = copy_node (targs);
1706 SET_TMPL_ARGS_LEVEL (*targs_out,
1707 TMPL_ARGS_DEPTH (*targs_out),
1708 TREE_PURPOSE (templates));
1711 *targs_out = TREE_PURPOSE (templates);
1712 return TREE_VALUE (templates);
1715 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
1716 but with the default argument values filled in from those in the
1720 copy_default_args_to_explicit_spec_1 (tree spec_types,
1723 tree new_spec_types;
1728 if (spec_types == void_list_node)
1729 return void_list_node;
1731 /* Substitute into the rest of the list. */
1733 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
1734 TREE_CHAIN (tmpl_types));
1736 /* Add the default argument for this parameter. */
1737 return hash_tree_cons (TREE_PURPOSE (tmpl_types),
1738 TREE_VALUE (spec_types),
1742 /* DECL is an explicit specialization. Replicate default arguments
1743 from the template it specializes. (That way, code like:
1745 template <class T> void f(T = 3);
1746 template <> void f(double);
1749 works, as required.) An alternative approach would be to look up
1750 the correct default arguments at the call-site, but this approach
1751 is consistent with how implicit instantiations are handled. */
1754 copy_default_args_to_explicit_spec (tree decl)
1759 tree new_spec_types;
1763 tree object_type = NULL_TREE;
1764 tree in_charge = NULL_TREE;
1765 tree vtt = NULL_TREE;
1767 /* See if there's anything we need to do. */
1768 tmpl = DECL_TI_TEMPLATE (decl);
1769 tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
1770 for (t = tmpl_types; t; t = TREE_CHAIN (t))
1771 if (TREE_PURPOSE (t))
1776 old_type = TREE_TYPE (decl);
1777 spec_types = TYPE_ARG_TYPES (old_type);
1779 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1781 /* Remove the this pointer, but remember the object's type for
1783 object_type = TREE_TYPE (TREE_VALUE (spec_types));
1784 spec_types = TREE_CHAIN (spec_types);
1785 tmpl_types = TREE_CHAIN (tmpl_types);
1787 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
1789 /* DECL may contain more parameters than TMPL due to the extra
1790 in-charge parameter in constructors and destructors. */
1791 in_charge = spec_types;
1792 spec_types = TREE_CHAIN (spec_types);
1794 if (DECL_HAS_VTT_PARM_P (decl))
1797 spec_types = TREE_CHAIN (spec_types);
1801 /* Compute the merged default arguments. */
1803 copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);
1805 /* Compute the new FUNCTION_TYPE. */
1809 new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt),
1814 /* Put the in-charge parameter back. */
1815 new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
1816 TREE_VALUE (in_charge),
1819 new_type = build_method_type_directly (object_type,
1820 TREE_TYPE (old_type),
1824 new_type = build_function_type (TREE_TYPE (old_type),
1826 new_type = cp_build_type_attribute_variant (new_type,
1827 TYPE_ATTRIBUTES (old_type));
1828 new_type = build_exception_variant (new_type,
1829 TYPE_RAISES_EXCEPTIONS (old_type));
1830 TREE_TYPE (decl) = new_type;
1833 /* Check to see if the function just declared, as indicated in
1834 DECLARATOR, and in DECL, is a specialization of a function
1835 template. We may also discover that the declaration is an explicit
1836 instantiation at this point.
1838 Returns DECL, or an equivalent declaration that should be used
1839 instead if all goes well. Issues an error message if something is
1840 amiss. Returns error_mark_node if the error is not easily
1843 FLAGS is a bitmask consisting of the following flags:
1845 2: The function has a definition.
1846 4: The function is a friend.
1848 The TEMPLATE_COUNT is the number of references to qualifying
1849 template classes that appeared in the name of the function. For
1852 template <class T> struct S { void f(); };
1855 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1856 classes are not counted in the TEMPLATE_COUNT, so that in
1858 template <class T> struct S {};
1859 template <> struct S<int> { void f(); }
1860 template <> void S<int>::f();
1862 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1863 invalid; there should be no template <>.)
1865 If the function is a specialization, it is marked as such via
1866 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1867 is set up correctly, and it is added to the list of specializations
1868 for that template. */
1871 check_explicit_specialization (tree declarator,
1876 int have_def = flags & 2;
1877 int is_friend = flags & 4;
1878 int specialization = 0;
1879 int explicit_instantiation = 0;
1880 int member_specialization = 0;
1881 tree ctype = DECL_CLASS_CONTEXT (decl);
1882 tree dname = DECL_NAME (decl);
1887 if (!processing_specialization)
1890 tsk = tsk_excessive_parms;
1893 tsk = current_tmpl_spec_kind (template_count);
1898 if (processing_specialization)
1901 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1903 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1906 /* This could be something like:
1908 template <class T> void f(T);
1909 class S { friend void f<>(int); } */
1913 /* This case handles bogus declarations like template <>
1914 template <class T> void f<int>(); */
1916 error ("template-id %qD in declaration of primary template",
1923 case tsk_invalid_member_spec:
1924 /* The error has already been reported in
1925 check_specialization_scope. */
1926 return error_mark_node;
1928 case tsk_invalid_expl_inst:
1929 error ("template parameter list used in explicit instantiation");
1935 error ("definition provided for explicit instantiation");
1937 explicit_instantiation = 1;
1940 case tsk_excessive_parms:
1941 case tsk_insufficient_parms:
1942 if (tsk == tsk_excessive_parms)
1943 error ("too many template parameter lists in declaration of %qD",
1945 else if (template_header_count)
1946 error("too few template parameter lists in declaration of %qD", decl);
1948 error("explicit specialization of %qD must be introduced by "
1949 "%<template <>%>", decl);
1953 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1955 member_specialization = 1;
1961 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1963 /* This case handles bogus declarations like template <>
1964 template <class T> void f<int>(); */
1966 if (uses_template_parms (declarator))
1967 error ("function template partial specialization %qD "
1968 "is not allowed", declarator);
1970 error ("template-id %qD in declaration of primary template",
1975 if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
1976 /* This is a specialization of a member template, without
1977 specialization the containing class. Something like:
1979 template <class T> struct S {
1980 template <class U> void f (U);
1982 template <> template <class U> void S<int>::f(U) {}
1984 That's a specialization -- but of the entire template. */
1992 if (specialization || member_specialization)
1994 tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
1995 for (; t; t = TREE_CHAIN (t))
1996 if (TREE_PURPOSE (t))
1999 ("default argument specified in explicit specialization");
2004 if (specialization || member_specialization || explicit_instantiation)
2006 tree tmpl = NULL_TREE;
2007 tree targs = NULL_TREE;
2009 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2010 if (TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
2014 gcc_assert (TREE_CODE (declarator) == IDENTIFIER_NODE);
2019 /* If there is no class context, the explicit instantiation
2020 must be at namespace scope. */
2021 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl));
2023 /* Find the namespace binding, using the declaration
2025 fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
2027 if (fns == error_mark_node || !is_overloaded_fn (fns))
2029 error ("%qD is not a template function", dname);
2030 fns = error_mark_node;
2034 tree fn = OVL_CURRENT (fns);
2035 if (!is_associated_namespace (CP_DECL_CONTEXT (decl),
2036 CP_DECL_CONTEXT (fn)))
2037 error ("%qD is not declared in %qD",
2038 decl, current_namespace);
2042 declarator = lookup_template_function (fns, NULL_TREE);
2045 if (declarator == error_mark_node)
2046 return error_mark_node;
2048 if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
2050 if (!explicit_instantiation)
2051 /* A specialization in class scope. This is invalid,
2052 but the error will already have been flagged by
2053 check_specialization_scope. */
2054 return error_mark_node;
2057 /* It's not valid to write an explicit instantiation in
2060 class C { template void f(); }
2062 This case is caught by the parser. However, on
2065 template class C { void f(); };
2067 (which is invalid) we can get here. The error will be
2074 else if (ctype != NULL_TREE
2075 && (TREE_CODE (TREE_OPERAND (declarator, 0)) ==
2078 /* Find the list of functions in ctype that have the same
2079 name as the declared function. */
2080 tree name = TREE_OPERAND (declarator, 0);
2081 tree fns = NULL_TREE;
2084 if (constructor_name_p (name, ctype))
2086 int is_constructor = DECL_CONSTRUCTOR_P (decl);
2088 if (is_constructor ? !TYPE_HAS_CONSTRUCTOR (ctype)
2089 : !CLASSTYPE_DESTRUCTORS (ctype))
2091 /* From [temp.expl.spec]:
2093 If such an explicit specialization for the member
2094 of a class template names an implicitly-declared
2095 special member function (clause _special_), the
2096 program is ill-formed.
2098 Similar language is found in [temp.explicit]. */
2099 error ("specialization of implicitly-declared special member function");
2100 return error_mark_node;
2103 name = is_constructor ? ctor_identifier : dtor_identifier;
2106 if (!DECL_CONV_FN_P (decl))
2108 idx = lookup_fnfields_1 (ctype, name);
2110 fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (ctype), idx);
2114 VEC(tree,gc) *methods;
2117 /* For a type-conversion operator, we cannot do a
2118 name-based lookup. We might be looking for `operator
2119 int' which will be a specialization of `operator T'.
2120 So, we find *all* the conversion operators, and then
2121 select from them. */
2124 methods = CLASSTYPE_METHOD_VEC (ctype);
2126 for (idx = CLASSTYPE_FIRST_CONVERSION_SLOT;
2127 VEC_iterate (tree, methods, idx, ovl);
2130 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl)))
2131 /* There are no more conversion functions. */
2134 /* Glue all these conversion functions together
2135 with those we already have. */
2136 for (; ovl; ovl = OVL_NEXT (ovl))
2137 fns = ovl_cons (OVL_CURRENT (ovl), fns);
2141 if (fns == NULL_TREE)
2143 error ("no member function %qD declared in %qT", name, ctype);
2144 return error_mark_node;
2147 TREE_OPERAND (declarator, 0) = fns;
2150 /* Figure out what exactly is being specialized at this point.
2151 Note that for an explicit instantiation, even one for a
2152 member function, we cannot tell apriori whether the
2153 instantiation is for a member template, or just a member
2154 function of a template class. Even if a member template is
2155 being instantiated, the member template arguments may be
2156 elided if they can be deduced from the rest of the
2158 tmpl = determine_specialization (declarator, decl,
2160 member_specialization,
2164 if (!tmpl || tmpl == error_mark_node)
2165 /* We couldn't figure out what this declaration was
2167 return error_mark_node;
2170 tree gen_tmpl = most_general_template (tmpl);
2172 if (explicit_instantiation)
2174 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2175 is done by do_decl_instantiation later. */
2177 int arg_depth = TMPL_ARGS_DEPTH (targs);
2178 int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
2180 if (arg_depth > parm_depth)
2182 /* If TMPL is not the most general template (for
2183 example, if TMPL is a friend template that is
2184 injected into namespace scope), then there will
2185 be too many levels of TARGS. Remove some of them
2190 new_targs = make_tree_vec (parm_depth);
2191 for (i = arg_depth - parm_depth; i < arg_depth; ++i)
2192 TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
2193 = TREE_VEC_ELT (targs, i);
2197 return instantiate_template (tmpl, targs, tf_error);
2200 /* If we thought that the DECL was a member function, but it
2201 turns out to be specializing a static member function,
2202 make DECL a static member function as well. */
2203 if (DECL_STATIC_FUNCTION_P (tmpl)
2204 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2205 revert_static_member_fn (decl);
2207 /* If this is a specialization of a member template of a
2208 template class, we want to return the TEMPLATE_DECL, not
2209 the specialization of it. */
2210 if (tsk == tsk_template)
2212 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
2213 DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl)) = NULL_TREE;
2216 DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
2217 DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (tmpl))
2218 = DECL_SOURCE_LOCATION (decl);
2219 /* We want to use the argument list specified in the
2220 definition, not in the original declaration. */
2221 DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (tmpl))
2222 = DECL_ARGUMENTS (decl);
2227 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2228 DECL_TEMPLATE_INFO (decl) = tree_cons (tmpl, targs, NULL_TREE);
2230 /* Inherit default function arguments from the template
2231 DECL is specializing. */
2232 copy_default_args_to_explicit_spec (decl);
2234 /* This specialization has the same protection as the
2235 template it specializes. */
2236 TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
2237 TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
2239 /* 7.1.1-1 [dcl.stc]
2241 A storage-class-specifier shall not be specified in an
2242 explicit specialization...
2244 The parser rejects these, so unless action is taken here,
2245 explicit function specializations will always appear with
2248 The action recommended by the C++ CWG in response to C++
2249 defect report 605 is to make the storage class and linkage
2250 of the explicit specialization match the templated function:
2252 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2254 if (tsk == tsk_expl_spec && DECL_FUNCTION_TEMPLATE_P (gen_tmpl))
2256 tree tmpl_func = DECL_TEMPLATE_RESULT (gen_tmpl);
2257 gcc_assert (TREE_CODE (tmpl_func) == FUNCTION_DECL);
2259 /* This specialization has the same linkage and visibility as
2260 the function template it specializes. */
2261 TREE_PUBLIC (decl) = TREE_PUBLIC (tmpl_func);
2262 if (! TREE_PUBLIC (decl))
2264 DECL_INTERFACE_KNOWN (decl) = 1;
2265 DECL_NOT_REALLY_EXTERN (decl) = 1;
2267 DECL_THIS_STATIC (decl) = DECL_THIS_STATIC (tmpl_func);
2268 if (DECL_VISIBILITY_SPECIFIED (tmpl_func))
2270 DECL_VISIBILITY_SPECIFIED (decl) = 1;
2271 DECL_VISIBILITY (decl) = DECL_VISIBILITY (tmpl_func);
2275 /* If DECL is a friend declaration, declared using an
2276 unqualified name, the namespace associated with DECL may
2277 have been set incorrectly. For example, in:
2279 template <typename T> void f(T);
2281 struct S { friend void f<int>(int); }
2284 we will have set the DECL_CONTEXT for the friend
2285 declaration to N, rather than to the global namespace. */
2286 if (DECL_NAMESPACE_SCOPE_P (decl))
2287 DECL_CONTEXT (decl) = DECL_CONTEXT (tmpl);
2289 if (is_friend && !have_def)
2290 /* This is not really a declaration of a specialization.
2291 It's just the name of an instantiation. But, it's not
2292 a request for an instantiation, either. */
2293 SET_DECL_IMPLICIT_INSTANTIATION (decl);
2294 else if (DECL_CONSTRUCTOR_P (decl) || DECL_DESTRUCTOR_P (decl))
2295 /* This is indeed a specialization. In case of constructors
2296 and destructors, we need in-charge and not-in-charge
2297 versions in V3 ABI. */
2298 clone_function_decl (decl, /*update_method_vec_p=*/0);
2300 /* Register this specialization so that we can find it
2302 decl = register_specialization (decl, gen_tmpl, targs, is_friend);
2309 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2310 parameters. These are represented in the same format used for
2311 DECL_TEMPLATE_PARMS. */
2314 comp_template_parms (const_tree parms1, const_tree parms2)
2319 if (parms1 == parms2)
2322 for (p1 = parms1, p2 = parms2;
2323 p1 != NULL_TREE && p2 != NULL_TREE;
2324 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2))
2326 tree t1 = TREE_VALUE (p1);
2327 tree t2 = TREE_VALUE (p2);
2330 gcc_assert (TREE_CODE (t1) == TREE_VEC);
2331 gcc_assert (TREE_CODE (t2) == TREE_VEC);
2333 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
2336 for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
2338 tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
2339 tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
2341 /* If either of the template parameters are invalid, assume
2342 they match for the sake of error recovery. */
2343 if (parm1 == error_mark_node || parm2 == error_mark_node)
2346 if (TREE_CODE (parm1) != TREE_CODE (parm2))
2349 if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM
2350 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1)
2351 == TEMPLATE_TYPE_PARAMETER_PACK (parm2)))
2353 else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
2358 if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
2359 /* One set of parameters has more parameters lists than the
2366 /* Determine whether PARM is a parameter pack. */
2368 template_parameter_pack_p (const_tree parm)
2370 /* Determine if we have a non-type template parameter pack. */
2371 if (TREE_CODE (parm) == PARM_DECL)
2372 return (DECL_TEMPLATE_PARM_P (parm)
2373 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)));
2375 /* If this is a list of template parameters, we could get a
2376 TYPE_DECL or a TEMPLATE_DECL. */
2377 if (TREE_CODE (parm) == TYPE_DECL || TREE_CODE (parm) == TEMPLATE_DECL)
2378 parm = TREE_TYPE (parm);
2380 return ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
2381 || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM)
2382 && TEMPLATE_TYPE_PARAMETER_PACK (parm));
2385 /* Determine whether ARGS describes a variadic template args list,
2386 i.e., one that is terminated by a template argument pack. */
2388 template_args_variadic_p (tree args)
2393 if (args == NULL_TREE)
2396 args = INNERMOST_TEMPLATE_ARGS (args);
2397 nargs = TREE_VEC_LENGTH (args);
2402 last_parm = TREE_VEC_ELT (args, nargs - 1);
2404 return ARGUMENT_PACK_P (last_parm);
2407 /* Generate a new name for the parameter pack name NAME (an
2408 IDENTIFIER_NODE) that incorporates its */
2410 make_ith_pack_parameter_name (tree name, int i)
2412 /* Munge the name to include the parameter index. */
2416 sprintf(numbuf, "%i", i);
2417 newname = (char*)alloca (IDENTIFIER_LENGTH (name) + strlen(numbuf) + 2);
2418 sprintf(newname, "%s#%i", IDENTIFIER_POINTER (name), i);
2419 return get_identifier (newname);
2422 /* Structure used to track the progress of find_parameter_packs_r. */
2423 struct find_parameter_pack_data
2425 /* TREE_LIST that will contain all of the parameter packs found by
2427 tree* parameter_packs;
2429 /* Set of AST nodes that have been visited by the traversal. */
2430 struct pointer_set_t *visited;
2432 /* Whether we should replace parameter packs with
2433 ERROR_MARK_NODE. Used by check_for_bare_parameter_packs. */
2434 bool set_packs_to_error;
2437 /* Identifies all of the argument packs that occur in a template
2438 argument and appends them to the TREE_LIST inside DATA, which is a
2439 find_parameter_pack_data structure. This is a subroutine of
2440 make_pack_expansion and uses_parameter_packs. */
2442 find_parameter_packs_r (tree *tp, int *walk_subtrees, void* data)
2445 struct find_parameter_pack_data* ppd =
2446 (struct find_parameter_pack_data*)data;
2447 bool parameter_pack_p = false;
2449 /* Don't visit nodes twice, except when we're clearing out parameter
2451 if (pointer_set_contains (ppd->visited, *tp))
2458 /* Identify whether this is a parameter pack or not. */
2459 switch (TREE_CODE (t))
2461 case TEMPLATE_PARM_INDEX:
2462 if (TEMPLATE_PARM_PARAMETER_PACK (t))
2463 parameter_pack_p = true;
2466 case TEMPLATE_TYPE_PARM:
2467 case TEMPLATE_TEMPLATE_PARM:
2468 if (TEMPLATE_TYPE_PARAMETER_PACK (t))
2469 parameter_pack_p = true;
2473 if (FUNCTION_PARAMETER_PACK_P (t))
2475 /* We don't want to walk into the type of a PARM_DECL,
2476 because we don't want to see the type parameter pack. */
2478 parameter_pack_p = true;
2483 if (ppd->set_packs_to_error)
2484 /* Pointer types are shared, set in that case the outermost
2485 POINTER_TYPE to error_mark_node rather than the parameter pack. */
2493 /* Not a parameter pack. */
2497 if (parameter_pack_p)
2499 /* Add this parameter pack to the list. */
2500 *ppd->parameter_packs = tree_cons (NULL_TREE, t, *ppd->parameter_packs);
2502 if (ppd->set_packs_to_error)
2503 /* The caller requested that we set the parameter packs to
2504 ERROR_MARK_NODE so that they will not trip up the compiler
2505 later. The caller is responsible for emitting an error. */
2506 *tp = error_mark_node;
2508 /* Make sure we do not visit this node again. */
2509 pointer_set_insert (ppd->visited, *tp);
2512 /* Make sure we do not visit this node again. */
2513 pointer_set_insert (ppd->visited, *tp);
2516 cp_walk_tree (&TYPE_CONTEXT (t),
2517 &find_parameter_packs_r, ppd, NULL);
2519 /* This switch statement will return immediately if we don't find a
2521 switch (TREE_CODE (t))
2523 case TEMPLATE_PARM_INDEX:
2526 case BOUND_TEMPLATE_TEMPLATE_PARM:
2527 /* Check the template itself. */
2528 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t)),
2529 &find_parameter_packs_r, ppd, NULL);
2530 /* Check the template arguments. */
2531 cp_walk_tree (&TYPE_TI_ARGS (t), &find_parameter_packs_r, ppd,
2536 case TEMPLATE_TYPE_PARM:
2537 case TEMPLATE_TEMPLATE_PARM:
2544 if (TYPE_PTRMEMFUNC_P (t))
2550 if (TYPE_TEMPLATE_INFO (t))
2551 cp_walk_tree (&TREE_VALUE (TYPE_TEMPLATE_INFO (t)),
2552 &find_parameter_packs_r, ppd, NULL);
2558 cp_walk_tree (&TREE_TYPE (t),
2559 &find_parameter_packs_r, ppd, NULL);
2563 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t), &find_parameter_packs_r,
2568 case TYPE_PACK_EXPANSION:
2569 case EXPR_PACK_EXPANSION:
2574 cp_walk_tree (&TYPE_MAX_VALUE (t), &find_parameter_packs_r,
2586 /* Determines if the expression or type T uses any parameter packs. */
2588 uses_parameter_packs (tree t)
2590 tree parameter_packs = NULL_TREE;
2591 struct find_parameter_pack_data ppd;
2592 ppd.parameter_packs = ¶meter_packs;
2593 ppd.visited = pointer_set_create ();
2594 ppd.set_packs_to_error = false;
2595 cp_walk_tree (&t, &find_parameter_packs_r, &ppd, NULL);
2596 pointer_set_destroy (ppd.visited);
2597 return parameter_packs != NULL_TREE;
2600 /* Turn ARG, which may be an expression, type, or a TREE_LIST
2601 representation a base-class initializer into a parameter pack
2602 expansion. If all goes well, the resulting node will be an
2603 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
2606 make_pack_expansion (tree arg)
2609 tree parameter_packs = NULL_TREE;
2610 bool for_types = false;
2611 struct find_parameter_pack_data ppd;
2613 ppd.set_packs_to_error = false;
2615 if (!arg || arg == error_mark_node)
2618 if (TREE_CODE (arg) == TREE_LIST)
2620 /* The only time we will see a TREE_LIST here is for a base
2621 class initializer. In this case, the TREE_PURPOSE will be a
2622 _TYPE node (representing the base class expansion we're
2623 initializing) and the TREE_VALUE will be a TREE_LIST
2624 containing the initialization arguments.
2626 The resulting expansion looks somewhat different from most
2627 expansions. Rather than returning just one _EXPANSION, we
2628 return a TREE_LIST whose TREE_PURPOSE is a
2629 TYPE_PACK_EXPANSION containing the bases that will be
2630 initialized. The TREE_VALUE will be identical to the
2631 original TREE_VALUE, which is a list of arguments that will
2632 be passed to each base. We do not introduce any new pack
2633 expansion nodes into the TREE_VALUE (although it is possible
2634 that some already exist), because the TREE_PURPOSE and
2635 TREE_VALUE all need to be expanded together with the same
2636 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
2637 resulting TREE_PURPOSE will mention the parameter packs in
2638 both the bases and the arguments to the bases. */
2641 tree parameter_packs = NULL_TREE;
2643 /* Determine which parameter packs will be used by the base
2645 ppd.visited = pointer_set_create ();
2646 ppd.parameter_packs = ¶meter_packs;
2647 cp_walk_tree (&TREE_PURPOSE (arg), &find_parameter_packs_r,
2650 if (parameter_packs == NULL_TREE)
2652 error ("base initializer expansion %<%T%> contains no parameter packs", arg);
2653 pointer_set_destroy (ppd.visited);
2654 return error_mark_node;
2657 if (TREE_VALUE (arg) != void_type_node)
2659 /* Collect the sets of parameter packs used in each of the
2660 initialization arguments. */
2661 for (value = TREE_VALUE (arg); value; value = TREE_CHAIN (value))
2663 /* Determine which parameter packs will be expanded in this
2665 cp_walk_tree (&TREE_VALUE (value), &find_parameter_packs_r,
2670 pointer_set_destroy (ppd.visited);
2672 /* Create the pack expansion type for the base type. */
2673 purpose = make_node (TYPE_PACK_EXPANSION);
2674 SET_PACK_EXPANSION_PATTERN (purpose, TREE_PURPOSE (arg));
2675 PACK_EXPANSION_PARAMETER_PACKS (purpose) = parameter_packs;
2677 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
2678 they will rarely be compared to anything. */
2679 SET_TYPE_STRUCTURAL_EQUALITY (purpose);
2681 return tree_cons (purpose, TREE_VALUE (arg), NULL_TREE);
2684 if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
2687 /* Build the PACK_EXPANSION_* node. */
2688 result = make_node (for_types ? TYPE_PACK_EXPANSION : EXPR_PACK_EXPANSION);
2689 SET_PACK_EXPANSION_PATTERN (result, arg);
2690 if (TREE_CODE (result) == EXPR_PACK_EXPANSION)
2692 /* Propagate type and const-expression information. */
2693 TREE_TYPE (result) = TREE_TYPE (arg);
2694 TREE_CONSTANT (result) = TREE_CONSTANT (arg);
2697 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
2698 they will rarely be compared to anything. */
2699 SET_TYPE_STRUCTURAL_EQUALITY (result);
2701 /* Determine which parameter packs will be expanded. */
2702 ppd.parameter_packs = ¶meter_packs;
2703 ppd.visited = pointer_set_create ();
2704 cp_walk_tree (&arg, &find_parameter_packs_r, &ppd, NULL);
2705 pointer_set_destroy (ppd.visited);
2707 /* Make sure we found some parameter packs. */
2708 if (parameter_packs == NULL_TREE)
2711 error ("expansion pattern %<%T%> contains no argument packs", arg);
2713 error ("expansion pattern %<%E%> contains no argument packs", arg);
2714 return error_mark_node;
2716 PACK_EXPANSION_PARAMETER_PACKS (result) = parameter_packs;
2721 /* Checks T for any "bare" parameter packs, which have not yet been
2722 expanded, and issues an error if any are found. This operation can
2723 only be done on full expressions or types (e.g., an expression
2724 statement, "if" condition, etc.), because we could have expressions like:
2726 foo(f(g(h(args)))...)
2728 where "args" is a parameter pack. check_for_bare_parameter_packs
2729 should not be called for the subexpressions args, h(args),
2730 g(h(args)), or f(g(h(args))), because we would produce erroneous
2733 Returns TRUE if there were no bare parameter packs, returns FALSE
2734 (and emits an error) if there were bare parameter packs.*/
2736 check_for_bare_parameter_packs (tree* t)
2738 tree parameter_packs = NULL_TREE;
2739 struct find_parameter_pack_data ppd;
2741 if (!processing_template_decl || !t || !*t || *t == error_mark_node)
2744 if (TREE_CODE (*t) == TYPE_DECL)
2745 t = &TREE_TYPE (*t);
2747 ppd.parameter_packs = ¶meter_packs;
2748 ppd.visited = pointer_set_create ();
2749 ppd.set_packs_to_error = false;
2750 cp_walk_tree (t, &find_parameter_packs_r, &ppd, NULL);
2751 pointer_set_destroy (ppd.visited);
2753 if (parameter_packs)
2755 error ("parameter packs not expanded with `...':");
2756 while (parameter_packs)
2758 tree pack = TREE_VALUE (parameter_packs);
2759 tree name = NULL_TREE;
2761 if (TREE_CODE (pack) == TEMPLATE_TYPE_PARM
2762 || TREE_CODE (pack) == TEMPLATE_TEMPLATE_PARM)
2763 name = TYPE_NAME (pack);
2764 else if (TREE_CODE (pack) == TEMPLATE_PARM_INDEX)
2765 name = DECL_NAME (TEMPLATE_PARM_DECL (pack));
2767 name = DECL_NAME (pack);
2770 inform (" %qD", name);
2772 inform (" <anonymous>");
2774 parameter_packs = TREE_CHAIN (parameter_packs);
2777 /* Clean up any references to these parameter packs within the
2779 ppd.parameter_packs = ¶meter_packs;
2780 ppd.visited = pointer_set_create ();
2781 ppd.set_packs_to_error = true;
2782 cp_walk_tree (t, &find_parameter_packs_r, &ppd, NULL);
2783 pointer_set_destroy (ppd.visited);
2791 /* Expand any parameter packs that occur in the template arguments in
2794 expand_template_argument_pack (tree args)
2796 tree result_args = NULL_TREE;
2797 int in_arg, out_arg = 0, nargs = args ? TREE_VEC_LENGTH (args) : 0;
2798 int num_result_args = -1;
2800 /* First, determine if we need to expand anything, and the number of
2801 slots we'll need. */
2802 for (in_arg = 0; in_arg < nargs; ++in_arg)
2804 tree arg = TREE_VEC_ELT (args, in_arg);
2805 if (ARGUMENT_PACK_P (arg))
2807 int num_packed = TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg));
2808 if (num_result_args < 0)
2809 num_result_args = in_arg + num_packed;
2811 num_result_args += num_packed;
2815 if (num_result_args >= 0)
2820 /* If no expansion is necessary, we're done. */
2821 if (num_result_args < 0)
2824 /* Expand arguments. */
2825 result_args = make_tree_vec (num_result_args);
2826 for (in_arg = 0; in_arg < nargs; ++in_arg)
2828 tree arg = TREE_VEC_ELT (args, in_arg);
2829 if (ARGUMENT_PACK_P (arg))
2831 tree packed = ARGUMENT_PACK_ARGS (arg);
2832 int i, num_packed = TREE_VEC_LENGTH (packed);
2833 for (i = 0; i < num_packed; ++i, ++out_arg)
2834 TREE_VEC_ELT (result_args, out_arg) = TREE_VEC_ELT(packed, i);
2838 TREE_VEC_ELT (result_args, out_arg) = arg;
2846 /* Complain if DECL shadows a template parameter.
2848 [temp.local]: A template-parameter shall not be redeclared within its
2849 scope (including nested scopes). */
2852 check_template_shadow (tree decl)
2856 /* If we're not in a template, we can't possibly shadow a template
2858 if (!current_template_parms)
2861 /* Figure out what we're shadowing. */
2862 if (TREE_CODE (decl) == OVERLOAD)
2863 decl = OVL_CURRENT (decl);
2864 olddecl = innermost_non_namespace_value (DECL_NAME (decl));
2866 /* If there's no previous binding for this name, we're not shadowing
2867 anything, let alone a template parameter. */
2871 /* If we're not shadowing a template parameter, we're done. Note
2872 that OLDDECL might be an OVERLOAD (or perhaps even an
2873 ERROR_MARK), so we can't just blithely assume it to be a _DECL
2875 if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
2878 /* We check for decl != olddecl to avoid bogus errors for using a
2879 name inside a class. We check TPFI to avoid duplicate errors for
2880 inline member templates. */
2882 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms))
2885 error ("declaration of %q+#D", decl);
2886 error (" shadows template parm %q+#D", olddecl);
2889 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
2890 ORIG_LEVEL, DECL, and TYPE. */
2893 build_template_parm_index (int index,
2899 tree t = make_node (TEMPLATE_PARM_INDEX);
2900 TEMPLATE_PARM_IDX (t) = index;
2901 TEMPLATE_PARM_LEVEL (t) = level;
2902 TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
2903 TEMPLATE_PARM_DECL (t) = decl;
2904 TREE_TYPE (t) = type;
2905 TREE_CONSTANT (t) = TREE_CONSTANT (decl);
2906 TREE_INVARIANT (t) = TREE_INVARIANT (decl);
2907 TREE_READONLY (t) = TREE_READONLY (decl);
2912 /* Find the canonical type parameter for the given template type
2913 parameter. Returns the canonical type parameter, which may be TYPE
2914 if no such parameter existed. */
2916 canonical_type_parameter (tree type)
2919 int idx = TEMPLATE_TYPE_IDX (type);
2920 if (!canonical_template_parms)
2921 canonical_template_parms = VEC_alloc (tree, gc, idx+1);
2923 while (VEC_length (tree, canonical_template_parms) <= (unsigned)idx)
2924 VEC_safe_push (tree, gc, canonical_template_parms, NULL_TREE);
2926 list = VEC_index (tree, canonical_template_parms, idx);
2927 while (list && !comptypes (type, TREE_VALUE (list), COMPARE_STRUCTURAL))
2928 list = TREE_CHAIN (list);
2931 return TREE_VALUE (list);
2934 VEC_replace(tree, canonical_template_parms, idx,
2935 tree_cons (NULL_TREE, type,
2936 VEC_index (tree, canonical_template_parms, idx)));
2941 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
2942 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
2943 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
2944 new one is created. */
2947 reduce_template_parm_level (tree index, tree type, int levels, tree args,
2948 tsubst_flags_t complain)
2950 if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
2951 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
2952 != TEMPLATE_PARM_LEVEL (index) - levels))
2954 tree orig_decl = TEMPLATE_PARM_DECL (index);
2957 decl = build_decl (TREE_CODE (orig_decl), DECL_NAME (orig_decl), type);
2958 TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl);
2959 TREE_INVARIANT (decl) = TREE_INVARIANT (orig_decl);
2960 TREE_READONLY (decl) = TREE_READONLY (orig_decl);
2961 DECL_ARTIFICIAL (decl) = 1;
2962 SET_DECL_TEMPLATE_PARM_P (decl);
2964 t = build_template_parm_index (TEMPLATE_PARM_IDX (index),
2965 TEMPLATE_PARM_LEVEL (index) - levels,
2966 TEMPLATE_PARM_ORIG_LEVEL (index),
2968 TEMPLATE_PARM_DESCENDANTS (index) = t;
2969 TEMPLATE_PARM_PARAMETER_PACK (t)
2970 = TEMPLATE_PARM_PARAMETER_PACK (index);
2972 /* Template template parameters need this. */
2973 if (TREE_CODE (decl) == TEMPLATE_DECL)
2974 DECL_TEMPLATE_PARMS (decl) = tsubst_template_parms
2975 (DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index)),
2979 return TEMPLATE_PARM_DESCENDANTS (index);
2982 /* Process information from new template parameter PARM and append it to the
2983 LIST being built. This new parameter is a non-type parameter iff
2984 IS_NON_TYPE is true. This new parameter is a parameter
2985 pack iff IS_PARAMETER_PACK is true. */
2988 process_template_parm (tree list, tree parm, bool is_non_type,
2989 bool is_parameter_pack)
2996 gcc_assert (TREE_CODE (parm) == TREE_LIST);
2997 defval = TREE_PURPOSE (parm);
3001 tree p = tree_last (list);
3003 if (p && TREE_VALUE (p) != error_mark_node)
3006 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
3007 idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
3009 idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
3019 parm = TREE_VALUE (parm);
3021 SET_DECL_TEMPLATE_PARM_P (parm);
3023 if (TREE_TYPE (parm) == error_mark_node)
3025 err_parm_list = build_tree_list (defval, parm);
3026 TREE_VALUE (err_parm_list) = error_mark_node;
3027 return chainon (list, err_parm_list);
3033 The top-level cv-qualifiers on the template-parameter are
3034 ignored when determining its type. */
3035 TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
3036 if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
3038 err_parm_list = build_tree_list (defval, parm);
3039 TREE_VALUE (err_parm_list) = error_mark_node;
3040 return chainon (list, err_parm_list);
3043 if (uses_parameter_packs (TREE_TYPE (parm)) && !is_parameter_pack)
3045 /* This template parameter is not a parameter pack, but it
3046 should be. Complain about "bare" parameter packs. */
3047 check_for_bare_parameter_packs (&TREE_TYPE (parm));
3049 /* Recover by calling this a parameter pack. */
3050 is_parameter_pack = true;
3054 /* A template parameter is not modifiable. */
3055 TREE_CONSTANT (parm) = 1;
3056 TREE_INVARIANT (parm) = 1;
3057 TREE_READONLY (parm) = 1;
3058 decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
3059 TREE_CONSTANT (decl) = 1;
3060 TREE_INVARIANT (decl) = 1;
3061 TREE_READONLY (decl) = 1;
3062 DECL_INITIAL (parm) = DECL_INITIAL (decl)
3063 = build_template_parm_index (idx, processing_template_decl,
3064 processing_template_decl,
3065 decl, TREE_TYPE (parm));
3067 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm))
3068 = is_parameter_pack;
3073 parm = TREE_VALUE (TREE_VALUE (parm));
3075 if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
3077 t = make_aggr_type (TEMPLATE_TEMPLATE_PARM);
3078 /* This is for distinguishing between real templates and template
3079 template parameters */
3080 TREE_TYPE (parm) = t;
3081 TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t;
3086 t = make_aggr_type (TEMPLATE_TYPE_PARM);
3087 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3088 decl = build_decl (TYPE_DECL, parm, t);
3091 TYPE_NAME (t) = decl;
3092 TYPE_STUB_DECL (t) = decl;
3094 TEMPLATE_TYPE_PARM_INDEX (t)
3095 = build_template_parm_index (idx, processing_template_decl,
3096 processing_template_decl,
3097 decl, TREE_TYPE (parm));
3098 TEMPLATE_TYPE_PARAMETER_PACK (t) = is_parameter_pack;
3099 TYPE_CANONICAL (t) = canonical_type_parameter (t);
3101 DECL_ARTIFICIAL (decl) = 1;
3102 SET_DECL_TEMPLATE_PARM_P (decl);
3104 parm = build_tree_list (defval, parm);
3105 return chainon (list, parm);
3108 /* The end of a template parameter list has been reached. Process the
3109 tree list into a parameter vector, converting each parameter into a more
3110 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3114 end_template_parm_list (tree parms)
3118 tree saved_parmlist = make_tree_vec (list_length (parms));
3120 current_template_parms
3121 = tree_cons (size_int (processing_template_decl),
3122 saved_parmlist, current_template_parms);
3124 for (parm = parms, nparms = 0; parm; parm = next, nparms++)
3126 next = TREE_CHAIN (parm);
3127 TREE_VEC_ELT (saved_parmlist, nparms) = parm;
3128 TREE_CHAIN (parm) = NULL_TREE;
3131 --processing_template_parmlist;
3133 return saved_parmlist;
3136 /* end_template_decl is called after a template declaration is seen. */
3139 end_template_decl (void)
3141 reset_specialization ();
3143 if (! processing_template_decl)
3146 /* This matches the pushlevel in begin_template_parm_list. */
3149 --processing_template_decl;
3150 current_template_parms = TREE_CHAIN (current_template_parms);
3153 /* Within the declaration of a template, return all levels of template
3154 parameters that apply. The template parameters are represented as
3155 a TREE_VEC, in the form documented in cp-tree.h for template
3159 current_template_args (void)
3162 tree args = NULL_TREE;
3163 int length = TMPL_PARMS_DEPTH (current_template_parms);
3166 /* If there is only one level of template parameters, we do not
3167 create a TREE_VEC of TREE_VECs. Instead, we return a single
3168 TREE_VEC containing the arguments. */
3170 args = make_tree_vec (length);
3172 for (header = current_template_parms; header; header = TREE_CHAIN (header))
3174 tree a = copy_node (TREE_VALUE (header));
3177 TREE_TYPE (a) = NULL_TREE;
3178 for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
3180 tree t = TREE_VEC_ELT (a, i);
3182 /* T will be a list if we are called from within a
3183 begin/end_template_parm_list pair, but a vector directly
3184 if within a begin/end_member_template_processing pair. */
3185 if (TREE_CODE (t) == TREE_LIST)
3189 if (t != error_mark_node)
3191 if (TREE_CODE (t) == TYPE_DECL
3192 || TREE_CODE (t) == TEMPLATE_DECL)
3196 if (TEMPLATE_TYPE_PARAMETER_PACK (t))
3198 /* Turn this argument into a TYPE_ARGUMENT_PACK
3199 with a single element, which expands T. */
3200 tree vec = make_tree_vec (1);
3201 TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
3203 t = make_node (TYPE_ARGUMENT_PACK);
3204 SET_ARGUMENT_PACK_ARGS (t, vec);
3209 t = DECL_INITIAL (t);
3211 if (TEMPLATE_PARM_PARAMETER_PACK (t))
3213 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3214 with a single element, which expands T. */
3215 tree vec = make_tree_vec (1);
3216 tree type = TREE_TYPE (TEMPLATE_PARM_DECL (t));
3217 TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
3219 t = make_node (NONTYPE_ARGUMENT_PACK);
3220 SET_ARGUMENT_PACK_ARGS (t, vec);
3221 TREE_TYPE (t) = type;
3224 TREE_VEC_ELT (a, i) = t;
3230 TREE_VEC_ELT (args, --l) = a;
3238 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
3239 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
3240 a member template. Used by push_template_decl below. */
3243 build_template_decl (tree decl, tree parms, bool member_template_p)
3245 tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
3246 DECL_TEMPLATE_PARMS (tmpl) = parms;
3247 DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
3248 DECL_MEMBER_TEMPLATE_P (tmpl) = member_template_p;
3249 if (DECL_LANG_SPECIFIC (decl))
3251 DECL_STATIC_FUNCTION_P (tmpl) = DECL_STATIC_FUNCTION_P (decl);
3252 DECL_CONSTRUCTOR_P (tmpl) = DECL_CONSTRUCTOR_P (decl);
3253 DECL_DESTRUCTOR_P (tmpl) = DECL_DESTRUCTOR_P (decl);
3254 DECL_NONCONVERTING_P (tmpl) = DECL_NONCONVERTING_P (decl);
3255 DECL_ASSIGNMENT_OPERATOR_P (tmpl) = DECL_ASSIGNMENT_OPERATOR_P (decl);
3256 if (DECL_OVERLOADED_OPERATOR_P (decl))
3257 SET_OVERLOADED_OPERATOR_CODE (tmpl,
3258 DECL_OVERLOADED_OPERATOR_P (decl));
3264 struct template_parm_data
3266 /* The level of the template parameters we are currently
3270 /* The index of the specialization argument we are currently
3274 /* An array whose size is the number of template parameters. The
3275 elements are nonzero if the parameter has been used in any one
3276 of the arguments processed so far. */
3279 /* An array whose size is the number of template arguments. The
3280 elements are nonzero if the argument makes use of template
3281 parameters of this level. */
3282 int* arg_uses_template_parms;
3285 /* Subroutine of push_template_decl used to see if each template
3286 parameter in a partial specialization is used in the explicit
3287 argument list. If T is of the LEVEL given in DATA (which is
3288 treated as a template_parm_data*), then DATA->PARMS is marked
3292 mark_template_parm (tree t, void* data)
3296 struct template_parm_data* tpd = (struct template_parm_data*) data;
3298 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
3300 level = TEMPLATE_PARM_LEVEL (t);
3301 idx = TEMPLATE_PARM_IDX (t);
3305 level = TEMPLATE_TYPE_LEVEL (t);
3306 idx = TEMPLATE_TYPE_IDX (t);
3309 if (level == tpd->level)
3311 tpd->parms[idx] = 1;
3312 tpd->arg_uses_template_parms[tpd->current_arg] = 1;
3315 /* Return zero so that for_each_template_parm will continue the
3316 traversal of the tree; we want to mark *every* template parm. */
3320 /* Process the partial specialization DECL. */
3323 process_partial_specialization (tree decl)
3325 tree type = TREE_TYPE (decl);
3326 tree maintmpl = CLASSTYPE_TI_TEMPLATE (type);
3327 tree specargs = CLASSTYPE_TI_ARGS (type);
3328 tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
3329 tree inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
3330 tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
3331 int nargs = TREE_VEC_LENGTH (inner_args);
3332 int ntparms = TREE_VEC_LENGTH (inner_parms);
3334 int did_error_intro = 0;
3335 struct template_parm_data tpd;
3336 struct template_parm_data tpd2;
3338 /* We check that each of the template parameters given in the
3339 partial specialization is used in the argument list to the
3340 specialization. For example:
3342 template <class T> struct S;
3343 template <class T> struct S<T*>;
3345 The second declaration is OK because `T*' uses the template
3346 parameter T, whereas
3348 template <class T> struct S<int>;
3350 is no good. Even trickier is:
3361 The S2<T> declaration is actually invalid; it is a
3362 full-specialization. Of course,
3365 struct S2<T (*)(U)>;
3367 or some such would have been OK. */
3368 tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
3369 tpd.parms = (int *) alloca (sizeof (int) * ntparms);
3370 memset (tpd.parms, 0, sizeof (int) * ntparms);
3372 tpd.arg_uses_template_parms = (int *) alloca (sizeof (int) * nargs);
3373 memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
3374 for (i = 0; i < nargs; ++i)
3376 tpd.current_arg = i;
3377 for_each_template_parm (TREE_VEC_ELT (inner_args, i),
3378 &mark_template_parm,
3382 for (i = 0; i < ntparms; ++i)
3383 if (tpd.parms[i] == 0)
3385 /* One of the template parms was not used in the
3387 if (!did_error_intro)
3389 error ("template parameters not used in partial specialization:");
3390 did_error_intro = 1;
3393 error (" %qD", TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
3396 /* [temp.class.spec]
3398 The argument list of the specialization shall not be identical to
3399 the implicit argument list of the primary template. */
3400 if (comp_template_args
3402 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
3404 error ("partial specialization %qT does not specialize any template arguments", type);
3406 /* [temp.class.spec]
3408 A partially specialized non-type argument expression shall not
3409 involve template parameters of the partial specialization except
3410 when the argument expression is a simple identifier.
3412 The type of a template parameter corresponding to a specialized
3413 non-type argument shall not be dependent on a parameter of the
3416 Also, we verify that pack expansions only occur at the
3417 end of the argument list. */
3418 gcc_assert (nargs == DECL_NTPARMS (maintmpl));
3420 for (i = 0; i < nargs; ++i)
3422 tree parm = TREE_VALUE (TREE_VEC_ELT (main_inner_parms, i));
3423 tree arg = TREE_VEC_ELT (inner_args, i);
3424 tree packed_args = NULL_TREE;
3427 if (ARGUMENT_PACK_P (arg))
3429 /* Extract the arguments from the argument pack. We'll be
3430 iterating over these in the following loop. */
3431 packed_args = ARGUMENT_PACK_ARGS (arg);
3432 len = TREE_VEC_LENGTH (packed_args);
3435 for (j = 0; j < len; j++)
3438 /* Get the Jth argument in the parameter pack. */
3439 arg = TREE_VEC_ELT (packed_args, j);
3441 if (PACK_EXPANSION_P (arg))
3443 /* Pack expansions must come at the end of the
3445 if ((packed_args && j < len - 1)
3446 || (!packed_args && i < nargs - 1))
3448 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
3449 error ("parameter pack argument %qE must be at the end of the template argument list", arg);
3451 error ("parameter pack argument %qT must be at the end of the template argument list", arg);
3454 TREE_VEC_ELT (packed_args, j) = error_mark_node;
3458 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
3459 /* We only care about the pattern. */
3460 arg = PACK_EXPANSION_PATTERN (arg);
3462 if (/* These first two lines are the `non-type' bit. */
3464 && TREE_CODE (arg) != TEMPLATE_DECL
3465 /* This next line is the `argument expression is not just a
3466 simple identifier' condition and also the `specialized
3467 non-type argument' bit. */
3468 && TREE_CODE (arg) != TEMPLATE_PARM_INDEX)
3470 if ((!packed_args && tpd.arg_uses_template_parms[i])
3471 || (packed_args && uses_template_parms (arg)))
3472 error ("template argument %qE involves template parameter(s)",
3476 /* Look at the corresponding template parameter,
3477 marking which template parameters its type depends
3479 tree type = TREE_TYPE (parm);
3483 /* We haven't yet initialized TPD2. Do so now. */
3484 tpd2.arg_uses_template_parms
3485 = (int *) alloca (sizeof (int) * nargs);
3486 /* The number of parameters here is the number in the
3487 main template, which, as checked in the assertion
3489 tpd2.parms = (int *) alloca (sizeof (int) * nargs);
3491 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
3494 /* Mark the template parameters. But this time, we're
3495 looking for the template parameters of the main
3496 template, not in the specialization. */
3497 tpd2.current_arg = i;
3498 tpd2.arg_uses_template_parms[i] = 0;
3499 memset (tpd2.parms, 0, sizeof (int) * nargs);
3500 for_each_template_parm (type,
3501 &mark_template_parm,
3505 if (tpd2.arg_uses_template_parms [i])
3507 /* The type depended on some template parameters.
3508 If they are fully specialized in the
3509 specialization, that's OK. */
3511 for (j = 0; j < nargs; ++j)
3512 if (tpd2.parms[j] != 0
3513 && tpd.arg_uses_template_parms [j])
3515 error ("type %qT of template argument %qE depends "
3516 "on template parameter(s)",
3527 if (retrieve_specialization (maintmpl, specargs,
3528 /*class_specializations_p=*/true))
3529 /* We've already got this specialization. */
3532 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
3533 = tree_cons (specargs, inner_parms,
3534 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
3535 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
3539 /* Check that a template declaration's use of default arguments is not
3540 invalid. Here, PARMS are the template parameters. IS_PRIMARY is
3541 nonzero if DECL is the thing declared by a primary template.
3542 IS_PARTIAL is nonzero if DECL is a partial specialization.
3545 IS_FRIEND_DECL is nonzero if DECL is a friend function template
3546 declaration (but not a definition); 1 indicates a declaration, 2
3547 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
3548 emitted for extraneous default arguments.
3550 Returns TRUE if there were no errors found, FALSE otherwise. */
3553 check_default_tmpl_args (tree decl, tree parms, int is_primary,
3554 int is_partial, int is_friend_decl)
3557 int last_level_to_check;
3559 bool no_errors = true;
3563 A default template-argument shall not be specified in a
3564 function template declaration or a function template definition, nor
3565 in the template-parameter-list of the definition of a member of a
3568 if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
3569 /* You can't have a function template declaration in a local
3570 scope, nor you can you define a member of a class template in a
3574 if (current_class_type
3575 && !TYPE_BEING_DEFINED (current_class_type)
3576 && DECL_LANG_SPECIFIC (decl)
3577 /* If this is either a friend defined in the scope of the class
3578 or a member function. */
3579 && (DECL_FUNCTION_MEMBER_P (decl)
3580 ? same_type_p (DECL_CONTEXT (decl), current_class_type)
3581 : DECL_FRIEND_CONTEXT (decl)
3582 ? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type)
3584 /* And, if it was a member function, it really was defined in
3585 the scope of the class. */
3586 && (!DECL_FUNCTION_MEMBER_P (decl)
3587 || DECL_INITIALIZED_IN_CLASS_P (decl)))
3588 /* We already checked these parameters when the template was
3589 declared, so there's no need to do it again now. This function
3590 was defined in class scope, but we're processing it's body now
3591 that the class is complete. */
3594 /* Core issue 226 (C++0x only): the following only applies to class
3596 if ((cxx_dialect == cxx98) || TREE_CODE (decl) != FUNCTION_DECL)
3600 If a template-parameter has a default template-argument, all
3601 subsequent template-parameters shall have a default
3602 template-argument supplied. */
3603 for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
3605 tree inner_parms = TREE_VALUE (parm_level);
3606 int ntparms = TREE_VEC_LENGTH (inner_parms);
3607 int seen_def_arg_p = 0;
3610 for (i = 0; i < ntparms; ++i)
3612 tree parm = TREE_VEC_ELT (inner_parms, i);
3614 if (parm == error_mark_node)
3617 if (TREE_PURPOSE (parm))
3619 else if (seen_def_arg_p)
3621 error ("no default argument for %qD", TREE_VALUE (parm));
3622 /* For better subsequent error-recovery, we indicate that
3623 there should have been a default argument. */
3624 TREE_PURPOSE (parm) = error_mark_node;
3631 if (((cxx_dialect == cxx98) && TREE_CODE (decl) != TYPE_DECL)
3635 /* For an ordinary class template, default template arguments are
3636 allowed at the innermost level, e.g.:
3637 template <class T = int>
3639 but, in a partial specialization, they're not allowed even
3640 there, as we have in [temp.class.spec]:
3642 The template parameter list of a specialization shall not
3643 contain default template argument values.
3645 So, for a partial specialization, or for a function template
3646 (in C++98/C++03), we look at all of them. */
3649 /* But, for a primary class template that is not a partial
3650 specialization we look at all template parameters except the
3652 parms = TREE_CHAIN (parms);
3654 /* Figure out what error message to issue. */
3655 if (is_friend_decl == 2)
3656 msg = "default template arguments may not be used in function template friend re-declaration";
3657 else if (is_friend_decl)
3658 msg = "default template arguments may not be used in function template friend declarations";
3659 else if (TREE_CODE (decl) == FUNCTION_DECL && (cxx_dialect == cxx98))
3660 msg = "default template arguments may not be used in function templates";
3661 else if (is_partial)
3662 msg = "default template arguments may not be used in partial specializations";
3664 msg = "default argument for template parameter for class enclosing %qD";
3666 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
3667 /* If we're inside a class definition, there's no need to
3668 examine the parameters to the class itself. On the one
3669 hand, they will be checked when the class is defined, and,
3670 on the other, default arguments are valid in things like:
3671 template <class T = double>
3672 struct S { template <class U> void f(U); };
3673 Here the default argument for `S' has no bearing on the
3674 declaration of `f'. */
3675 last_level_to_check = template_class_depth (current_class_type) + 1;
3677 /* Check everything. */
3678 last_level_to_check = 0;
3680 for (parm_level = parms;
3681 parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
3682 parm_level = TREE_CHAIN (parm_level))
3684 tree inner_parms = TREE_VALUE (parm_level);
3688 ntparms = TREE_VEC_LENGTH (inner_parms);
3689 for (i = 0; i < ntparms; ++i)
3691 if (TREE_VEC_ELT (inner_parms, i) == error_mark_node)
3694 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
3699 if (is_friend_decl == 2)
3706 /* Clear out the default argument so that we are not
3708 TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
3712 /* At this point, if we're still interested in issuing messages,
3713 they must apply to classes surrounding the object declared. */
3715 msg = "default argument for template parameter for class enclosing %qD";
3721 /* Worker for push_template_decl_real, called via
3722 for_each_template_parm. DATA is really an int, indicating the
3723 level of the parameters we are interested in. If T is a template
3724 parameter of that level, return nonzero. */
3727 template_parm_this_level_p (tree t, void* data)
3729 int this_level = *(int *)data;
3732 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
3733 level = TEMPLATE_PARM_LEVEL (t);
3735 level = TEMPLATE_TYPE_LEVEL (t);
3736 return level == this_level;
3739 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
3740 parameters given by current_template_args, or reuses a
3741 previously existing one, if appropriate. Returns the DECL, or an
3742 equivalent one, if it is replaced via a call to duplicate_decls.
3744 If IS_FRIEND is true, DECL is a friend declaration. */
3747 push_template_decl_real (tree decl, bool is_friend)
3755 int new_template_p = 0;
3756 /* True if the template is a member template, in the sense of
3758 bool member_template_p = false;
3760 if (decl == error_mark_node)
3763 /* See if this is a partial specialization. */
3764 is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl)
3765 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
3766 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)));
3768 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl))
3772 /* For a friend, we want the context of the friend function, not
3773 the type of which it is a friend. */
3774 ctx = DECL_CONTEXT (decl);
3775 else if (CP_DECL_CONTEXT (decl)
3776 && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
3777 /* In the case of a virtual function, we want the class in which
3779 ctx = CP_DECL_CONTEXT (decl);
3781 /* Otherwise, if we're currently defining some class, the DECL
3782 is assumed to be a member of the class. */
3783 ctx = current_scope ();
3785 if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
3788 if (!DECL_CONTEXT (decl))
3789 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
3791 /* See if this is a primary template. */
3792 if (is_friend && ctx)
3793 /* A friend template that specifies a class context, i.e.
3794 template <typename T> friend void A<T>::f();
3798 primary = template_parm_scope_p ();
3802 if (DECL_CLASS_SCOPE_P (decl))
3803 member_template_p = true;
3804 if (TREE_CODE (decl) == TYPE_DECL
3805 && ANON_AGGRNAME_P (DECL_NAME (decl)))
3806 error ("template class without a name");
3807 else if (TREE_CODE (decl) == FUNCTION_DECL)
3809 if (DECL_DESTRUCTOR_P (decl))
3813 A destructor shall not be a member template. */
3814 error ("destructor %qD declared as member template", decl);
3815 return error_mark_node;
3817 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl))
3818 && (!TYPE_ARG_TYPES (TREE_TYPE (decl))
3819 || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
3820 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
3821 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl))))
3822 == void_list_node)))
3824 /* [basic.stc.dynamic.allocation]
3826 An allocation function can be a function
3827 template. ... Template allocation functions shall
3828 have two or more parameters. */
3829 error ("invalid template declaration of %qD", decl);
3830 return error_mark_node;
3833 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
3834 && CLASS_TYPE_P (TREE_TYPE (decl)))
3838 error ("template declaration of %q#D", decl);
3839 return error_mark_node;
3843 /* Check to see that the rules regarding the use of default
3844 arguments are not being violated. */
3845 check_default_tmpl_args (decl, current_template_parms,
3846 primary, is_partial, /*is_friend_decl=*/0);
3848 /* Ensure that there are no parameter packs in the type of this
3849 declaration that have not been expanded. */
3850 if (TREE_CODE (decl) == FUNCTION_DECL)
3852 /* Check each of the arguments individually to see if there are
3853 any bare parameter packs. */
3854 tree type = TREE_TYPE (decl);
3855 tree arg = DECL_ARGUMENTS (decl);
3856 tree argtype = TYPE_ARG_TYPES (type);
3858 while (arg && argtype)
3860 if (!FUNCTION_PARAMETER_PACK_P (arg)
3861 && !check_for_bare_parameter_packs (&TREE_TYPE (arg)))
3863 /* This is a PARM_DECL that contains unexpanded parameter
3864 packs. We have already complained about this in the
3865 check_for_bare_parameter_packs call, so just replace
3866 these types with ERROR_MARK_NODE. */
3867 TREE_TYPE (arg) = error_mark_node;
3868 TREE_VALUE (argtype) = error_mark_node;
3871 arg = TREE_CHAIN (arg);
3872 argtype = TREE_CHAIN (argtype);
3875 /* Check for bare parameter packs in the return type and the
3876 exception specifiers. */
3877 if (!check_for_bare_parameter_packs (&TREE_TYPE (type)))
3878 /* Errors were already issued, set return type to int
3879 as the frontend doesn't expect error_mark_node as
3881 TREE_TYPE (type) = integer_type_node;
3882 check_for_bare_parameter_packs (&TYPE_RAISES_EXCEPTIONS (type));
3884 else if (!check_for_bare_parameter_packs (&TREE_TYPE (decl)))
3885 return error_mark_node;
3888 return process_partial_specialization (decl);
3890 /* A primary class template can only have one parameter pack, at the
3891 end of the template parameter list. */
3892 if (primary && TREE_CODE (decl) == TYPE_DECL)
3895 = INNERMOST_TEMPLATE_PARMS (current_template_parms);
3896 int i, len = TREE_VEC_LENGTH (inner_parms);
3897 for (i = 0; i < len - 1; i++)
3899 tree parm = TREE_VALUE (TREE_VEC_ELT (inner_parms, i));
3901 if (template_parameter_pack_p (parm))
3903 if (TREE_CODE (parm) == PARM_DECL)
3904 error ("parameter pack %qE must be at the end of the"
3905 " template parameter list", parm);
3907 error ("parameter pack %qT must be at the end of the"
3908 " template parameter list", TREE_TYPE (parm));
3910 TREE_VALUE (TREE_VEC_ELT (inner_parms, i)) = error_mark_node;
3915 args = current_template_args ();
3918 || TREE_CODE (ctx) == FUNCTION_DECL
3919 || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
3920 || (is_friend && !DECL_TEMPLATE_INFO (decl)))
3922 if (DECL_LANG_SPECIFIC (decl)
3923 && DECL_TEMPLATE_INFO (decl)
3924 && DECL_TI_TEMPLATE (decl))
3925 tmpl = DECL_TI_TEMPLATE (decl);
3926 /* If DECL is a TYPE_DECL for a class-template, then there won't
3927 be DECL_LANG_SPECIFIC. The information equivalent to
3928 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
3929 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
3930 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
3931 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
3933 /* Since a template declaration already existed for this
3934 class-type, we must be redeclaring it here. Make sure
3935 that the redeclaration is valid. */
3936 redeclare_class_template (TREE_TYPE (decl),
3937 current_template_parms);
3938 /* We don't need to create a new TEMPLATE_DECL; just use the
3939 one we already had. */
3940 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
3944 tmpl = build_template_decl (decl, current_template_parms,
3948 if (DECL_LANG_SPECIFIC (decl)
3949 && DECL_TEMPLATE_SPECIALIZATION (decl))
3951 /* A specialization of a member template of a template
3953 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
3954 DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
3955 DECL_TEMPLATE_INFO (decl) = NULL_TREE;
3961 tree a, t, current, parms;
3963 tree tinfo = get_template_info (decl);
3967 error ("template definition of non-template %q#D", decl);
3971 tmpl = TI_TEMPLATE (tinfo);
3973 if (DECL_FUNCTION_TEMPLATE_P (tmpl)
3974 && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
3975 && DECL_TEMPLATE_SPECIALIZATION (decl)
3976 && DECL_MEMBER_TEMPLATE_P (tmpl))
3980 /* The declaration is a specialization of a member
3981 template, declared outside the class. Therefore, the
3982 innermost template arguments will be NULL, so we
3983 replace them with the arguments determined by the
3984 earlier call to check_explicit_specialization. */
3985 args = DECL_TI_ARGS (decl);
3988 = build_template_decl (decl, current_template_parms,
3990 DECL_TEMPLATE_RESULT (new_tmpl) = decl;
3991 TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
3992 DECL_TI_TEMPLATE (decl) = new_tmpl;
3993 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
3994 DECL_TEMPLATE_INFO (new_tmpl)
3995 = tree_cons (tmpl, args, NULL_TREE);
3997 register_specialization (new_tmpl,
3998 most_general_template (tmpl),
4004 /* Make sure the template headers we got make sense. */
4006 parms = DECL_TEMPLATE_PARMS (tmpl);
4007 i = TMPL_PARMS_DEPTH (parms);
4008 if (TMPL_ARGS_DEPTH (args) != i)
4010 error ("expected %d levels of template parms for %q#D, got %d",
4011 i, decl, TMPL_ARGS_DEPTH (args));
4014 for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
4016 a = TMPL_ARGS_LEVEL (args, i);
4017 t = INNERMOST_TEMPLATE_PARMS (parms);
4019 if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
4021 if (current == decl)
4022 error ("got %d template parameters for %q#D",
4023 TREE_VEC_LENGTH (a), decl);
4025 error ("got %d template parameters for %q#T",
4026 TREE_VEC_LENGTH (a), current);
4027 error (" but %d required", TREE_VEC_LENGTH (t));
4028 return error_mark_node;
4031 if (current == decl)
4034 current = (TYPE_P (current)
4035 ? TYPE_CONTEXT (current)
4036 : DECL_CONTEXT (current));
4039 /* Check that the parms are used in the appropriate qualifying scopes
4040 in the declarator. */
4041 if (!comp_template_args
4043 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl)))))
4046 template arguments to %qD do not match original template %qD",
4047 decl, DECL_TEMPLATE_RESULT (tmpl));
4048 if (!uses_template_parms (TI_ARGS (tinfo)))
4049 inform ("use template<> for an explicit specialization");
4050 /* Avoid crash in import_export_decl. */
4051 DECL_INTERFACE_KNOWN (decl) = 1;
4052 return error_mark_node;
4056 DECL_TEMPLATE_RESULT (tmpl) = decl;
4057 TREE_TYPE (tmpl) = TREE_TYPE (decl);
4059 /* Push template declarations for global functions and types. Note
4060 that we do not try to push a global template friend declared in a
4061 template class; such a thing may well depend on the template
4062 parameters of the class. */
4063 if (new_template_p && !ctx
4064 && !(is_friend && template_class_depth (current_class_type) > 0))
4066 tmpl = pushdecl_namespace_level (tmpl, is_friend);
4067 if (tmpl == error_mark_node)
4068 return error_mark_node;
4070 /* Hide template friend classes that haven't been declared yet. */
4071 if (is_friend && TREE_CODE (decl) == TYPE_DECL)
4073 DECL_ANTICIPATED (tmpl) = 1;
4074 DECL_FRIEND_P (tmpl) = 1;
4080 tree parms = DECL_TEMPLATE_PARMS (tmpl);
4083 DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
4084 if (DECL_CONV_FN_P (tmpl))
4086 int depth = TMPL_PARMS_DEPTH (parms);
4088 /* It is a conversion operator. See if the type converted to
4089 depends on innermost template operands. */
4091 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl)),
4093 DECL_TEMPLATE_CONV_FN_P (tmpl) = 1;
4096 /* Give template template parms a DECL_CONTEXT of the template
4097 for which they are a parameter. */
4098 parms = INNERMOST_TEMPLATE_PARMS (parms);
4099 for (i = TREE_VEC_LENGTH (parms) - 1; i >= 0; --i)
4101 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
4102 if (TREE_CODE (parm) == TEMPLATE_DECL)
4103 DECL_CONTEXT (parm) = tmpl;
4107 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
4108 back to its most general template. If TMPL is a specialization,
4109 ARGS may only have the innermost set of arguments. Add the missing
4110 argument levels if necessary. */
4111 if (DECL_TEMPLATE_INFO (tmpl))
4112 args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);
4114 info = tree_cons (tmpl, args, NULL_TREE);
4116 if (DECL_IMPLICIT_TYPEDEF_P (decl))
4117 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
4118 else if (DECL_LANG_SPECIFIC (decl))
4119 DECL_TEMPLATE_INFO (decl) = info;
4121 return DECL_TEMPLATE_RESULT (tmpl);
4125 push_template_decl (tree decl)
4127 return push_template_decl_real (decl, false);
4130 /* Called when a class template TYPE is redeclared with the indicated
4131 template PARMS, e.g.:
4133 template <class T> struct S;
4134 template <class T> struct S {}; */
4137 redeclare_class_template (tree type, tree parms)
4143 if (!TYPE_TEMPLATE_INFO (type))
4145 error ("%qT is not a template type", type);
4149 tmpl = TYPE_TI_TEMPLATE (type);
4150 if (!PRIMARY_TEMPLATE_P (tmpl))
4151 /* The type is nested in some template class. Nothing to worry
4152 about here; there are no new template parameters for the nested
4158 error ("template specifiers not specified in declaration of %qD",
4163 parms = INNERMOST_TEMPLATE_PARMS (parms);
4164 tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
4166 if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
4168 error ("redeclared with %d template parameter(s)",
4169 TREE_VEC_LENGTH (parms));
4170 inform ("previous declaration %q+D used %d template parameter(s)",
4171 tmpl, TREE_VEC_LENGTH (tmpl_parms));
4175 for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
4182 if (TREE_VEC_ELT (tmpl_parms, i) == error_mark_node
4183 || TREE_VEC_ELT (parms, i) == error_mark_node)
4186 tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
4187 parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
4188 tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i));
4189 parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
4191 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
4193 if (tmpl_parm != error_mark_node
4194 && (TREE_CODE (tmpl_parm) != TREE_CODE (parm)
4195 || (TREE_CODE (tmpl_parm) != TYPE_DECL
4196 && !same_type_p (TREE_TYPE (tmpl_parm), TREE_TYPE (parm)))))
4198 error ("template parameter %q+#D", tmpl_parm);
4199 error ("redeclared here as %q#D", parm);
4203 if (tmpl_default != NULL_TREE && parm_default != NULL_TREE)
4205 /* We have in [temp.param]:
4207 A template-parameter may not be given default arguments
4208 by two different declarations in the same scope. */
4209 error ("redefinition of default argument for %q#D", parm);
4210 inform ("%Joriginal definition appeared here", tmpl_parm);
4214 if (parm_default != NULL_TREE)
4215 /* Update the previous template parameters (which are the ones
4216 that will really count) with the new default value. */
4217 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default;
4218 else if (tmpl_default != NULL_TREE)
4219 /* Update the new parameters, too; they'll be used as the
4220 parameters for any members. */
4221 TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default;
4227 /* Simplify EXPR if it is a non-dependent expression. Returns the
4228 (possibly simplified) expression. */
4231 fold_non_dependent_expr (tree expr)
4233 if (expr == NULL_TREE)
4236 /* If we're in a template, but EXPR isn't value dependent, simplify
4237 it. We're supposed to treat:
4239 template <typename T> void f(T[1 + 1]);
4240 template <typename T> void f(T[2]);
4242 as two declarations of the same function, for example. */
4243 if (processing_template_decl
4244 && !type_dependent_expression_p (expr)
4245 && !value_dependent_expression_p (expr))
4247 HOST_WIDE_INT saved_processing_template_decl;
4249 saved_processing_template_decl = processing_template_decl;
4250 processing_template_decl = 0;
4251 expr = tsubst_copy_and_build (expr,
4254 /*in_decl=*/NULL_TREE,
4255 /*function_p=*/false,
4256 /*integral_constant_expression_p=*/true);
4257 processing_template_decl = saved_processing_template_decl;
4262 /* EXPR is an expression which is used in a constant-expression context.
4263 For instance, it could be a VAR_DECL with a constant initializer.
4264 Extract the innest constant expression.
4266 This is basically a more powerful version of
4267 integral_constant_value, which can be used also in templates where
4268 initializers can maintain a syntactic rather than semantic form
4269 (even if they are non-dependent, for access-checking purposes). */
4272 fold_decl_constant_value (tree expr)
4274 tree const_expr = expr;
4277 expr = fold_non_dependent_expr (const_expr);
4278 const_expr = integral_constant_value (expr);
4280 while (expr != const_expr);
4285 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
4286 must be a function or a pointer-to-function type, as specified
4287 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
4288 and check that the resulting function has external linkage. */
4291 convert_nontype_argument_function (tree type, tree expr)
4296 fn = instantiate_type (type, fns, tf_none);
4297 if (fn == error_mark_node)
4298 return error_mark_node;
4301 if (TREE_CODE (fn_no_ptr) == ADDR_EXPR)
4302 fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0);
4303 if (TREE_CODE (fn_no_ptr) == BASELINK)
4304 fn_no_ptr = BASELINK_FUNCTIONS (fn_no_ptr);
4306 /* [temp.arg.nontype]/1
4308 A template-argument for a non-type, non-template template-parameter
4311 -- the address of an object or function with external linkage. */
4312 if (!DECL_EXTERNAL_LINKAGE_P (fn_no_ptr))
4314 error ("%qE is not a valid template argument for type %qT "
4315 "because function %qD has not external linkage",
4316 expr, type, fn_no_ptr);
4323 /* Attempt to convert the non-type template parameter EXPR to the
4324 indicated TYPE. If the conversion is successful, return the
4325 converted value. If the conversion is unsuccessful, return
4326 NULL_TREE if we issued an error message, or error_mark_node if we
4327 did not. We issue error messages for out-and-out bad template
4328 parameters, but not simply because the conversion failed, since we
4329 might be just trying to do argument deduction. Both TYPE and EXPR
4330 must be non-dependent.
4332 The conversion follows the special rules described in
4333 [temp.arg.nontype], and it is much more strict than an implicit
4336 This function is called twice for each template argument (see
4337 lookup_template_class for a more accurate description of this
4338 problem). This means that we need to handle expressions which
4339 are not valid in a C++ source, but can be created from the
4340 first call (for instance, casts to perform conversions). These
4341 hacks can go away after we fix the double coercion problem. */
4344 convert_nontype_argument (tree type, tree expr)
4348 /* Detect immediately string literals as invalid non-type argument.
4349 This special-case is not needed for correctness (we would easily
4350 catch this later), but only to provide better diagnostic for this
4351 common user mistake. As suggested by DR 100, we do not mention
4352 linkage issues in the diagnostic as this is not the point. */
4353 if (TREE_CODE (expr) == STRING_CST)
4355 error ("%qE is not a valid template argument for type %qT "
4356 "because string literals can never be used in this context",
4361 /* If we are in a template, EXPR may be non-dependent, but still
4362 have a syntactic, rather than semantic, form. For example, EXPR
4363 might be a SCOPE_REF, rather than the VAR_DECL to which the
4364 SCOPE_REF refers. Preserving the qualifying scope is necessary
4365 so that access checking can be performed when the template is
4366 instantiated -- but here we need the resolved form so that we can
4367 convert the argument. */
4368 expr = fold_non_dependent_expr (expr);
4369 if (error_operand_p (expr))
4370 return error_mark_node;
4371 expr_type = TREE_TYPE (expr);
4373 /* HACK: Due to double coercion, we can get a
4374 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
4375 which is the tree that we built on the first call (see
4376 below when coercing to reference to object or to reference to
4377 function). We just strip everything and get to the arg.
4378 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
4380 if (TREE_CODE (expr) == NOP_EXPR)
4382 if (TYPE_REF_OBJ_P (type) || TYPE_REFFN_P (type))
4384 /* ??? Maybe we could use convert_from_reference here, but we
4385 would need to relax its constraints because the NOP_EXPR
4386 could actually change the type to something more cv-qualified,
4387 and this is not folded by convert_from_reference. */
4388 tree addr = TREE_OPERAND (expr, 0);
4389 gcc_assert (TREE_CODE (expr_type) == REFERENCE_TYPE);
4390 gcc_assert (TREE_CODE (addr) == ADDR_EXPR);
4391 gcc_assert (TREE_CODE (TREE_TYPE (addr)) == POINTER_TYPE);
4392 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4393 (TREE_TYPE (expr_type),
4394 TREE_TYPE (TREE_TYPE (addr))));
4396 expr = TREE_OPERAND (addr, 0);
4397 expr_type = TREE_TYPE (expr);
4400 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
4401 parameter is a pointer to object, through decay and
4402 qualification conversion. Let's strip everything. */
4403 else if (TYPE_PTROBV_P (type))
4406 gcc_assert (TREE_CODE (expr) == ADDR_EXPR);
4407 gcc_assert (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE);
4408 /* Skip the ADDR_EXPR only if it is part of the decay for
4409 an array. Otherwise, it is part of the original argument
4410 in the source code. */
4411 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == ARRAY_TYPE)
4412 expr = TREE_OPERAND (expr, 0);
4413 expr_type = TREE_TYPE (expr);
4417 /* [temp.arg.nontype]/5, bullet 1
4419 For a non-type template-parameter of integral or enumeration type,
4420 integral promotions (_conv.prom_) and integral conversions
4421 (_conv.integral_) are applied. */
4422 if (INTEGRAL_TYPE_P (type))
4424 if (!INTEGRAL_TYPE_P (expr_type))
4425 return error_mark_node;
4427 expr = fold_decl_constant_value (expr);
4428 /* Notice that there are constant expressions like '4 % 0' which
4429 do not fold into integer constants. */
4430 if (TREE_CODE (expr) != INTEGER_CST)
4432 error ("%qE is not a valid template argument for type %qT "
4433 "because it is a non-constant expression", expr, type);
4437 /* At this point, an implicit conversion does what we want,
4438 because we already know that the expression is of integral
4440 expr = ocp_convert (type, expr, CONV_IMPLICIT, LOOKUP_PROTECT);
4441 if (expr == error_mark_node)
4442 return error_mark_node;
4444 /* Conversion was allowed: fold it to a bare integer constant. */
4447 /* [temp.arg.nontype]/5, bullet 2
4449 For a non-type template-parameter of type pointer to object,
4450 qualification conversions (_conv.qual_) and the array-to-pointer
4451 conversion (_conv.array_) are applied. */
4452 else if (TYPE_PTROBV_P (type))
4454 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
4456 A template-argument for a non-type, non-template template-parameter
4457 shall be one of: [...]
4459 -- the name of a non-type template-parameter;
4460 -- the address of an object or function with external linkage, [...]
4461 expressed as "& id-expression" where the & is optional if the name
4462 refers to a function or array, or if the corresponding
4463 template-parameter is a reference.
4465 Here, we do not care about functions, as they are invalid anyway
4466 for a parameter of type pointer-to-object. */
4468 if (DECL_P (expr) && DECL_TEMPLATE_PARM_P (expr))
4469 /* Non-type template parameters are OK. */
4471 else if (TREE_CODE (expr) != ADDR_EXPR
4472 && TREE_CODE (expr_type) != ARRAY_TYPE)
4474 if (TREE_CODE (expr) == VAR_DECL)
4476 error ("%qD is not a valid template argument "
4477 "because %qD is a variable, not the address of "
4482 /* Other values, like integer constants, might be valid
4483 non-type arguments of some other type. */
4484 return error_mark_node;
4490 decl = ((TREE_CODE (expr) == ADDR_EXPR)
4491 ? TREE_OPERAND (expr, 0) : expr);
4492 if (TREE_CODE (decl) != VAR_DECL)
4494 error ("%qE is not a valid template argument of type %qT "
4495 "because %qE is not a variable",
4499 else if (!DECL_EXTERNAL_LINKAGE_P (decl))
4501 error ("%qE is not a valid template argument of type %qT "
4502 "because %qD does not have external linkage",
4508 expr = decay_conversion (expr);
4509 if (expr == error_mark_node)
4510 return error_mark_node;
4512 expr = perform_qualification_conversions (type, expr);
4513 if (expr == error_mark_node)
4514 return error_mark_node;
4516 /* [temp.arg.nontype]/5, bullet 3
4518 For a non-type template-parameter of type reference to object, no
4519 conversions apply. The type referred to by the reference may be more
4520 cv-qualified than the (otherwise identical) type of the
4521 template-argument. The template-parameter is bound directly to the
4522 template-argument, which must be an lvalue. */
4523 else if (TYPE_REF_OBJ_P (type))
4525 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type),
4527 return error_mark_node;
4529 if (!at_least_as_qualified_p (TREE_TYPE (type), expr_type))
4531 error ("%qE is not a valid template argument for type %qT "
4532 "because of conflicts in cv-qualification", expr, type);
4536 if (!real_lvalue_p (expr))
4538 error ("%qE is not a valid template argument for type %qT "
4539 "because it is not an lvalue", expr, type);
4543 /* [temp.arg.nontype]/1
4545 A template-argument for a non-type, non-template template-parameter
4546 shall be one of: [...]
4548 -- the address of an object or function with external linkage. */
4549 if (!DECL_EXTERNAL_LINKAGE_P (expr))
4551 error ("%qE is not a valid template argument for type %qT "
4552 "because object %qD has not external linkage",
4557 expr = build_nop (type, build_address (expr));
4559 /* [temp.arg.nontype]/5, bullet 4
4561 For a non-type template-parameter of type pointer to function, only
4562 the function-to-pointer conversion (_conv.func_) is applied. If the
4563 template-argument represents a set of overloaded functions (or a
4564 pointer to such), the matching function is selected from the set
4566 else if (TYPE_PTRFN_P (type))
4568 /* If the argument is a template-id, we might not have enough
4569 context information to decay the pointer. */
4570 if (!type_unknown_p (expr_type))
4572 expr = decay_conversion (expr);
4573 if (expr == error_mark_node)
4574 return error_mark_node;
4577 expr = convert_nontype_argument_function (type, expr);
4578 if (!expr || expr == error_mark_node)
4581 /* [temp.arg.nontype]/5, bullet 5
4583 For a non-type template-parameter of type reference to function, no
4584 conversions apply. If the template-argument represents a set of
4585 overloaded functions, the matching function is selected from the set
4587 else if (TYPE_REFFN_P (type))
4589 if (TREE_CODE (expr) == ADDR_EXPR)
4591 error ("%qE is not a valid template argument for type %qT "
4592 "because it is a pointer", expr, type);
4593 inform ("try using %qE instead", TREE_OPERAND (expr, 0));
4597 expr = convert_nontype_argument_function (TREE_TYPE (type), expr);
4598 if (!expr || expr == error_mark_node)
4601 expr = build_nop (type, build_address (expr));
4603 /* [temp.arg.nontype]/5, bullet 6
4605 For a non-type template-parameter of type pointer to member function,
4606 no conversions apply. If the template-argument represents a set of
4607 overloaded member functions, the matching member function is selected
4608 from the set (_over.over_). */
4609 else if (TYPE_PTRMEMFUNC_P (type))
4611 expr = instantiate_type (type, expr, tf_none);
4612 if (expr == error_mark_node)
4613 return error_mark_node;
4615 /* There is no way to disable standard conversions in
4616 resolve_address_of_overloaded_function (called by
4617 instantiate_type). It is possible that the call succeeded by
4618 converting &B::I to &D::I (where B is a base of D), so we need
4619 to reject this conversion here.
4621 Actually, even if there was a way to disable standard conversions,
4622 it would still be better to reject them here so that we can
4623 provide a superior diagnostic. */
4624 if (!same_type_p (TREE_TYPE (expr), type))
4626 /* Make sure we are just one standard conversion off. */
4627 gcc_assert (can_convert (type, TREE_TYPE (expr)));
4628 error ("%qE is not a valid template argument for type %qT "
4629 "because it is of type %qT", expr, type,
4631 inform ("standard conversions are not allowed in this context");
4635 /* [temp.arg.nontype]/5, bullet 7
4637 For a non-type template-parameter of type pointer to data member,
4638 qualification conversions (_conv.qual_) are applied. */
4639 else if (TYPE_PTRMEM_P (type))
4641 expr = perform_qualification_conversions (type, expr);
4642 if (expr == error_mark_node)
4645 /* A template non-type parameter must be one of the above. */
4649 /* Sanity check: did we actually convert the argument to the
4651 gcc_assert (same_type_p (type, TREE_TYPE (expr)));
4656 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
4657 template template parameters. Both PARM_PARMS and ARG_PARMS are
4658 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
4661 Consider the example:
4662 template <class T> class A;
4663 template<template <class U> class TT> class B;
4665 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
4666 the parameters to A, and OUTER_ARGS contains A. */
4669 coerce_template_template_parms (tree parm_parms,
4671 tsubst_flags_t complain,
4675 int nparms, nargs, i;
4678 gcc_assert (TREE_CODE (parm_parms) == TREE_VEC);
4679 gcc_assert (TREE_CODE (arg_parms) == TREE_VEC);
4681 nparms = TREE_VEC_LENGTH (parm_parms);
4682 nargs = TREE_VEC_LENGTH (arg_parms);
4684 if (nargs != nparms)
4687 for (i = 0; i < nparms; ++i)
4689 if (TREE_VEC_ELT (parm_parms, i) == error_mark_node
4690 || TREE_VEC_ELT (arg_parms, i) == error_mark_node)
4693 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
4694 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
4696 if (arg == NULL_TREE || arg == error_mark_node
4697 || parm == NULL_TREE || parm == error_mark_node)
4700 if (TREE_CODE (arg) != TREE_CODE (parm))
4703 switch (TREE_CODE (parm))
4706 /* We encounter instantiations of templates like
4707 template <template <template <class> class> class TT>
4710 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
4711 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
4713 if (!coerce_template_template_parms
4714 (parmparm, argparm, complain, in_decl, outer_args))
4720 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm))
4721 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg)))
4722 /* One is a parameter pack, the other is not. */
4727 /* The tsubst call is used to handle cases such as
4729 template <int> class C {};
4730 template <class T, template <T> class TT> class D {};
4733 i.e. the parameter list of TT depends on earlier parameters. */
4734 if (!dependent_type_p (TREE_TYPE (arg))
4736 (tsubst (TREE_TYPE (parm), outer_args, complain, in_decl),
4740 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm))
4741 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg)))
4742 /* One is a parameter pack, the other is not. */
4753 /* Convert the indicated template ARG as necessary to match the
4754 indicated template PARM. Returns the converted ARG, or
4755 error_mark_node if the conversion was unsuccessful. Error and
4756 warning messages are issued under control of COMPLAIN. This
4757 conversion is for the Ith parameter in the parameter list. ARGS is
4758 the full set of template arguments deduced so far. */
4761 convert_template_argument (tree parm,
4764 tsubst_flags_t complain,
4770 int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
4772 if (TREE_CODE (arg) == TREE_LIST
4773 && TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF)
4775 /* The template argument was the name of some
4776 member function. That's usually
4777 invalid, but static members are OK. In any
4778 case, grab the underlying fields/functions
4779 and issue an error later if required. */
4780 orig_arg = TREE_VALUE (arg);
4781 TREE_TYPE (arg) = unknown_type_node;
4786 requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
4787 requires_type = (TREE_CODE (parm) == TYPE_DECL
4788 || requires_tmpl_type);
4790 /* When determining whether an argument pack expansion is a template,
4791 look at the pattern. */
4792 if (TREE_CODE (arg) == TYPE_PACK_EXPANSION)
4793 arg = PACK_EXPANSION_PATTERN (arg);
4796 ((TREE_CODE (arg) == TEMPLATE_DECL
4797 && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
4798 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4799 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
4802 && (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4803 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE))
4804 arg = TYPE_STUB_DECL (arg);
4806 is_type = TYPE_P (arg) || is_tmpl_type;
4808 if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
4809 && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
4811 pedwarn ("to refer to a type member of a template parameter, "
4812 "use %<typename %E%>", orig_arg);
4814 orig_arg = make_typename_type (TREE_OPERAND (arg, 0),
4815 TREE_OPERAND (arg, 1),
4817 complain & tf_error);
4821 if (is_type != requires_type)
4825 if (complain & tf_error)
4827 error ("type/value mismatch at argument %d in template "
4828 "parameter list for %qD",
4831 error (" expected a constant of type %qT, got %qT",
4833 (DECL_P (arg) ? DECL_NAME (arg) : orig_arg));
4834 else if (requires_tmpl_type)
4835 error (" expected a class template, got %qE", orig_arg);
4837 error (" expected a type, got %qE", orig_arg);
4840 return error_mark_node;
4842 if (is_tmpl_type ^ requires_tmpl_type)
4844 if (in_decl && (complain & tf_error))
4846 error ("type/value mismatch at argument %d in template "
4847 "parameter list for %qD",
4850 error (" expected a type, got %qT", DECL_NAME (arg));
4852 error (" expected a class template, got %qT", orig_arg);
4854 return error_mark_node;
4859 if (requires_tmpl_type)
4861 if (TREE_CODE (TREE_TYPE (arg)) == UNBOUND_CLASS_TEMPLATE)
4862 /* The number of argument required is not known yet.
4863 Just accept it for now. */
4864 val = TREE_TYPE (arg);
4867 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
4870 argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
4872 if (coerce_template_template_parms (parmparm, argparm,
4878 /* TEMPLATE_TEMPLATE_PARM node is preferred over
4880 if (val != error_mark_node)
4882 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val))
4883 val = TREE_TYPE (val);
4884 else if (TREE_CODE (val) == TYPE_PACK_EXPANSION
4885 && DECL_TEMPLATE_TEMPLATE_PARM_P (arg))
4887 val = TREE_TYPE (arg);
4888 val = make_pack_expansion (val);
4894 if (in_decl && (complain & tf_error))
4896 error ("type/value mismatch at argument %d in "
4897 "template parameter list for %qD",
4899 error (" expected a template of type %qD, got %qD",
4903 val = error_mark_node;
4909 /* We only form one instance of each template specialization.
4910 Therefore, if we use a non-canonical variant (i.e., a
4911 typedef), any future messages referring to the type will use
4912 the typedef, which is confusing if those future uses do not
4913 themselves also use the typedef. */
4915 val = canonical_type_variant (val);
4919 tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl);
4921 if (invalid_nontype_parm_type_p (t, complain))
4922 return error_mark_node;
4924 if (!uses_template_parms (orig_arg) && !uses_template_parms (t))
4925 /* We used to call digest_init here. However, digest_init
4926 will report errors, which we don't want when complain
4927 is zero. More importantly, digest_init will try too
4928 hard to convert things: for example, `0' should not be
4929 converted to pointer type at this point according to
4930 the standard. Accepting this is not merely an
4931 extension, since deciding whether or not these
4932 conversions can occur is part of determining which
4933 function template to call, or whether a given explicit
4934 argument specification is valid. */
4935 val = convert_nontype_argument (t, orig_arg);
4939 if (val == NULL_TREE)
4940 val = error_mark_node;
4941 else if (val == error_mark_node && (complain & tf_error))
4942 error ("could not convert template argument %qE to %qT", orig_arg, t);
4948 /* Coerces the remaining template arguments in INNER_ARGS (from
4949 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
4950 Returns the coerced argument pack. PARM_IDX is the position of this
4951 parameter in the template parameter list. ARGS is the original
4952 template argument list. */
4954 coerce_template_parameter_pack (tree parms,
4962 tsubst_flags_t complain)
4964 tree parm = TREE_VEC_ELT (parms, parm_idx);
4965 int nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
4968 tree packed_types = NULL_TREE;
4970 if (arg_idx > nargs)
4973 packed_args = make_tree_vec (nargs - arg_idx);
4975 if (TREE_CODE (TREE_VALUE (parm)) == PARM_DECL
4976 && uses_parameter_packs (TREE_TYPE (TREE_VALUE (parm))))
4978 /* When the template parameter is a non-type template
4979 parameter pack whose type uses parameter packs, we need
4980 to look at each of the template arguments
4981 separately. Build a vector of the types for these
4982 non-type template parameters in PACKED_TYPES. */
4984 = make_pack_expansion (TREE_TYPE (TREE_VALUE (parm)));
4985 packed_types = tsubst_pack_expansion (expansion, args,
4988 if (packed_types == error_mark_node)
4989 return error_mark_node;
4991 /* Check that we have the right number of arguments. */
4993 && !PACK_EXPANSION_P (TREE_VEC_ELT (inner_args, arg_idx))
4994 && nargs - arg_idx != TREE_VEC_LENGTH (packed_types))
4997 = TREE_VEC_LENGTH (parms) - 1 + TREE_VEC_LENGTH (packed_types);
4998 error ("wrong number of template arguments (%d, should be %d)",
4999 nargs, needed_parms);
5000 return error_mark_node;
5003 /* If we aren't able to check the actual arguments now
5004 (because they haven't been expanded yet), we can at least
5005 verify that all of the types used for the non-type
5006 template parameter pack are, in fact, valid for non-type
5007 template parameters. */
5009 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args, arg_idx)))
5011 int j, len = TREE_VEC_LENGTH (packed_types);
5012 for (j = 0; j < len; ++j)
5014 tree t = TREE_VEC_ELT (packed_types, j);
5015 if (invalid_nontype_parm_type_p (t, complain))
5016 return error_mark_node;
5021 /* Convert the remaining arguments, which will be a part of the
5022 parameter pack "parm". */
5023 for (; arg_idx < nargs; ++arg_idx)
5025 tree arg = TREE_VEC_ELT (inner_args, arg_idx);
5026 tree actual_parm = TREE_VALUE (parm);
5028 if (packed_types && !PACK_EXPANSION_P (arg))
5030 /* When we have a vector of types (corresponding to the
5031 non-type template parameter pack that uses parameter
5032 packs in its type, as mention above), and the
5033 argument is not an expansion (which expands to a
5034 currently unknown number of arguments), clone the
5035 parm and give it the next type in PACKED_TYPES. */
5036 actual_parm = copy_node (actual_parm);
5037 TREE_TYPE (actual_parm) =
5038 TREE_VEC_ELT (packed_types, arg_idx - parm_idx);
5041 if (arg != error_mark_node)
5042 arg = convert_template_argument (actual_parm,
5043 arg, new_args, complain, parm_idx,
5045 if (arg == error_mark_node)
5047 TREE_VEC_ELT (packed_args, arg_idx - parm_idx) = arg;
5050 if (TREE_CODE (TREE_VALUE (parm)) == TYPE_DECL
5051 || TREE_CODE (TREE_VALUE (parm)) == TEMPLATE_DECL)
5052 argument_pack = make_node (TYPE_ARGUMENT_PACK);
5055 argument_pack = make_node (NONTYPE_ARGUMENT_PACK);
5056 TREE_TYPE (argument_pack)
5057 = tsubst (TREE_TYPE (TREE_VALUE (parm)), args, complain, in_decl);
5058 TREE_CONSTANT (argument_pack) = 1;
5061 SET_ARGUMENT_PACK_ARGS (argument_pack, packed_args);
5062 return argument_pack;
5065 /* Convert all template arguments to their appropriate types, and
5066 return a vector containing the innermost resulting template
5067 arguments. If any error occurs, return error_mark_node. Error and
5068 warning messages are issued under control of COMPLAIN.
5070 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
5071 for arguments not specified in ARGS. Otherwise, if
5072 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
5073 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
5074 USE_DEFAULT_ARGS is false, then all arguments must be specified in
5078 coerce_template_parms (tree parms,
5081 tsubst_flags_t complain,
5082 bool require_all_args,
5083 bool use_default_args)
5085 int nparms, nargs, parm_idx, arg_idx, lost = 0;
5088 tree new_inner_args;
5089 bool saved_skip_evaluation;
5091 /* When used as a boolean value, indicates whether this is a
5092 variadic template parameter list. Since it's an int, we can also
5093 subtract it from nparms to get the number of non-variadic
5098 = expand_template_argument_pack (INNERMOST_TEMPLATE_ARGS (args));
5100 nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
5101 nparms = TREE_VEC_LENGTH (parms);
5103 /* Determine if there are any parameter packs. */
5104 for (parm_idx = 0; parm_idx < nparms; ++parm_idx)
5106 tree tparm = TREE_VALUE (TREE_VEC_ELT (parms, parm_idx));
5107 if (template_parameter_pack_p (tparm))
5114 if ((nargs > nparms - variadic_p && !variadic_p)
5115 || (nargs < nparms - variadic_p
5117 && (!use_default_args
5118 || (TREE_VEC_ELT (parms, nargs) != error_mark_node
5119 && !TREE_PURPOSE (TREE_VEC_ELT (parms, nargs))))))
5121 if (complain & tf_error)
5123 const char *or_more = "";
5126 or_more = " or more";
5130 error ("wrong number of template arguments (%d, should be %d%s)",
5131 nargs, nparms, or_more);
5134 error ("provided for %q+D", in_decl);
5137 return error_mark_node;
5140 /* We need to evaluate the template arguments, even though this
5141 template-id may be nested within a "sizeof". */
5142 saved_skip_evaluation = skip_evaluation;
5143 skip_evaluation = false;
5144 new_inner_args = make_tree_vec (nparms);
5145 new_args = add_outermost_template_args (args, new_inner_args);
5146 for (parm_idx = 0, arg_idx = 0; parm_idx < nparms; parm_idx++, arg_idx++)
5151 /* Get the Ith template parameter. */
5152 parm = TREE_VEC_ELT (parms, parm_idx);
5154 if (parm == error_mark_node)
5156 TREE_VEC_ELT (new_inner_args, arg_idx) = error_mark_node;
5160 /* Calculate the next argument. */
5161 if (template_parameter_pack_p (TREE_VALUE (parm)))
5163 /* All remaining arguments will be placed in the
5164 template parameter pack PARM. */
5165 arg = coerce_template_parameter_pack (parms, parm_idx, args,
5166 inner_args, arg_idx,
5170 /* Store this argument. */
5171 if (arg == error_mark_node)
5173 TREE_VEC_ELT (new_inner_args, parm_idx) = arg;
5175 /* We are done with all of the arguments. */
5180 else if (arg_idx < nargs)
5182 arg = TREE_VEC_ELT (inner_args, arg_idx);
5184 if (arg && PACK_EXPANSION_P (arg))
5186 /* If ARG is a pack expansion, but PARM is not a
5187 template parameter pack (if it were, we would have
5188 handled it above), we're trying to expand into a
5189 fixed-length argument list. */
5190 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
5191 error ("cannot expand %<%E%> into a fixed-length "
5192 "argument list", arg);
5194 error ("cannot expand %<%T%> into a fixed-length "
5195 "argument list", arg);
5196 return error_mark_node;
5199 else if (require_all_args)
5200 /* There must be a default arg in this case. */
5201 arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
5206 if (arg == error_mark_node)
5208 if (complain & tf_error)
5209 error ("template argument %d is invalid", arg_idx + 1);
5212 /* This only occurs if there was an error in the template
5213 parameter list itself (which we would already have
5214 reported) that we are trying to recover from, e.g., a class
5215 template with a parameter list such as
5216 template<typename..., typename>. */
5217 return error_mark_node;
5219 arg = convert_template_argument (TREE_VALUE (parm),
5220 arg, new_args, complain,
5223 if (arg == error_mark_node)
5225 TREE_VEC_ELT (new_inner_args, arg_idx) = arg;
5227 skip_evaluation = saved_skip_evaluation;
5230 return error_mark_node;
5232 return new_inner_args;
5235 /* Returns 1 if template args OT and NT are equivalent. */
5238 template_args_equal (tree ot, tree nt)
5243 if (TREE_CODE (nt) == TREE_VEC)
5244 /* For member templates */
5245 return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt);
5246 else if (PACK_EXPANSION_P (ot))
5247 return PACK_EXPANSION_P (nt)
5248 && template_args_equal (PACK_EXPANSION_PATTERN (ot),
5249 PACK_EXPANSION_PATTERN (nt));
5250 else if (TYPE_P (nt))
5251 return TYPE_P (ot) && same_type_p (ot, nt);
5252 else if (TREE_CODE (ot) == TREE_VEC || TYPE_P (ot))
5255 return cp_tree_equal (ot, nt);
5258 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
5259 of template arguments. Returns 0 otherwise. */
5262 comp_template_args (tree oldargs, tree newargs)
5266 oldargs = expand_template_argument_pack (oldargs);
5267 newargs = expand_template_argument_pack (newargs);
5269 if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
5272 for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
5274 tree nt = TREE_VEC_ELT (newargs, i);
5275 tree ot = TREE_VEC_ELT (oldargs, i);
5277 if (! template_args_equal (ot, nt))
5284 add_pending_template (tree d)
5286 tree ti = (TYPE_P (d)
5287 ? CLASSTYPE_TEMPLATE_INFO (d)
5288 : DECL_TEMPLATE_INFO (d));
5289 struct pending_template *pt;
5292 if (TI_PENDING_TEMPLATE_FLAG (ti))
5295 /* We are called both from instantiate_decl, where we've already had a
5296 tinst_level pushed, and instantiate_template, where we haven't.
5298 level = !current_tinst_level || current_tinst_level->decl != d;
5301 push_tinst_level (d);
5303 pt = GGC_NEW (struct pending_template);
5305 pt->tinst = current_tinst_level;
5306 if (last_pending_template)
5307 last_pending_template->next = pt;
5309 pending_templates = pt;
5311 last_pending_template = pt;
5313 TI_PENDING_TEMPLATE_FLAG (ti) = 1;
5320 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
5321 ARGLIST. Valid choices for FNS are given in the cp-tree.def
5322 documentation for TEMPLATE_ID_EXPR. */
5325 lookup_template_function (tree fns, tree arglist)
5329 if (fns == error_mark_node || arglist == error_mark_node)
5330 return error_mark_node;
5332 gcc_assert (!arglist || TREE_CODE (arglist) == TREE_VEC);
5333 gcc_assert (fns && (is_overloaded_fn (fns)
5334 || TREE_CODE (fns) == IDENTIFIER_NODE));
5336 if (BASELINK_P (fns))
5338 BASELINK_FUNCTIONS (fns) = build2 (TEMPLATE_ID_EXPR,
5340 BASELINK_FUNCTIONS (fns),
5345 type = TREE_TYPE (fns);
5346 if (TREE_CODE (fns) == OVERLOAD || !type)
5347 type = unknown_type_node;
5349 return build2 (TEMPLATE_ID_EXPR, type, fns, arglist);
5352 /* Within the scope of a template class S<T>, the name S gets bound
5353 (in build_self_reference) to a TYPE_DECL for the class, not a
5354 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
5355 or one of its enclosing classes, and that type is a template,
5356 return the associated TEMPLATE_DECL. Otherwise, the original
5357 DECL is returned. */
5360 maybe_get_template_decl_from_type_decl (tree decl)
5362 return (decl != NULL_TREE
5363 && TREE_CODE (decl) == TYPE_DECL
5364 && DECL_ARTIFICIAL (decl)
5365 && CLASS_TYPE_P (TREE_TYPE (decl))
5366 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
5367 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl;
5370 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
5371 parameters, find the desired type.
5373 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
5375 IN_DECL, if non-NULL, is the template declaration we are trying to
5378 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
5379 the class we are looking up.
5381 Issue error and warning messages under control of COMPLAIN.
5383 If the template class is really a local class in a template
5384 function, then the FUNCTION_CONTEXT is the function in which it is
5387 ??? Note that this function is currently called *twice* for each
5388 template-id: the first time from the parser, while creating the
5389 incomplete type (finish_template_type), and the second type during the
5390 real instantiation (instantiate_template_class). This is surely something
5391 that we want to avoid. It also causes some problems with argument
5392 coercion (see convert_nontype_argument for more information on this). */
5395 lookup_template_class (tree d1,
5400 tsubst_flags_t complain)
5402 tree template = NULL_TREE, parmlist;
5405 timevar_push (TV_NAME_LOOKUP);
5407 if (TREE_CODE (d1) == IDENTIFIER_NODE)
5409 tree value = innermost_non_namespace_value (d1);
5410 if (value && DECL_TEMPLATE_TEMPLATE_PARM_P (value))
5415 push_decl_namespace (context);
5416 template = lookup_name (d1);
5417 template = maybe_get_template_decl_from_type_decl (template);
5419 pop_decl_namespace ();
5422 context = DECL_CONTEXT (template);
5424 else if (TREE_CODE (d1) == TYPE_DECL && IS_AGGR_TYPE (TREE_TYPE (d1)))
5426 tree type = TREE_TYPE (d1);
5428 /* If we are declaring a constructor, say A<T>::A<T>, we will get
5429 an implicit typename for the second A. Deal with it. */
5430 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5431 type = TREE_TYPE (type);
5433 if (CLASSTYPE_TEMPLATE_INFO (type))
5435 template = CLASSTYPE_TI_TEMPLATE (type);
5436 d1 = DECL_NAME (template);
5439 else if (TREE_CODE (d1) == ENUMERAL_TYPE
5440 || (TYPE_P (d1) && IS_AGGR_TYPE (d1)))
5442 template = TYPE_TI_TEMPLATE (d1);
5443 d1 = DECL_NAME (template);
5445 else if (TREE_CODE (d1) == TEMPLATE_DECL
5446 && TREE_CODE (DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL)
5449 d1 = DECL_NAME (template);
5450 context = DECL_CONTEXT (template);
5453 /* Issue an error message if we didn't find a template. */
5456 if (complain & tf_error)
5457 error ("%qT is not a template", d1);
5458 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5461 if (TREE_CODE (template) != TEMPLATE_DECL
5462 /* Make sure it's a user visible template, if it was named by
5464 || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (template)
5465 && !PRIMARY_TEMPLATE_P (template)))
5467 if (complain & tf_error)
5469 error ("non-template type %qT used as a template", d1);
5471 error ("for template declaration %q+D", in_decl);
5473 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5476 complain &= ~tf_user;
5478 if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
5480 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
5481 template arguments */
5487 parmlist = DECL_INNERMOST_TEMPLATE_PARMS (template);
5489 /* Consider an example where a template template parameter declared as
5491 template <class T, class U = std::allocator<T> > class TT
5493 The template parameter level of T and U are one level larger than
5494 of TT. To proper process the default argument of U, say when an
5495 instantiation `TT<int>' is seen, we need to build the full
5496 arguments containing {int} as the innermost level. Outer levels,
5497 available when not appearing as default template argument, can be
5498 obtained from the arguments of the enclosing template.
5500 Suppose that TT is later substituted with std::vector. The above
5501 instantiation is `TT<int, std::allocator<T> >' with TT at
5502 level 1, and T at level 2, while the template arguments at level 1
5503 becomes {std::vector} and the inner level 2 is {int}. */
5505 outer = DECL_CONTEXT (template);
5507 outer = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer)));
5508 else if (current_template_parms)
5509 /* This is an argument of the current template, so we haven't set
5510 DECL_CONTEXT yet. */
5511 outer = current_template_args ();
5514 arglist = add_to_template_args (outer, arglist);
5516 arglist2 = coerce_template_parms (parmlist, arglist, template,
5518 /*require_all_args=*/true,
5519 /*use_default_args=*/true);
5520 if (arglist2 == error_mark_node
5521 || (!uses_template_parms (arglist2)
5522 && check_instantiated_args (template, arglist2, complain)))
5523 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5525 parm = bind_template_template_parm (TREE_TYPE (template), arglist2);
5526 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, parm);
5530 tree template_type = TREE_TYPE (template);
5533 tree found = NULL_TREE;
5536 int is_partial_instantiation;
5538 gen_tmpl = most_general_template (template);
5539 parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
5540 parm_depth = TMPL_PARMS_DEPTH (parmlist);
5541 arg_depth = TMPL_ARGS_DEPTH (arglist);
5543 if (arg_depth == 1 && parm_depth > 1)
5545 /* We've been given an incomplete set of template arguments.
5548 template <class T> struct S1 {
5549 template <class U> struct S2 {};
5550 template <class U> struct S2<U*> {};
5553 we will be called with an ARGLIST of `U*', but the
5554 TEMPLATE will be `template <class T> template
5555 <class U> struct S1<T>::S2'. We must fill in the missing
5558 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)),
5560 arg_depth = TMPL_ARGS_DEPTH (arglist);
5563 /* Now we should have enough arguments. */
5564 gcc_assert (parm_depth == arg_depth);
5566 /* From here on, we're only interested in the most general
5568 template = gen_tmpl;
5570 /* Calculate the BOUND_ARGS. These will be the args that are
5571 actually tsubst'd into the definition to create the
5575 /* We have multiple levels of arguments to coerce, at once. */
5577 int saved_depth = TMPL_ARGS_DEPTH (arglist);
5579 tree bound_args = make_tree_vec (parm_depth);
5581 for (i = saved_depth,
5582 t = DECL_TEMPLATE_PARMS (template);
5583 i > 0 && t != NULL_TREE;
5584 --i, t = TREE_CHAIN (t))
5586 tree a = coerce_template_parms (TREE_VALUE (t),
5589 /*require_all_args=*/true,
5590 /*use_default_args=*/true);
5592 /* Don't process further if one of the levels fails. */
5593 if (a == error_mark_node)
5595 /* Restore the ARGLIST to its full size. */
5596 TREE_VEC_LENGTH (arglist) = saved_depth;
5597 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5600 SET_TMPL_ARGS_LEVEL (bound_args, i, a);
5602 /* We temporarily reduce the length of the ARGLIST so
5603 that coerce_template_parms will see only the arguments
5604 corresponding to the template parameters it is
5606 TREE_VEC_LENGTH (arglist)--;
5609 /* Restore the ARGLIST to its full size. */
5610 TREE_VEC_LENGTH (arglist) = saved_depth;
5612 arglist = bound_args;
5616 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist),
5617 INNERMOST_TEMPLATE_ARGS (arglist),
5620 /*require_all_args=*/true,
5621 /*use_default_args=*/true);
5623 if (arglist == error_mark_node)
5624 /* We were unable to bind the arguments. */
5625 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5627 /* In the scope of a template class, explicit references to the
5628 template class refer to the type of the template, not any
5629 instantiation of it. For example, in:
5631 template <class T> class C { void f(C<T>); }
5633 the `C<T>' is just the same as `C'. Outside of the
5634 class, however, such a reference is an instantiation. */
5635 if (comp_template_args (TYPE_TI_ARGS (template_type),
5638 found = template_type;
5640 if (!entering_scope && PRIMARY_TEMPLATE_P (template))
5644 for (ctx = current_class_type;
5645 ctx && TREE_CODE (ctx) != NAMESPACE_DECL;
5647 ? TYPE_CONTEXT (ctx)
5648 : DECL_CONTEXT (ctx)))
5649 if (TYPE_P (ctx) && same_type_p (ctx, template_type))
5652 /* We're not in the scope of the class, so the
5653 TEMPLATE_TYPE is not the type we want after all. */
5659 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
5661 /* If we already have this specialization, return it. */
5662 found = retrieve_specialization (template, arglist,
5663 /*class_specializations_p=*/false);
5665 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
5667 /* This type is a "partial instantiation" if any of the template
5668 arguments still involve template parameters. Note that we set
5669 IS_PARTIAL_INSTANTIATION for partial specializations as
5671 is_partial_instantiation = uses_template_parms (arglist);
5673 /* If the deduced arguments are invalid, then the binding
5675 if (!is_partial_instantiation
5676 && check_instantiated_args (template,
5677 INNERMOST_TEMPLATE_ARGS (arglist),
5679 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5681 if (!is_partial_instantiation
5682 && !PRIMARY_TEMPLATE_P (template)
5683 && TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL)
5685 found = xref_tag_from_type (TREE_TYPE (template),
5686 DECL_NAME (template),
5687 /*tag_scope=*/ts_global);
5688 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
5691 context = tsubst (DECL_CONTEXT (template), arglist,
5694 context = global_namespace;
5696 /* Create the type. */
5697 if (TREE_CODE (template_type) == ENUMERAL_TYPE)
5699 if (!is_partial_instantiation)
5701 set_current_access_from_decl (TYPE_NAME (template_type));
5702 t = start_enum (TYPE_IDENTIFIER (template_type));
5705 /* We don't want to call start_enum for this type, since
5706 the values for the enumeration constants may involve
5707 template parameters. And, no one should be interested
5708 in the enumeration constants for such a type. */
5709 t = make_node (ENUMERAL_TYPE);
5713 t = make_aggr_type (TREE_CODE (template_type));
5714 CLASSTYPE_DECLARED_CLASS (t)
5715 = CLASSTYPE_DECLARED_CLASS (template_type);
5716 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
5717 TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);
5719 /* A local class. Make sure the decl gets registered properly. */
5720 if (context == current_function_decl)
5721 pushtag (DECL_NAME (template), t, /*tag_scope=*/ts_current);
5723 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type), arglist))
5724 /* This instantiation is another name for the primary
5725 template type. Set the TYPE_CANONICAL field
5727 TYPE_CANONICAL (t) = template_type;
5728 else if (any_template_arguments_need_structural_equality_p (arglist))
5729 /* Some of the template arguments require structural
5730 equality testing, so this template class requires
5731 structural equality testing. */
5732 SET_TYPE_STRUCTURAL_EQUALITY (t);
5735 /* If we called start_enum or pushtag above, this information
5736 will already be set up. */
5739 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5741 type_decl = create_implicit_typedef (DECL_NAME (template), t);
5742 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
5743 TYPE_STUB_DECL (t) = type_decl;
5744 DECL_SOURCE_LOCATION (type_decl)
5745 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type));
5748 type_decl = TYPE_NAME (t);
5750 TREE_PRIVATE (type_decl)
5751 = TREE_PRIVATE (TYPE_STUB_DECL (template_type));
5752 TREE_PROTECTED (type_decl)
5753 = TREE_PROTECTED (TYPE_STUB_DECL (template_type));
5754 DECL_IN_SYSTEM_HEADER (type_decl)
5755 = DECL_IN_SYSTEM_HEADER (template);
5756 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type))
5758 DECL_VISIBILITY_SPECIFIED (type_decl) = 1;
5759 DECL_VISIBILITY (type_decl) = CLASSTYPE_VISIBILITY (template_type);
5762 /* Set up the template information. We have to figure out which
5763 template is the immediate parent if this is a full
5765 if (parm_depth == 1 || is_partial_instantiation
5766 || !PRIMARY_TEMPLATE_P (template))
5767 /* This case is easy; there are no member templates involved. */
5771 /* This is a full instantiation of a member template. Look
5772 for a partial instantiation of which this is an instance. */
5774 for (found = DECL_TEMPLATE_INSTANTIATIONS (template);
5775 found; found = TREE_CHAIN (found))
5778 tree tmpl = CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found));
5780 /* We only want partial instantiations, here, not
5781 specializations or full instantiations. */
5782 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found))
5783 || !uses_template_parms (TREE_VALUE (found)))
5786 /* Temporarily reduce by one the number of levels in the
5787 ARGLIST and in FOUND so as to avoid comparing the
5788 last set of arguments. */
5789 TREE_VEC_LENGTH (arglist)--;
5790 TREE_VEC_LENGTH (TREE_PURPOSE (found)) --;
5792 /* See if the arguments match. If they do, then TMPL is
5793 the partial instantiation we want. */
5794 success = comp_template_args (TREE_PURPOSE (found), arglist);
5796 /* Restore the argument vectors to their full size. */
5797 TREE_VEC_LENGTH (arglist)++;
5798 TREE_VEC_LENGTH (TREE_PURPOSE (found))++;
5809 /* There was no partial instantiation. This happens
5810 where C<T> is a member template of A<T> and it's used
5813 template <typename T> struct B { A<T>::C<int> m; };
5816 Create the partial instantiation.
5818 TREE_VEC_LENGTH (arglist)--;
5819 found = tsubst (template, arglist, complain, NULL_TREE);
5820 TREE_VEC_LENGTH (arglist)++;
5824 SET_TYPE_TEMPLATE_INFO (t, tree_cons (found, arglist, NULL_TREE));
5825 DECL_TEMPLATE_INSTANTIATIONS (template)
5826 = tree_cons (arglist, t,
5827 DECL_TEMPLATE_INSTANTIATIONS (template));
5829 if (TREE_CODE (t) == ENUMERAL_TYPE
5830 && !is_partial_instantiation)
5831 /* Now that the type has been registered on the instantiations
5832 list, we set up the enumerators. Because the enumeration
5833 constants may involve the enumeration type itself, we make
5834 sure to register the type first, and then create the
5835 constants. That way, doing tsubst_expr for the enumeration
5836 constants won't result in recursive calls here; we'll find
5837 the instantiation and exit above. */
5838 tsubst_enum (template_type, t, arglist);
5840 if (is_partial_instantiation)
5841 /* If the type makes use of template parameters, the
5842 code that generates debugging information will crash. */
5843 DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1;
5845 /* Possibly limit visibility based on template args. */
5846 TREE_PUBLIC (type_decl) = 1;
5847 determine_visibility (type_decl);
5849 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
5851 timevar_pop (TV_NAME_LOOKUP);
5858 struct pointer_set_t *visited;
5861 /* Called from for_each_template_parm via walk_tree. */
5864 for_each_template_parm_r (tree *tp, int *walk_subtrees, void *d)
5867 struct pair_fn_data *pfd = (struct pair_fn_data *) d;
5868 tree_fn_t fn = pfd->fn;
5869 void *data = pfd->data;
5872 && for_each_template_parm (TYPE_CONTEXT (t), fn, data, pfd->visited))
5873 return error_mark_node;
5875 switch (TREE_CODE (t))
5878 if (TYPE_PTRMEMFUNC_P (t))
5884 if (!TYPE_TEMPLATE_INFO (t))
5886 else if (for_each_template_parm (TREE_VALUE (TYPE_TEMPLATE_INFO (t)),
5887 fn, data, pfd->visited))
5888 return error_mark_node;
5892 if (for_each_template_parm (TYPE_MIN_VALUE (t),
5893 fn, data, pfd->visited)
5894 || for_each_template_parm (TYPE_MAX_VALUE (t),
5895 fn, data, pfd->visited))
5896 return error_mark_node;
5900 /* Since we're not going to walk subtrees, we have to do this
5902 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data,
5904 return error_mark_node;
5908 /* Check the return type. */
5909 if (for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
5910 return error_mark_node;
5912 /* Check the parameter types. Since default arguments are not
5913 instantiated until they are needed, the TYPE_ARG_TYPES may
5914 contain expressions that involve template parameters. But,
5915 no-one should be looking at them yet. And, once they're
5916 instantiated, they don't contain template parameters, so
5917 there's no point in looking at them then, either. */
5921 for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm))
5922 if (for_each_template_parm (TREE_VALUE (parm), fn, data,
5924 return error_mark_node;
5926 /* Since we've already handled the TYPE_ARG_TYPES, we don't
5927 want walk_tree walking into them itself. */
5933 if (for_each_template_parm (TYPE_FIELDS (t), fn, data,
5935 return error_mark_node;
5940 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
5941 && for_each_template_parm (DECL_TI_ARGS (t), fn, data,
5943 return error_mark_node;
5948 if (TREE_CODE (t) == CONST_DECL && DECL_TEMPLATE_PARM_P (t)
5949 && for_each_template_parm (DECL_INITIAL (t), fn, data,
5951 return error_mark_node;
5952 if (DECL_CONTEXT (t)
5953 && for_each_template_parm (DECL_CONTEXT (t), fn, data,
5955 return error_mark_node;
5958 case BOUND_TEMPLATE_TEMPLATE_PARM:
5959 /* Record template parameters such as `T' inside `TT<T>'. */
5960 if (for_each_template_parm (TYPE_TI_ARGS (t), fn, data, pfd->visited))
5961 return error_mark_node;
5964 case TEMPLATE_TEMPLATE_PARM:
5965 case TEMPLATE_TYPE_PARM:
5966 case TEMPLATE_PARM_INDEX:
5967 if (fn && (*fn)(t, data))
5968 return error_mark_node;
5970 return error_mark_node;
5974 /* A template template parameter is encountered. */
5975 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)
5976 && for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
5977 return error_mark_node;
5979 /* Already substituted template template parameter */
5985 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t), fn,
5986 data, pfd->visited))
5987 return error_mark_node;
5991 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))
5992 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
5993 (TREE_TYPE (t)), fn, data,
5995 return error_mark_node;
6000 /* If there's no type, then this thing must be some expression
6001 involving template parameters. */
6002 if (!fn && !TREE_TYPE (t))
6003 return error_mark_node;
6008 case REINTERPRET_CAST_EXPR:
6009 case CONST_CAST_EXPR:
6010 case STATIC_CAST_EXPR:
6011 case DYNAMIC_CAST_EXPR:
6015 case PSEUDO_DTOR_EXPR:
6017 return error_mark_node;
6024 /* We didn't find any template parameters we liked. */
6028 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
6029 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
6030 call FN with the parameter and the DATA.
6031 If FN returns nonzero, the iteration is terminated, and
6032 for_each_template_parm returns 1. Otherwise, the iteration
6033 continues. If FN never returns a nonzero value, the value
6034 returned by for_each_template_parm is 0. If FN is NULL, it is
6035 considered to be the function which always returns 1. */
6038 for_each_template_parm (tree t, tree_fn_t fn, void* data,
6039 struct pointer_set_t *visited)
6041 struct pair_fn_data pfd;
6048 /* Walk the tree. (Conceptually, we would like to walk without
6049 duplicates, but for_each_template_parm_r recursively calls
6050 for_each_template_parm, so we would need to reorganize a fair
6051 bit to use walk_tree_without_duplicates, so we keep our own
6054 pfd.visited = visited;
6056 pfd.visited = pointer_set_create ();
6057 result = cp_walk_tree (&t,
6058 for_each_template_parm_r,
6060 pfd.visited) != NULL_TREE;
6065 pointer_set_destroy (pfd.visited);
6072 /* Returns true if T depends on any template parameter. */
6075 uses_template_parms (tree t)
6078 int saved_processing_template_decl;
6080 saved_processing_template_decl = processing_template_decl;
6081 if (!saved_processing_template_decl)
6082 processing_template_decl = 1;
6084 dependent_p = dependent_type_p (t);
6085 else if (TREE_CODE (t) == TREE_VEC)
6086 dependent_p = any_dependent_template_arguments_p (t);
6087 else if (TREE_CODE (t) == TREE_LIST)
6088 dependent_p = (uses_template_parms (TREE_VALUE (t))
6089 || uses_template_parms (TREE_CHAIN (t)));
6090 else if (TREE_CODE (t) == TYPE_DECL)
6091 dependent_p = dependent_type_p (TREE_TYPE (t));
6094 || TREE_CODE (t) == TEMPLATE_PARM_INDEX
6095 || TREE_CODE (t) == OVERLOAD
6096 || TREE_CODE (t) == BASELINK
6097 || TREE_CODE (t) == IDENTIFIER_NODE
6098 || TREE_CODE (t) == TRAIT_EXPR
6099 || CONSTANT_CLASS_P (t))
6100 dependent_p = (type_dependent_expression_p (t)
6101 || value_dependent_expression_p (t));
6104 gcc_assert (t == error_mark_node);
6105 dependent_p = false;
6108 processing_template_decl = saved_processing_template_decl;
6113 /* Returns true if T depends on any template parameter with level LEVEL. */
6116 uses_template_parms_level (tree t, int level)
6118 return for_each_template_parm (t, template_parm_this_level_p, &level, NULL);
6121 static int tinst_depth;
6122 extern int max_tinst_depth;
6123 #ifdef GATHER_STATISTICS
6126 static int tinst_level_tick;
6127 static int last_template_error_tick;
6129 /* We're starting to instantiate D; record the template instantiation context
6130 for diagnostics and to restore it later. */
6133 push_tinst_level (tree d)
6135 struct tinst_level *new;
6137 if (tinst_depth >= max_tinst_depth)
6139 /* If the instantiation in question still has unbound template parms,
6140 we don't really care if we can't instantiate it, so just return.
6141 This happens with base instantiation for implicit `typename'. */
6142 if (uses_template_parms (d))
6145 last_template_error_tick = tinst_level_tick;
6146 error ("template instantiation depth exceeds maximum of %d (use "
6147 "-ftemplate-depth-NN to increase the maximum) instantiating %qD",
6148 max_tinst_depth, d);
6150 print_instantiation_context ();
6155 new = GGC_NEW (struct tinst_level);
6157 new->locus = input_location;
6158 new->in_system_header_p = in_system_header;
6159 new->next = current_tinst_level;
6160 current_tinst_level = new;
6163 #ifdef GATHER_STATISTICS
6164 if (tinst_depth > depth_reached)
6165 depth_reached = tinst_depth;
6172 /* We're done instantiating this template; return to the instantiation
6176 pop_tinst_level (void)
6178 /* Restore the filename and line number stashed away when we started
6179 this instantiation. */
6180 input_location = current_tinst_level->locus;
6181 in_system_header = current_tinst_level->in_system_header_p;
6182 current_tinst_level = current_tinst_level->next;
6187 /* We're instantiating a deferred template; restore the template
6188 instantiation context in which the instantiation was requested, which
6189 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
6192 reopen_tinst_level (struct tinst_level *level)
6194 struct tinst_level *t;
6197 for (t = level; t; t = t->next)
6200 current_tinst_level = level;
6205 /* Returns the TINST_LEVEL which gives the original instantiation
6208 struct tinst_level *
6209 outermost_tinst_level (void)
6211 struct tinst_level *level = current_tinst_level;
6214 level = level->next;
6218 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
6219 vector of template arguments, as for tsubst.
6221 Returns an appropriate tsubst'd friend declaration. */
6224 tsubst_friend_function (tree decl, tree args)
6228 if (TREE_CODE (decl) == FUNCTION_DECL
6229 && DECL_TEMPLATE_INSTANTIATION (decl)
6230 && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
6231 /* This was a friend declared with an explicit template
6232 argument list, e.g.:
6236 to indicate that f was a template instantiation, not a new
6237 function declaration. Now, we have to figure out what
6238 instantiation of what template. */
6240 tree template_id, arglist, fns;
6243 tree ns = decl_namespace_context (TYPE_MAIN_DECL (current_class_type));
6245 /* Friend functions are looked up in the containing namespace scope.
6246 We must enter that scope, to avoid finding member functions of the
6247 current cless with same name. */
6248 push_nested_namespace (ns);
6249 fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args,
6250 tf_warning_or_error, NULL_TREE,
6251 /*integral_constant_expression_p=*/false);
6252 pop_nested_namespace (ns);
6253 arglist = tsubst (DECL_TI_ARGS (decl), args,
6254 tf_warning_or_error, NULL_TREE);
6255 template_id = lookup_template_function (fns, arglist);
6257 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
6258 tmpl = determine_specialization (template_id, new_friend,
6260 /*need_member_template=*/0,
6261 TREE_VEC_LENGTH (args),
6263 return instantiate_template (tmpl, new_args, tf_error);
6266 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
6268 /* The NEW_FRIEND will look like an instantiation, to the
6269 compiler, but is not an instantiation from the point of view of
6270 the language. For example, we might have had:
6272 template <class T> struct S {
6273 template <class U> friend void f(T, U);
6276 Then, in S<int>, template <class U> void f(int, U) is not an
6277 instantiation of anything. */
6278 if (new_friend == error_mark_node)
6279 return error_mark_node;
6281 DECL_USE_TEMPLATE (new_friend) = 0;
6282 if (TREE_CODE (decl) == TEMPLATE_DECL)
6284 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0;
6285 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend))
6286 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
6289 /* The mangled name for the NEW_FRIEND is incorrect. The function
6290 is not a template instantiation and should not be mangled like
6291 one. Therefore, we forget the mangling here; we'll recompute it
6292 later if we need it. */
6293 if (TREE_CODE (new_friend) != TEMPLATE_DECL)
6295 SET_DECL_RTL (new_friend, NULL_RTX);
6296 SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE);
6299 if (DECL_NAMESPACE_SCOPE_P (new_friend))
6302 tree new_friend_template_info;
6303 tree new_friend_result_template_info;
6305 int new_friend_is_defn;
6307 /* We must save some information from NEW_FRIEND before calling
6308 duplicate decls since that function will free NEW_FRIEND if
6310 new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
6311 new_friend_is_defn =
6312 (DECL_INITIAL (DECL_TEMPLATE_RESULT
6313 (template_for_substitution (new_friend)))
6315 if (TREE_CODE (new_friend) == TEMPLATE_DECL)
6317 /* This declaration is a `primary' template. */
6318 DECL_PRIMARY_TEMPLATE (new_friend) = new_friend;
6320 new_friend_result_template_info
6321 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend));
6324 new_friend_result_template_info = NULL_TREE;
6326 /* Make the init_value nonzero so pushdecl knows this is a defn. */
6327 if (new_friend_is_defn)
6328 DECL_INITIAL (new_friend) = error_mark_node;
6330 /* Inside pushdecl_namespace_level, we will push into the
6331 current namespace. However, the friend function should go
6332 into the namespace of the template. */
6333 ns = decl_namespace_context (new_friend);
6334 push_nested_namespace (ns);
6335 old_decl = pushdecl_namespace_level (new_friend, /*is_friend=*/true);
6336 pop_nested_namespace (ns);
6338 if (old_decl == error_mark_node)
6339 return error_mark_node;
6341 if (old_decl != new_friend)
6343 /* This new friend declaration matched an existing
6344 declaration. For example, given:
6346 template <class T> void f(T);
6347 template <class U> class C {
6348 template <class T> friend void f(T) {}
6351 the friend declaration actually provides the definition
6352 of `f', once C has been instantiated for some type. So,
6353 old_decl will be the out-of-class template declaration,
6354 while new_friend is the in-class definition.
6356 But, if `f' was called before this point, the
6357 instantiation of `f' will have DECL_TI_ARGS corresponding
6358 to `T' but not to `U', references to which might appear
6359 in the definition of `f'. Previously, the most general
6360 template for an instantiation of `f' was the out-of-class
6361 version; now it is the in-class version. Therefore, we
6362 run through all specialization of `f', adding to their
6363 DECL_TI_ARGS appropriately. In particular, they need a
6364 new set of outer arguments, corresponding to the
6365 arguments for this class instantiation.
6367 The same situation can arise with something like this:
6370 template <class T> class C {
6374 when `C<int>' is instantiated. Now, `f(int)' is defined
6377 if (!new_friend_is_defn)
6378 /* On the other hand, if the in-class declaration does
6379 *not* provide a definition, then we don't want to alter
6380 existing definitions. We can just leave everything
6385 /* Overwrite whatever template info was there before, if
6386 any, with the new template information pertaining to
6388 DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
6390 if (TREE_CODE (old_decl) != TEMPLATE_DECL)
6391 reregister_specialization (new_friend,
6392 most_general_template (old_decl),
6397 tree new_friend_args;
6399 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl))
6400 = new_friend_result_template_info;
6402 new_friend_args = TI_ARGS (new_friend_template_info);
6403 for (t = DECL_TEMPLATE_SPECIALIZATIONS (old_decl);
6407 tree spec = TREE_VALUE (t);
6410 = add_outermost_template_args (new_friend_args,
6411 DECL_TI_ARGS (spec));
6414 /* Now, since specializations are always supposed to
6415 hang off of the most general template, we must move
6417 t = most_general_template (old_decl);
6420 DECL_TEMPLATE_SPECIALIZATIONS (t)
6421 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t),
6422 DECL_TEMPLATE_SPECIALIZATIONS (old_decl));
6423 DECL_TEMPLATE_SPECIALIZATIONS (old_decl) = NULL_TREE;
6428 /* The information from NEW_FRIEND has been merged into OLD_DECL
6429 by duplicate_decls. */
6430 new_friend = old_decl;
6435 tree context = DECL_CONTEXT (new_friend);
6439 template <class T> class C {
6440 template <class U> friend void C1<U>::f (); // case 1
6441 friend void C2<T>::f (); // case 2
6443 we only need to make sure CONTEXT is a complete type for
6444 case 2. To distinguish between the two cases, we note that
6445 CONTEXT of case 1 remains dependent type after tsubst while
6446 this isn't true for case 2. */
6447 ++processing_template_decl;
6448 dependent_p = dependent_type_p (context);
6449 --processing_template_decl;
6452 && !complete_type_or_else (context, NULL_TREE))
6453 return error_mark_node;
6455 if (COMPLETE_TYPE_P (context))
6457 /* Check to see that the declaration is really present, and,
6458 possibly obtain an improved declaration. */
6459 tree fn = check_classfn (context,
6460 new_friend, NULL_TREE);
6470 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
6471 template arguments, as for tsubst.
6473 Returns an appropriate tsubst'd friend type or error_mark_node on
6477 tsubst_friend_class (tree friend_tmpl, tree args)
6483 context = DECL_CONTEXT (friend_tmpl);
6487 if (TREE_CODE (context) == NAMESPACE_DECL)
6488 push_nested_namespace (context);
6490 push_nested_class (tsubst (context, args, tf_none, NULL_TREE));
6493 /* Look for a class template declaration. We look for hidden names
6494 because two friend declarations of the same template are the
6495 same. For example, in:
6498 template <typename> friend class F;
6500 template <typename> struct B {
6501 template <typename> friend class F;
6504 both F templates are the same. */
6505 tmpl = lookup_name_real (DECL_NAME (friend_tmpl), 0, 0,
6506 /*block_p=*/true, 0,
6507 LOOKUP_COMPLAIN | LOOKUP_HIDDEN);
6509 /* But, if we don't find one, it might be because we're in a
6510 situation like this:
6518 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
6519 for `S<int>', not the TEMPLATE_DECL. */
6520 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
6522 tmpl = lookup_name_prefer_type (DECL_NAME (friend_tmpl), 1);
6523 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
6526 if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
6528 /* The friend template has already been declared. Just
6529 check to see that the declarations match, and install any new
6530 default parameters. We must tsubst the default parameters,
6531 of course. We only need the innermost template parameters
6532 because that is all that redeclare_class_template will look
6534 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl))
6535 > TMPL_ARGS_DEPTH (args))
6538 location_t saved_input_location;
6539 parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
6540 args, tf_warning_or_error);
6542 saved_input_location = input_location;
6543 input_location = DECL_SOURCE_LOCATION (friend_tmpl);
6544 redeclare_class_template (TREE_TYPE (tmpl), parms);
6545 input_location = saved_input_location;
6549 friend_type = TREE_TYPE (tmpl);
6553 /* The friend template has not already been declared. In this
6554 case, the instantiation of the template class will cause the
6555 injection of this template into the global scope. */
6556 tmpl = tsubst (friend_tmpl, args, tf_warning_or_error, NULL_TREE);
6557 if (tmpl == error_mark_node)
6558 return error_mark_node;
6560 /* The new TMPL is not an instantiation of anything, so we
6561 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
6562 the new type because that is supposed to be the corresponding
6563 template decl, i.e., TMPL. */
6564 DECL_USE_TEMPLATE (tmpl) = 0;
6565 DECL_TEMPLATE_INFO (tmpl) = NULL_TREE;
6566 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0;
6567 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl))
6568 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)));
6570 /* Inject this template into the global scope. */
6571 friend_type = TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl, true));
6576 if (TREE_CODE (context) == NAMESPACE_DECL)
6577 pop_nested_namespace (context);
6579 pop_nested_class ();
6585 /* Returns zero if TYPE cannot be completed later due to circularity.
6586 Otherwise returns one. */
6589 can_complete_type_without_circularity (tree type)
6591 if (type == NULL_TREE || type == error_mark_node)
6593 else if (COMPLETE_TYPE_P (type))
6595 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
6596 return can_complete_type_without_circularity (TREE_TYPE (type));
6597 else if (CLASS_TYPE_P (type)
6598 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type)))
6604 /* Apply any attributes which had to be deferred until instantiation
6605 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
6606 ARGS, COMPLAIN, IN_DECL are as tsubst. */
6609 apply_late_template_attributes (tree *decl_p, tree attributes, int attr_flags,
6610 tree args, tsubst_flags_t complain, tree in_decl)
6612 tree last_dep = NULL_TREE;
6616 for (t = attributes; t; t = TREE_CHAIN (t))
6617 if (ATTR_IS_DEPENDENT (t))
6620 attributes = copy_list (attributes);
6624 if (DECL_P (*decl_p))
6626 if (TREE_TYPE (*decl_p) == error_mark_node)
6628 p = &DECL_ATTRIBUTES (*decl_p);
6631 p = &TYPE_ATTRIBUTES (*decl_p);
6635 tree late_attrs = NULL_TREE;
6636 tree *q = &late_attrs;
6638 for (*p = attributes; *p; )
6641 if (ATTR_IS_DEPENDENT (t))
6643 *p = TREE_CHAIN (t);
6644 TREE_CHAIN (t) = NULL_TREE;
6646 = tsubst_expr (TREE_VALUE (t), args, complain, in_decl,
6647 /*integral_constant_expression_p=*/false);
6649 q = &TREE_CHAIN (t);
6652 p = &TREE_CHAIN (t);
6655 cplus_decl_attributes (decl_p, late_attrs, attr_flags);
6660 instantiate_class_template (tree type)
6662 tree template, args, pattern, t, member;
6667 if (type == error_mark_node)
6668 return error_mark_node;
6670 if (TYPE_BEING_DEFINED (type)
6671 || COMPLETE_TYPE_P (type)
6672 || dependent_type_p (type))
6675 /* Figure out which template is being instantiated. */
6676 template = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
6677 gcc_assert (TREE_CODE (template) == TEMPLATE_DECL);
6679 /* Determine what specialization of the original template to
6681 t = most_specialized_class (type, template);
6682 if (t == error_mark_node)
6684 TYPE_BEING_DEFINED (type) = 1;
6685 return error_mark_node;
6689 /* This TYPE is actually an instantiation of a partial
6690 specialization. We replace the innermost set of ARGS with
6691 the arguments appropriate for substitution. For example,
6694 template <class T> struct S {};
6695 template <class T> struct S<T*> {};
6697 and supposing that we are instantiating S<int*>, ARGS will
6698 presently be {int*} -- but we need {int}. */
6699 pattern = TREE_TYPE (t);
6700 args = TREE_PURPOSE (t);
6704 pattern = TREE_TYPE (template);
6705 args = CLASSTYPE_TI_ARGS (type);
6708 /* If the template we're instantiating is incomplete, then clearly
6709 there's nothing we can do. */
6710 if (!COMPLETE_TYPE_P (pattern))
6713 /* If we've recursively instantiated too many templates, stop. */
6714 if (! push_tinst_level (type))
6717 /* Now we're really doing the instantiation. Mark the type as in
6718 the process of being defined. */
6719 TYPE_BEING_DEFINED (type) = 1;
6721 /* We may be in the middle of deferred access check. Disable
6723 push_deferring_access_checks (dk_no_deferred);
6725 push_to_top_level ();
6727 SET_CLASSTYPE_INTERFACE_UNKNOWN (type);
6729 /* Set the input location to the template definition. This is needed
6730 if tsubsting causes an error. */
6731 typedecl = TYPE_MAIN_DECL (type);
6732 input_location = DECL_SOURCE_LOCATION (typedecl);
6733 in_system_header = DECL_IN_SYSTEM_HEADER (typedecl);
6735 TYPE_HAS_CONSTRUCTOR (type) = TYPE_HAS_CONSTRUCTOR (pattern);
6736 TYPE_HAS_NEW_OPERATOR (type) = TYPE_HAS_NEW_OPERATOR (pattern);
6737 TYPE_HAS_ARRAY_NEW_OPERATOR (type) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern);
6738 TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern);
6739 TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern);
6740 TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern);
6741 TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern);
6742 TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern);
6743 TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern);
6744 TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern);
6745 TYPE_PACKED (type) = TYPE_PACKED (pattern);
6746 TYPE_ALIGN (type) = TYPE_ALIGN (pattern);
6747 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);
6748 TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */
6749 if (ANON_AGGR_TYPE_P (pattern))
6750 SET_ANON_AGGR_TYPE_P (type);
6751 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern))
6753 CLASSTYPE_VISIBILITY_SPECIFIED (type) = 1;
6754 CLASSTYPE_VISIBILITY (type) = CLASSTYPE_VISIBILITY (pattern);
6757 pbinfo = TYPE_BINFO (pattern);
6759 /* We should never instantiate a nested class before its enclosing
6760 class; we need to look up the nested class by name before we can
6761 instantiate it, and that lookup should instantiate the enclosing
6763 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))
6764 || COMPLETE_TYPE_P (TYPE_CONTEXT (type))
6765 || TYPE_BEING_DEFINED (TYPE_CONTEXT (type)));
6767 base_list = NULL_TREE;
6768 if (BINFO_N_BASE_BINFOS (pbinfo))
6771 tree context = TYPE_CONTEXT (type);
6775 /* We must enter the scope containing the type, as that is where
6776 the accessibility of types named in dependent bases are
6778 pushed_scope = push_scope (context ? context : global_namespace);
6780 /* Substitute into each of the bases to determine the actual
6782 for (i = 0; BINFO_BASE_ITERATE (pbinfo, i, pbase_binfo); i++)
6785 tree access = BINFO_BASE_ACCESS (pbinfo, i);
6786 tree expanded_bases = NULL_TREE;
6789 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo)))
6792 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo),
6793 args, tf_error, NULL_TREE);
6794 if (expanded_bases == error_mark_node)
6797 len = TREE_VEC_LENGTH (expanded_bases);
6800 for (idx = 0; idx < len; idx++)
6803 /* Extract the already-expanded base class. */
6804 base = TREE_VEC_ELT (expanded_bases, idx);
6806 /* Substitute to figure out the base class. */
6807 base = tsubst (BINFO_TYPE (pbase_binfo), args, tf_error,
6810 if (base == error_mark_node)
6813 base_list = tree_cons (access, base, base_list);
6814 if (BINFO_VIRTUAL_P (pbase_binfo))
6815 TREE_TYPE (base_list) = integer_type_node;
6819 /* The list is now in reverse order; correct that. */
6820 base_list = nreverse (base_list);
6823 pop_scope (pushed_scope);
6825 /* Now call xref_basetypes to set up all the base-class
6827 xref_basetypes (type, base_list);
6829 apply_late_template_attributes (&type, TYPE_ATTRIBUTES (pattern),
6830 (int) ATTR_FLAG_TYPE_IN_PLACE,
6831 args, tf_error, NULL_TREE);
6833 /* Now that our base classes are set up, enter the scope of the
6834 class, so that name lookups into base classes, etc. will work
6835 correctly. This is precisely analogous to what we do in
6836 begin_class_definition when defining an ordinary non-template
6837 class, except we also need to push the enclosing classes. */
6838 push_nested_class (type);
6840 /* Now members are processed in the order of declaration. */
6841 for (member = CLASSTYPE_DECL_LIST (pattern);
6842 member; member = TREE_CHAIN (member))
6844 tree t = TREE_VALUE (member);
6846 if (TREE_PURPOSE (member))
6850 /* Build new CLASSTYPE_NESTED_UTDS. */
6853 bool class_template_p;
6855 class_template_p = (TREE_CODE (t) != ENUMERAL_TYPE
6856 && TYPE_LANG_SPECIFIC (t)
6857 && CLASSTYPE_IS_TEMPLATE (t));
6858 /* If the member is a class template, then -- even after
6859 substitution -- there may be dependent types in the
6860 template argument list for the class. We increment
6861 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
6862 that function will assume that no types are dependent
6863 when outside of a template. */
6864 if (class_template_p)
6865 ++processing_template_decl;
6866 newtag = tsubst (t, args, tf_error, NULL_TREE);
6867 if (class_template_p)
6868 --processing_template_decl;
6869 if (newtag == error_mark_node)
6872 if (TREE_CODE (newtag) != ENUMERAL_TYPE)
6874 tree name = TYPE_IDENTIFIER (t);
6876 if (class_template_p)
6877 /* Unfortunately, lookup_template_class sets
6878 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
6879 instantiation (i.e., for the type of a member
6880 template class nested within a template class.)
6881 This behavior is required for
6882 maybe_process_partial_specialization to work
6883 correctly, but is not accurate in this case;
6884 the TAG is not an instantiation of anything.
6885 (The corresponding TEMPLATE_DECL is an
6886 instantiation, but the TYPE is not.) */
6887 CLASSTYPE_USE_TEMPLATE (newtag) = 0;
6889 /* Now, we call pushtag to put this NEWTAG into the scope of
6890 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
6891 pushtag calling push_template_decl. We don't have to do
6892 this for enums because it will already have been done in
6895 SET_IDENTIFIER_TYPE_VALUE (name, newtag);
6896 pushtag (name, newtag, /*tag_scope=*/ts_current);
6899 else if (TREE_CODE (t) == FUNCTION_DECL
6900 || DECL_FUNCTION_TEMPLATE_P (t))
6902 /* Build new TYPE_METHODS. */
6905 if (TREE_CODE (t) == TEMPLATE_DECL)
6906 ++processing_template_decl;
6907 r = tsubst (t, args, tf_error, NULL_TREE);
6908 if (TREE_CODE (t) == TEMPLATE_DECL)
6909 --processing_template_decl;
6910 set_current_access_from_decl (r);
6911 finish_member_declaration (r);
6915 /* Build new TYPE_FIELDS. */
6916 if (TREE_CODE (t) == STATIC_ASSERT)
6919 tsubst_expr (STATIC_ASSERT_CONDITION (t), args,
6920 tf_warning_or_error, NULL_TREE,
6921 /*integral_constant_expression_p=*/true);
6922 finish_static_assert (condition,
6923 STATIC_ASSERT_MESSAGE (t),
6924 STATIC_ASSERT_SOURCE_LOCATION (t),
6927 else if (TREE_CODE (t) != CONST_DECL)
6931 /* The the file and line for this declaration, to
6932 assist in error message reporting. Since we
6933 called push_tinst_level above, we don't need to
6935 input_location = DECL_SOURCE_LOCATION (t);
6937 if (TREE_CODE (t) == TEMPLATE_DECL)
6938 ++processing_template_decl;
6939 r = tsubst (t, args, tf_warning_or_error, NULL_TREE);
6940 if (TREE_CODE (t) == TEMPLATE_DECL)
6941 --processing_template_decl;
6942 if (TREE_CODE (r) == VAR_DECL)
6946 [t]he initialization (and any associated
6947 side-effects) of a static data member does
6948 not occur unless the static data member is
6949 itself used in a way that requires the
6950 definition of the static data member to
6953 Therefore, we do not substitute into the
6954 initialized for the static data member here. */
6955 finish_static_data_member_decl
6958 /*init_const_expr_p=*/false,
6959 /*asmspec_tree=*/NULL_TREE,
6961 if (DECL_INITIALIZED_IN_CLASS_P (r))
6962 check_static_variable_definition (r, TREE_TYPE (r));
6964 else if (TREE_CODE (r) == FIELD_DECL)
6966 /* Determine whether R has a valid type and can be
6967 completed later. If R is invalid, then it is
6968 replaced by error_mark_node so that it will not be
6969 added to TYPE_FIELDS. */
6970 tree rtype = TREE_TYPE (r);
6971 if (can_complete_type_without_circularity (rtype))
6972 complete_type (rtype);
6974 if (!COMPLETE_TYPE_P (rtype))
6976 cxx_incomplete_type_error (r, rtype);
6977 r = error_mark_node;
6981 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
6982 such a thing will already have been added to the field
6983 list by tsubst_enum in finish_member_declaration in the
6984 CLASSTYPE_NESTED_UTDS case above. */
6985 if (!(TREE_CODE (r) == TYPE_DECL
6986 && TREE_CODE (TREE_TYPE (r)) == ENUMERAL_TYPE
6987 && DECL_ARTIFICIAL (r)))
6989 set_current_access_from_decl (r);
6990 finish_member_declaration (r);
6997 if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t))
6999 /* Build new CLASSTYPE_FRIEND_CLASSES. */
7001 tree friend_type = t;
7002 bool adjust_processing_template_decl = false;
7004 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
7006 /* template <class T> friend class C; */
7007 friend_type = tsubst_friend_class (friend_type, args);
7008 adjust_processing_template_decl = true;
7010 else if (TREE_CODE (friend_type) == UNBOUND_CLASS_TEMPLATE)
7012 /* template <class T> friend class C::D; */
7013 friend_type = tsubst (friend_type, args,
7014 tf_warning_or_error, NULL_TREE);
7015 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
7016 friend_type = TREE_TYPE (friend_type);
7017 adjust_processing_template_decl = true;
7019 else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
7021 /* This could be either
7025 when dependent_type_p is false or
7027 template <class U> friend class T::C;
7030 friend_type = tsubst (friend_type, args,
7031 tf_warning_or_error, NULL_TREE);
7032 /* Bump processing_template_decl for correct
7033 dependent_type_p calculation. */
7034 ++processing_template_decl;
7035 if (dependent_type_p (friend_type))
7036 adjust_processing_template_decl = true;
7037 --processing_template_decl;
7039 else if (!CLASSTYPE_USE_TEMPLATE (friend_type)
7040 && hidden_name_p (TYPE_NAME (friend_type)))
7044 where C hasn't been declared yet. Let's lookup name
7045 from namespace scope directly, bypassing any name that
7046 come from dependent base class. */
7047 tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type));
7049 /* The call to xref_tag_from_type does injection for friend
7051 push_nested_namespace (ns);
7053 xref_tag_from_type (friend_type, NULL_TREE,
7054 /*tag_scope=*/ts_current);
7055 pop_nested_namespace (ns);
7057 else if (uses_template_parms (friend_type))
7058 /* friend class C<T>; */
7059 friend_type = tsubst (friend_type, args,
7060 tf_warning_or_error, NULL_TREE);
7065 where C is already declared or
7067 friend class C<int>;
7069 We don't have to do anything in these cases. */
7071 if (adjust_processing_template_decl)
7072 /* Trick make_friend_class into realizing that the friend
7073 we're adding is a template, not an ordinary class. It's
7074 important that we use make_friend_class since it will
7075 perform some error-checking and output cross-reference
7077 ++processing_template_decl;
7079 if (friend_type != error_mark_node)
7080 make_friend_class (type, friend_type, /*complain=*/false);
7082 if (adjust_processing_template_decl)
7083 --processing_template_decl;
7087 /* Build new DECL_FRIENDLIST. */
7090 /* The the file and line for this declaration, to
7091 assist in error message reporting. Since we
7092 called push_tinst_level above, we don't need to
7094 input_location = DECL_SOURCE_LOCATION (t);
7096 if (TREE_CODE (t) == TEMPLATE_DECL)
7098 ++processing_template_decl;
7099 push_deferring_access_checks (dk_no_check);
7102 r = tsubst_friend_function (t, args);
7103 add_friend (type, r, /*complain=*/false);
7104 if (TREE_CODE (t) == TEMPLATE_DECL)
7106 pop_deferring_access_checks ();
7107 --processing_template_decl;
7113 /* Set the file and line number information to whatever is given for
7114 the class itself. This puts error messages involving generated
7115 implicit functions at a predictable point, and the same point
7116 that would be used for non-template classes. */
7117 input_location = DECL_SOURCE_LOCATION (typedecl);
7119 unreverse_member_declarations (type);
7120 finish_struct_1 (type);
7121 TYPE_BEING_DEFINED (type) = 0;
7123 /* Now that the class is complete, instantiate default arguments for
7124 any member functions. We don't do this earlier because the
7125 default arguments may reference members of the class. */
7126 if (!PRIMARY_TEMPLATE_P (template))
7127 for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t))
7128 if (TREE_CODE (t) == FUNCTION_DECL
7129 /* Implicitly generated member functions will not have template
7130 information; they are not instantiations, but instead are
7131 created "fresh" for each instantiation. */
7132 && DECL_TEMPLATE_INFO (t))
7133 tsubst_default_arguments (t);
7135 pop_nested_class ();
7136 pop_from_top_level ();
7137 pop_deferring_access_checks ();
7140 /* The vtable for a template class can be emitted in any translation
7141 unit in which the class is instantiated. When there is no key
7142 method, however, finish_struct_1 will already have added TYPE to
7143 the keyed_classes list. */
7144 if (TYPE_CONTAINS_VPTR_P (type) && CLASSTYPE_KEY_METHOD (type))
7145 keyed_classes = tree_cons (NULL_TREE, type, keyed_classes);
7151 tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl)
7157 else if (TYPE_P (t))
7158 r = tsubst (t, args, complain, in_decl);
7161 r = tsubst_expr (t, args, complain, in_decl,
7162 /*integral_constant_expression_p=*/true);
7163 r = fold_non_dependent_expr (r);
7168 /* Substitute ARGS into T, which is an pack expansion
7169 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
7170 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
7171 (if only a partial substitution could be performed) or
7172 ERROR_MARK_NODE if there was an error. */
7174 tsubst_pack_expansion (tree t, tree args, tsubst_flags_t complain,
7178 tree pack, packs = NULL_TREE, unsubstituted_packs = NULL_TREE;
7179 tree first_arg_pack; int i, len = -1;
7183 gcc_assert (PACK_EXPANSION_P (t));
7184 pattern = PACK_EXPANSION_PATTERN (t);
7186 /* Determine the argument packs that will instantiate the parameter
7187 packs used in the expansion expression. While we're at it,
7188 compute the number of arguments to be expanded and make sure it
7190 for (pack = PACK_EXPANSION_PARAMETER_PACKS (t); pack;
7191 pack = TREE_CHAIN (pack))
7193 tree parm_pack = TREE_VALUE (pack);
7194 tree arg_pack = NULL_TREE;
7195 tree orig_arg = NULL_TREE;
7197 if (TREE_CODE (parm_pack) == PARM_DECL)
7199 if (local_specializations)
7200 arg_pack = retrieve_local_specialization (parm_pack);
7204 int level, idx, levels;
7205 template_parm_level_and_index (parm_pack, &level, &idx);
7207 levels = TMPL_ARGS_DEPTH (args);
7208 if (level <= levels)
7209 arg_pack = TMPL_ARG (args, level, idx);
7212 orig_arg = arg_pack;
7213 if (arg_pack && TREE_CODE (arg_pack) == ARGUMENT_PACK_SELECT)
7214 arg_pack = ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack);
7216 if (arg_pack && !ARGUMENT_PACK_P (arg_pack))
7217 /* This can only happen if we forget to expand an argument
7218 pack somewhere else. Just return an error, silently. */
7220 result = make_tree_vec (1);
7221 TREE_VEC_ELT (result, 0) = error_mark_node;
7226 && TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack)) == 1
7227 && PACK_EXPANSION_P (TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg_pack), 0)))
7229 tree expansion = TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg_pack), 0);
7230 tree pattern = PACK_EXPANSION_PATTERN (expansion);
7231 if ((TYPE_P (pattern) && same_type_p (pattern, parm_pack))
7232 || (!TYPE_P (pattern) && cp_tree_equal (parm_pack, pattern)))
7233 /* The argument pack that the parameter maps to is just an
7234 expansion of the parameter itself, such as one would
7235 find in the implicit typedef of a class inside the
7236 class itself. Consider this parameter "unsubstituted",
7237 so that we will maintain the outer pack expansion. */
7238 arg_pack = NULL_TREE;
7244 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack));
7246 /* It's all-or-nothing with incomplete argument packs. */
7247 if (incomplete && !ARGUMENT_PACK_INCOMPLETE_P (arg_pack))
7248 return error_mark_node;
7250 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack))
7256 first_arg_pack = arg_pack;
7258 else if (len != my_len)
7260 if (TREE_CODE (t) == TYPE_PACK_EXPANSION)
7261 error ("mismatched argument pack lengths while expanding "
7265 error ("mismatched argument pack lengths while expanding "
7268 return error_mark_node;
7271 /* Keep track of the parameter packs and their corresponding
7273 packs = tree_cons (parm_pack, arg_pack, packs);
7274 TREE_TYPE (packs) = orig_arg;
7277 /* We can't substitute for this parameter pack. */
7278 unsubstituted_packs = tree_cons (TREE_PURPOSE (pack),
7280 unsubstituted_packs);
7283 /* We cannot expand this expansion expression, because we don't have
7284 all of the argument packs we need. Substitute into the pattern
7285 and return a PACK_EXPANSION_*. The caller will need to deal with
7287 if (unsubstituted_packs)
7288 return make_pack_expansion (tsubst (pattern, args, complain,
7291 /* We could not find any argument packs that work. */
7293 return error_mark_node;
7295 /* For each argument in each argument pack, substitute into the
7297 result = make_tree_vec (len + incomplete);
7298 for (i = 0; i < len + incomplete; ++i)
7300 /* For parameter pack, change the substitution of the parameter
7301 pack to the ith argument in its argument pack, then expand
7303 for (pack = packs; pack; pack = TREE_CHAIN (pack))
7305 tree parm = TREE_PURPOSE (pack);
7307 if (TREE_CODE (parm) == PARM_DECL)
7309 /* Select the Ith argument from the pack. */
7310 tree arg = make_node (ARGUMENT_PACK_SELECT);
7311 ARGUMENT_PACK_SELECT_FROM_PACK (arg) = TREE_VALUE (pack);
7312 ARGUMENT_PACK_SELECT_INDEX (arg) = i;
7314 register_local_specialization (arg, parm);
7320 template_parm_level_and_index (parm, &level, &idx);
7324 /* Select the Ith argument from the pack. */
7325 value = make_node (ARGUMENT_PACK_SELECT);
7326 ARGUMENT_PACK_SELECT_FROM_PACK (value) = TREE_VALUE (pack);
7327 ARGUMENT_PACK_SELECT_INDEX (value) = i;
7330 /* Update the corresponding argument. */
7331 TMPL_ARG (args, level, idx) = value;
7335 /* Substitute into the PATTERN with the altered arguments. */
7336 if (TREE_CODE (t) == EXPR_PACK_EXPANSION)
7337 TREE_VEC_ELT (result, i) =
7338 tsubst_expr (pattern, args, complain, in_decl,
7339 /*integral_constant_expression_p=*/false);
7341 TREE_VEC_ELT (result, i) = tsubst (pattern, args, complain, in_decl);
7344 /* When we have incomplete argument packs, the last "expanded"
7345 result is itself a pack expansion, which allows us
7346 to deduce more arguments. */
7347 TREE_VEC_ELT (result, i) =
7348 make_pack_expansion (TREE_VEC_ELT (result, i));
7350 if (TREE_VEC_ELT (result, i) == error_mark_node)
7352 result = error_mark_node;
7357 /* Update ARGS to restore the substitution from parameter packs to
7358 their argument packs. */
7359 for (pack = packs; pack; pack = TREE_CHAIN (pack))
7361 tree parm = TREE_PURPOSE (pack);
7363 if (TREE_CODE (parm) == PARM_DECL)
7364 register_local_specialization (TREE_TYPE (pack), parm);
7368 template_parm_level_and_index (parm, &level, &idx);
7370 /* Update the corresponding argument. */
7371 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
7372 TREE_VEC_ELT (TREE_VEC_ELT (args, level -1 ), idx) =
7375 TREE_VEC_ELT (args, idx) = TREE_TYPE (pack);
7382 /* Substitute ARGS into the vector or list of template arguments T. */
7385 tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl)
7388 int len = TREE_VEC_LENGTH (t);
7389 int need_new = 0, i, expanded_len_adjust = 0, out;
7390 tree *elts = (tree *) alloca (len * sizeof (tree));
7392 for (i = 0; i < len; i++)
7394 tree orig_arg = TREE_VEC_ELT (t, i);
7397 if (TREE_CODE (orig_arg) == TREE_VEC)
7398 new_arg = tsubst_template_args (orig_arg, args, complain, in_decl);
7399 else if (PACK_EXPANSION_P (orig_arg))
7401 /* Substitute into an expansion expression. */
7402 new_arg = tsubst_pack_expansion (orig_arg, args, complain, in_decl);
7404 if (TREE_CODE (new_arg) == TREE_VEC)
7405 /* Add to the expanded length adjustment the number of
7406 expanded arguments. We subtract one from this
7407 measurement, because the argument pack expression
7408 itself is already counted as 1 in
7409 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
7410 the argument pack is empty. */
7411 expanded_len_adjust += TREE_VEC_LENGTH (new_arg) - 1;
7413 else if (ARGUMENT_PACK_P (orig_arg))
7415 /* Substitute into each of the arguments. */
7416 new_arg = make_node (TREE_CODE (orig_arg));
7418 SET_ARGUMENT_PACK_ARGS (
7420 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg),
7421 args, complain, in_decl));
7423 if (ARGUMENT_PACK_ARGS (new_arg) == error_mark_node)
7424 new_arg = error_mark_node;
7426 if (TREE_CODE (new_arg) == NONTYPE_ARGUMENT_PACK) {
7427 TREE_TYPE (new_arg) = tsubst (TREE_TYPE (orig_arg), args,
7429 TREE_CONSTANT (new_arg) = TREE_CONSTANT (orig_arg);
7431 if (TREE_TYPE (new_arg) == error_mark_node)
7432 new_arg = error_mark_node;
7436 new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl);
7438 if (new_arg == error_mark_node)
7439 return error_mark_node;
7442 if (new_arg != orig_arg)
7449 /* Make space for the expanded arguments coming from template
7451 t = make_tree_vec (len + expanded_len_adjust);
7452 for (i = 0, out = 0; i < len; i++)
7454 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t, i))
7455 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t, i)))
7456 && TREE_CODE (elts[i]) == TREE_VEC)
7460 /* Now expand the template argument pack "in place". */
7461 for (idx = 0; idx < TREE_VEC_LENGTH (elts[i]); idx++, out++)
7462 TREE_VEC_ELT (t, out) = TREE_VEC_ELT (elts[i], idx);
7466 TREE_VEC_ELT (t, out) = elts[i];
7474 /* Return the result of substituting ARGS into the template parameters
7475 given by PARMS. If there are m levels of ARGS and m + n levels of
7476 PARMS, then the result will contain n levels of PARMS. For
7477 example, if PARMS is `template <class T> template <class U>
7478 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
7479 result will be `template <int*, double, class V>'. */
7482 tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain)
7487 /* When substituting into a template, we must set
7488 PROCESSING_TEMPLATE_DECL as the template parameters may be
7489 dependent if they are based on one-another, and the dependency
7490 predicates are short-circuit outside of templates. */
7491 ++processing_template_decl;
7493 for (new_parms = &r;
7494 TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args);
7495 new_parms = &(TREE_CHAIN (*new_parms)),
7496 parms = TREE_CHAIN (parms))
7499 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms)));
7502 for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i)
7508 if (parms == error_mark_node)
7511 tuple = TREE_VEC_ELT (TREE_VALUE (parms), i);
7513 if (tuple == error_mark_node)
7516 default_value = TREE_PURPOSE (tuple);
7517 parm_decl = TREE_VALUE (tuple);
7519 parm_decl = tsubst (parm_decl, args, complain, NULL_TREE);
7520 if (TREE_CODE (parm_decl) == PARM_DECL
7521 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl), complain))
7522 parm_decl = error_mark_node;
7523 default_value = tsubst_template_arg (default_value, args,
7524 complain, NULL_TREE);
7526 tuple = build_tree_list (default_value, parm_decl);
7527 TREE_VEC_ELT (new_vec, i) = tuple;
7531 tree_cons (size_int (TMPL_PARMS_DEPTH (parms)
7532 - TMPL_ARGS_DEPTH (args)),
7533 new_vec, NULL_TREE);
7536 --processing_template_decl;
7541 /* Substitute the ARGS into the indicated aggregate (or enumeration)
7542 type T. If T is not an aggregate or enumeration type, it is
7543 handled as if by tsubst. IN_DECL is as for tsubst. If
7544 ENTERING_SCOPE is nonzero, T is the context for a template which
7545 we are presently tsubst'ing. Return the substituted value. */
7548 tsubst_aggr_type (tree t,
7550 tsubst_flags_t complain,
7557 switch (TREE_CODE (t))
7560 if (TYPE_PTRMEMFUNC_P (t))
7561 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl);
7563 /* Else fall through. */
7566 if (TYPE_TEMPLATE_INFO (t))
7571 bool saved_skip_evaluation;
7573 /* In "sizeof(X<I>)" we need to evaluate "I". */
7574 saved_skip_evaluation = skip_evaluation;
7575 skip_evaluation = false;
7577 /* First, determine the context for the type we are looking
7579 context = TYPE_CONTEXT (t);
7581 context = tsubst_aggr_type (context, args, complain,
7582 in_decl, /*entering_scope=*/1);
7584 /* Then, figure out what arguments are appropriate for the
7585 type we are trying to find. For example, given:
7587 template <class T> struct S;
7588 template <class T, class U> void f(T, U) { S<U> su; }
7590 and supposing that we are instantiating f<int, double>,
7591 then our ARGS will be {int, double}, but, when looking up
7592 S we only want {double}. */
7593 argvec = tsubst_template_args (TYPE_TI_ARGS (t), args,
7595 if (argvec == error_mark_node)
7596 r = error_mark_node;
7599 r = lookup_template_class (t, argvec, in_decl, context,
7600 entering_scope, complain);
7601 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
7604 skip_evaluation = saved_skip_evaluation;
7609 /* This is not a template type, so there's nothing to do. */
7613 return tsubst (t, args, complain, in_decl);
7617 /* Substitute into the default argument ARG (a default argument for
7618 FN), which has the indicated TYPE. */
7621 tsubst_default_argument (tree fn, tree type, tree arg)
7623 tree saved_class_ptr = NULL_TREE;
7624 tree saved_class_ref = NULL_TREE;
7626 /* This default argument came from a template. Instantiate the
7627 default argument here, not in tsubst. In the case of
7636 we must be careful to do name lookup in the scope of S<T>,
7637 rather than in the current class. */
7638 push_access_scope (fn);
7639 /* The "this" pointer is not valid in a default argument. */
7642 saved_class_ptr = current_class_ptr;
7643 cp_function_chain->x_current_class_ptr = NULL_TREE;
7644 saved_class_ref = current_class_ref;
7645 cp_function_chain->x_current_class_ref = NULL_TREE;
7648 push_deferring_access_checks(dk_no_deferred);
7649 /* The default argument expression may cause implicitly defined
7650 member functions to be synthesized, which will result in garbage
7651 collection. We must treat this situation as if we were within
7652 the body of function so as to avoid collecting live data on the
7655 arg = tsubst_expr (arg, DECL_TI_ARGS (fn),
7656 tf_warning_or_error, NULL_TREE,
7657 /*integral_constant_expression_p=*/false);
7659 pop_deferring_access_checks();
7661 /* Restore the "this" pointer. */
7664 cp_function_chain->x_current_class_ptr = saved_class_ptr;
7665 cp_function_chain->x_current_class_ref = saved_class_ref;
7668 pop_access_scope (fn);
7670 /* Make sure the default argument is reasonable. */
7671 arg = check_default_argument (type, arg);
7676 /* Substitute into all the default arguments for FN. */
7679 tsubst_default_arguments (tree fn)
7684 tmpl_args = DECL_TI_ARGS (fn);
7686 /* If this function is not yet instantiated, we certainly don't need
7687 its default arguments. */
7688 if (uses_template_parms (tmpl_args))
7691 for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
7693 arg = TREE_CHAIN (arg))
7694 if (TREE_PURPOSE (arg))
7695 TREE_PURPOSE (arg) = tsubst_default_argument (fn,
7697 TREE_PURPOSE (arg));
7700 /* Substitute the ARGS into the T, which is a _DECL. Return the
7701 result of the substitution. Issue error and warning messages under
7702 control of COMPLAIN. */
7705 tsubst_decl (tree t, tree args, tsubst_flags_t complain)
7707 location_t saved_loc;
7711 /* Set the filename and linenumber to improve error-reporting. */
7712 saved_loc = input_location;
7713 input_location = DECL_SOURCE_LOCATION (t);
7715 switch (TREE_CODE (t))
7719 /* We can get here when processing a member function template,
7720 member class template, and template template parameter of
7721 a template class. */
7722 tree decl = DECL_TEMPLATE_RESULT (t);
7727 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
7729 /* Template template parameter is treated here. */
7730 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
7731 if (new_type == error_mark_node)
7732 return error_mark_node;
7735 TREE_CHAIN (r) = NULL_TREE;
7736 TREE_TYPE (r) = new_type;
7737 DECL_TEMPLATE_RESULT (r)
7738 = build_decl (TYPE_DECL, DECL_NAME (decl), new_type);
7739 DECL_TEMPLATE_PARMS (r)
7740 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
7742 TYPE_NAME (new_type) = r;
7746 /* We might already have an instance of this template.
7747 The ARGS are for the surrounding class type, so the
7748 full args contain the tsubst'd args for the context,
7749 plus the innermost args from the template decl. */
7750 tmpl_args = DECL_CLASS_TEMPLATE_P (t)
7751 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t))
7752 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t));
7753 /* Because this is a template, the arguments will still be
7754 dependent, even after substitution. If
7755 PROCESSING_TEMPLATE_DECL is not set, the dependency
7756 predicates will short-circuit. */
7757 ++processing_template_decl;
7758 full_args = tsubst_template_args (tmpl_args, args,
7760 --processing_template_decl;
7761 if (full_args == error_mark_node)
7762 return error_mark_node;
7764 /* tsubst_template_args doesn't copy the vector if
7765 nothing changed. But, *something* should have
7767 gcc_assert (full_args != tmpl_args);
7769 spec = retrieve_specialization (t, full_args,
7770 /*class_specializations_p=*/true);
7771 if (spec != NULL_TREE)
7777 /* Make a new template decl. It will be similar to the
7778 original, but will record the current template arguments.
7779 We also create a new function declaration, which is just
7780 like the old one, but points to this new template, rather
7781 than the old one. */
7783 gcc_assert (DECL_LANG_SPECIFIC (r) != 0);
7784 TREE_CHAIN (r) = NULL_TREE;
7786 DECL_TEMPLATE_INFO (r) = build_tree_list (t, args);
7788 if (TREE_CODE (decl) == TYPE_DECL)
7791 ++processing_template_decl;
7792 new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
7793 --processing_template_decl;
7794 if (new_type == error_mark_node)
7795 return error_mark_node;
7797 TREE_TYPE (r) = new_type;
7798 CLASSTYPE_TI_TEMPLATE (new_type) = r;
7799 DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type);
7800 DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type);
7801 DECL_CONTEXT (r) = TYPE_CONTEXT (new_type);
7806 ++processing_template_decl;
7807 new_decl = tsubst (decl, args, complain, in_decl);
7808 --processing_template_decl;
7809 if (new_decl == error_mark_node)
7810 return error_mark_node;
7812 DECL_TEMPLATE_RESULT (r) = new_decl;
7813 DECL_TI_TEMPLATE (new_decl) = r;
7814 TREE_TYPE (r) = TREE_TYPE (new_decl);
7815 DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl);
7816 DECL_CONTEXT (r) = DECL_CONTEXT (new_decl);
7819 SET_DECL_IMPLICIT_INSTANTIATION (r);
7820 DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE;
7821 DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE;
7823 /* The template parameters for this new template are all the
7824 template parameters for the old template, except the
7825 outermost level of parameters. */
7826 DECL_TEMPLATE_PARMS (r)
7827 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
7830 if (PRIMARY_TEMPLATE_P (t))
7831 DECL_PRIMARY_TEMPLATE (r) = r;
7833 if (TREE_CODE (decl) != TYPE_DECL)
7834 /* Record this non-type partial instantiation. */
7835 register_specialization (r, t,
7836 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r)),
7844 tree argvec = NULL_TREE;
7852 /* Nobody should be tsubst'ing into non-template functions. */
7853 gcc_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE);
7855 if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL)
7860 /* If T is not dependent, just return it. We have to
7861 increment PROCESSING_TEMPLATE_DECL because
7862 value_dependent_expression_p assumes that nothing is
7863 dependent when PROCESSING_TEMPLATE_DECL is zero. */
7864 ++processing_template_decl;
7865 dependent_p = value_dependent_expression_p (t);
7866 --processing_template_decl;
7870 /* Calculate the most general template of which R is a
7871 specialization, and the complete set of arguments used to
7873 gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
7874 argvec = tsubst_template_args (DECL_TI_ARGS
7875 (DECL_TEMPLATE_RESULT (gen_tmpl)),
7876 args, complain, in_decl);
7878 /* Check to see if we already have this specialization. */
7879 spec = retrieve_specialization (gen_tmpl, argvec,
7880 /*class_specializations_p=*/false);
7888 /* We can see more levels of arguments than parameters if
7889 there was a specialization of a member template, like
7892 template <class T> struct S { template <class U> void f(); }
7893 template <> template <class U> void S<int>::f(U);
7895 Here, we'll be substituting into the specialization,
7896 because that's where we can find the code we actually
7897 want to generate, but we'll have enough arguments for
7898 the most general template.
7900 We also deal with the peculiar case:
7902 template <class T> struct S {
7903 template <class U> friend void f();
7905 template <class U> void f() {}
7907 template void f<double>();
7909 Here, the ARGS for the instantiation of will be {int,
7910 double}. But, we only need as many ARGS as there are
7911 levels of template parameters in CODE_PATTERN. We are
7912 careful not to get fooled into reducing the ARGS in
7915 template <class T> struct S { template <class U> void f(U); }
7916 template <class T> template <> void S<T>::f(int) {}
7918 which we can spot because the pattern will be a
7919 specialization in this case. */
7920 args_depth = TMPL_ARGS_DEPTH (args);
7922 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t)));
7923 if (args_depth > parms_depth
7924 && !DECL_TEMPLATE_SPECIALIZATION (t))
7925 args = get_innermost_template_args (args, parms_depth);
7929 /* This special case arises when we have something like this:
7931 template <class T> struct S {
7932 friend void f<int>(int, double);
7935 Here, the DECL_TI_TEMPLATE for the friend declaration
7936 will be an IDENTIFIER_NODE. We are being called from
7937 tsubst_friend_function, and we want only to create a
7938 new decl (R) with appropriate types so that we can call
7939 determine_specialization. */
7940 gen_tmpl = NULL_TREE;
7943 if (DECL_CLASS_SCOPE_P (t))
7945 if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t)))
7949 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
7950 complain, t, /*entering_scope=*/1);
7955 ctx = DECL_CONTEXT (t);
7957 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
7958 if (type == error_mark_node)
7959 return error_mark_node;
7961 /* We do NOT check for matching decls pushed separately at this
7962 point, as they may not represent instantiations of this
7963 template, and in any case are considered separate under the
7966 DECL_USE_TEMPLATE (r) = 0;
7967 TREE_TYPE (r) = type;
7968 /* Clear out the mangled name and RTL for the instantiation. */
7969 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
7970 SET_DECL_RTL (r, NULL_RTX);
7971 DECL_INITIAL (r) = NULL_TREE;
7972 DECL_CONTEXT (r) = ctx;
7974 if (member && DECL_CONV_FN_P (r))
7975 /* Type-conversion operator. Reconstruct the name, in
7976 case it's the name of one of the template's parameters. */
7977 DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type));
7979 DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args,
7981 DECL_RESULT (r) = NULL_TREE;
7983 TREE_STATIC (r) = 0;
7984 TREE_PUBLIC (r) = TREE_PUBLIC (t);
7985 DECL_EXTERNAL (r) = 1;
7986 /* If this is an instantiation of a function with internal
7987 linkage, we already know what object file linkage will be
7988 assigned to the instantiation. */
7989 DECL_INTERFACE_KNOWN (r) = !TREE_PUBLIC (r);
7990 DECL_DEFER_OUTPUT (r) = 0;
7991 TREE_CHAIN (r) = NULL_TREE;
7992 DECL_PENDING_INLINE_INFO (r) = 0;
7993 DECL_PENDING_INLINE_P (r) = 0;
7994 DECL_SAVED_TREE (r) = NULL_TREE;
7996 if (DECL_CLONED_FUNCTION (r))
7998 DECL_CLONED_FUNCTION (r) = tsubst (DECL_CLONED_FUNCTION (t),
8000 TREE_CHAIN (r) = TREE_CHAIN (DECL_CLONED_FUNCTION (r));
8001 TREE_CHAIN (DECL_CLONED_FUNCTION (r)) = r;
8004 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
8005 this in the special friend case mentioned above where
8006 GEN_TMPL is NULL. */
8009 DECL_TEMPLATE_INFO (r)
8010 = tree_cons (gen_tmpl, argvec, NULL_TREE);
8011 SET_DECL_IMPLICIT_INSTANTIATION (r);
8012 register_specialization (r, gen_tmpl, argvec, false);
8014 /* We're not supposed to instantiate default arguments
8015 until they are called, for a template. But, for a
8018 template <class T> void f ()
8019 { extern void g(int i = T()); }
8021 we should do the substitution when the template is
8022 instantiated. We handle the member function case in
8023 instantiate_class_template since the default arguments
8024 might refer to other members of the class. */
8026 && !PRIMARY_TEMPLATE_P (gen_tmpl)
8027 && !uses_template_parms (argvec))
8028 tsubst_default_arguments (r);
8031 DECL_TEMPLATE_INFO (r) = NULL_TREE;
8033 /* Copy the list of befriending classes. */
8034 for (friends = &DECL_BEFRIENDING_CLASSES (r);
8036 friends = &TREE_CHAIN (*friends))
8038 *friends = copy_node (*friends);
8039 TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends),
8044 if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r))
8046 maybe_retrofit_in_chrg (r);
8047 if (DECL_CONSTRUCTOR_P (r))
8048 grok_ctor_properties (ctx, r);
8049 /* If this is an instantiation of a member template, clone it.
8050 If it isn't, that'll be handled by
8051 clone_constructors_and_destructors. */
8052 if (PRIMARY_TEMPLATE_P (gen_tmpl))
8053 clone_function_decl (r, /*update_method_vec_p=*/0);
8055 else if (IDENTIFIER_OPNAME_P (DECL_NAME (r))
8056 && !grok_op_properties (r, (complain & tf_error) != 0))
8057 return error_mark_node;
8059 if (DECL_FRIEND_P (t) && DECL_FRIEND_CONTEXT (t))
8060 SET_DECL_FRIEND_CONTEXT (r,
8061 tsubst (DECL_FRIEND_CONTEXT (t),
8062 args, complain, in_decl));
8064 /* Possibly limit visibility based on template args. */
8065 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
8066 if (DECL_VISIBILITY_SPECIFIED (t))
8068 DECL_VISIBILITY_SPECIFIED (r) = 0;
8070 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
8072 determine_visibility (r);
8074 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
8075 args, complain, in_decl);
8081 tree type = NULL_TREE;
8083 tree expanded_types = NULL_TREE;
8084 tree prev_r = NULL_TREE;
8085 tree first_r = NULL_TREE;
8087 if (FUNCTION_PARAMETER_PACK_P (t))
8089 /* If there is a local specialization that isn't a
8090 parameter pack, it means that we're doing a "simple"
8091 substitution from inside tsubst_pack_expansion. Just
8092 return the local specialization (which will be a single
8094 tree spec = NULL_TREE;
8095 if (local_specializations)
8096 spec = retrieve_local_specialization (t);
8098 && TREE_CODE (spec) == PARM_DECL
8099 && TREE_CODE (TREE_TYPE (spec)) != TYPE_PACK_EXPANSION)
8102 /* Expand the TYPE_PACK_EXPANSION that provides the types for
8103 the parameters in this function parameter pack. */
8104 expanded_types = tsubst_pack_expansion (TREE_TYPE (t), args,
8106 if (TREE_CODE (expanded_types) == TREE_VEC)
8108 len = TREE_VEC_LENGTH (expanded_types);
8110 /* Zero-length parameter packs are boring. Just substitute
8113 return tsubst (TREE_CHAIN (t), args, complain,
8118 /* All we did was update the type. Make a note of that. */
8119 type = expanded_types;
8120 expanded_types = NULL_TREE;
8124 /* Loop through all of the parameter's we'll build. When T is
8125 a function parameter pack, LEN is the number of expanded
8126 types in EXPANDED_TYPES; otherwise, LEN is 1. */
8128 for (i = 0; i < len; ++i)
8132 if (DECL_TEMPLATE_PARM_P (t))
8133 SET_DECL_TEMPLATE_PARM_P (r);
8136 /* We're on the Ith parameter of the function parameter
8139 /* Get the Ith type. */
8140 type = TREE_VEC_ELT (expanded_types, i);
8143 /* Rename the parameter to include the index. */
8145 make_ith_pack_parameter_name (DECL_NAME (r), i);
8148 /* We're dealing with a normal parameter. */
8149 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8151 type = type_decays_to (type);
8152 TREE_TYPE (r) = type;
8153 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
8155 if (DECL_INITIAL (r))
8157 if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
8158 DECL_INITIAL (r) = TREE_TYPE (r);
8160 DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
8164 DECL_CONTEXT (r) = NULL_TREE;
8166 if (!DECL_TEMPLATE_PARM_P (r))
8167 DECL_ARG_TYPE (r) = type_passed_as (type);
8169 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
8170 args, complain, in_decl);
8172 /* Keep track of the first new parameter we
8173 generate. That's what will be returned to the
8178 /* Build a proper chain of parameters when substituting
8179 into a function parameter pack. */
8181 TREE_CHAIN (prev_r) = r;
8185 TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args,
8186 complain, TREE_CHAIN (t));
8188 /* FIRST_R contains the start of the chain we've built. */
8198 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8199 if (type == error_mark_node)
8200 return error_mark_node;
8201 TREE_TYPE (r) = type;
8202 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
8204 /* DECL_INITIAL gives the number of bits in a bit-field. */
8206 = tsubst_expr (DECL_INITIAL (t), args,
8208 /*integral_constant_expression_p=*/true);
8209 /* We don't have to set DECL_CONTEXT here; it is set by
8210 finish_member_declaration. */
8211 TREE_CHAIN (r) = NULL_TREE;
8212 if (VOID_TYPE_P (type))
8213 error ("instantiation of %q+D as type %qT", r, type);
8215 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
8216 args, complain, in_decl);
8221 /* We reach here only for member using decls. */
8222 if (DECL_DEPENDENT_P (t))
8224 r = do_class_using_decl
8225 (tsubst_copy (USING_DECL_SCOPE (t), args, complain, in_decl),
8226 tsubst_copy (DECL_NAME (t), args, complain, in_decl));
8228 r = error_mark_node;
8233 TREE_CHAIN (r) = NULL_TREE;
8240 tree argvec = NULL_TREE;
8241 tree gen_tmpl = NULL_TREE;
8243 tree tmpl = NULL_TREE;
8245 tree type = NULL_TREE;
8248 if (TREE_CODE (t) == TYPE_DECL
8249 && t == TYPE_MAIN_DECL (TREE_TYPE (t)))
8251 /* If this is the canonical decl, we don't have to
8252 mess with instantiations, and often we can't (for
8253 typename, template type parms and such). Note that
8254 TYPE_NAME is not correct for the above test if
8255 we've copied the type for a typedef. */
8256 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8257 if (type == error_mark_node)
8258 return error_mark_node;
8259 r = TYPE_NAME (type);
8263 /* Check to see if we already have the specialization we
8266 if (DECL_CLASS_SCOPE_P (t) || DECL_NAMESPACE_SCOPE_P (t))
8268 /* T is a static data member or namespace-scope entity.
8269 We have to substitute into namespace-scope variables
8270 (even though such entities are never templates) because
8273 template <class T> void f() { extern T t; }
8275 where the entity referenced is not known until
8276 instantiation time. */
8278 ctx = DECL_CONTEXT (t);
8279 if (DECL_CLASS_SCOPE_P (t))
8281 ctx = tsubst_aggr_type (ctx, args,
8283 in_decl, /*entering_scope=*/1);
8284 /* If CTX is unchanged, then T is in fact the
8285 specialization we want. That situation occurs when
8286 referencing a static data member within in its own
8287 class. We can use pointer equality, rather than
8288 same_type_p, because DECL_CONTEXT is always
8290 if (ctx == DECL_CONTEXT (t))
8296 tmpl = DECL_TI_TEMPLATE (t);
8297 gen_tmpl = most_general_template (tmpl);
8298 argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl);
8299 spec = (retrieve_specialization
8301 /*class_specializations_p=*/false));
8306 /* A local variable. */
8308 /* Subsequent calls to pushdecl will fill this in. */
8310 spec = retrieve_local_specialization (t);
8312 /* If we already have the specialization we need, there is
8313 nothing more to do. */
8320 /* Create a new node for the specialization we need. */
8322 if (type == NULL_TREE)
8323 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8324 if (TREE_CODE (r) == VAR_DECL)
8326 /* Even if the original location is out of scope, the
8327 newly substituted one is not. */
8328 DECL_DEAD_FOR_LOCAL (r) = 0;
8329 DECL_INITIALIZED_P (r) = 0;
8330 DECL_TEMPLATE_INSTANTIATED (r) = 0;
8331 if (type == error_mark_node)
8332 return error_mark_node;
8333 if (TREE_CODE (type) == FUNCTION_TYPE)
8335 /* It may seem that this case cannot occur, since:
8340 declares a function, not a variable. However:
8343 template <typename T> void g() { T t; }
8344 template void g<f>();
8346 is an attempt to declare a variable with function
8348 error ("variable %qD has function type",
8349 /* R is not yet sufficiently initialized, so we
8350 just use its name. */
8352 return error_mark_node;
8354 type = complete_type (type);
8355 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
8356 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t);
8357 type = check_var_type (DECL_NAME (r), type);
8359 if (DECL_HAS_VALUE_EXPR_P (t))
8361 tree ve = DECL_VALUE_EXPR (t);
8362 ve = tsubst_expr (ve, args, complain, in_decl,
8363 /*constant_expression_p=*/false);
8364 SET_DECL_VALUE_EXPR (r, ve);
8367 else if (DECL_SELF_REFERENCE_P (t))
8368 SET_DECL_SELF_REFERENCE_P (r);
8369 TREE_TYPE (r) = type;
8370 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
8371 DECL_CONTEXT (r) = ctx;
8372 /* Clear out the mangled name and RTL for the instantiation. */
8373 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
8374 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
8375 SET_DECL_RTL (r, NULL_RTX);
8376 /* The initializer must not be expanded until it is required;
8378 DECL_INITIAL (r) = NULL_TREE;
8379 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
8380 SET_DECL_RTL (r, NULL_RTX);
8381 DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0;
8382 if (TREE_CODE (r) == VAR_DECL)
8384 /* Possibly limit visibility based on template args. */
8385 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
8386 if (DECL_VISIBILITY_SPECIFIED (t))
8388 DECL_VISIBILITY_SPECIFIED (r) = 0;
8390 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
8392 determine_visibility (r);
8394 /* Preserve a typedef that names a type. */
8395 else if (TREE_CODE (r) == TYPE_DECL
8396 && DECL_ORIGINAL_TYPE (t)
8397 && type != error_mark_node)
8399 DECL_ORIGINAL_TYPE (r) = tsubst (DECL_ORIGINAL_TYPE (t),
8400 args, complain, in_decl);
8401 TREE_TYPE (r) = type = build_variant_type_copy (type);
8402 TYPE_NAME (type) = r;
8407 /* A static data member declaration is always marked
8408 external when it is declared in-class, even if an
8409 initializer is present. We mimic the non-template
8411 DECL_EXTERNAL (r) = 1;
8413 register_specialization (r, gen_tmpl, argvec, false);
8414 DECL_TEMPLATE_INFO (r) = tree_cons (tmpl, argvec, NULL_TREE);
8415 SET_DECL_IMPLICIT_INSTANTIATION (r);
8418 register_local_specialization (r, t);
8420 TREE_CHAIN (r) = NULL_TREE;
8422 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r),
8423 (int) ATTR_FLAG_TYPE_IN_PLACE,
8424 args, complain, in_decl);
8433 /* Restore the file and line information. */
8434 input_location = saved_loc;
8439 /* Substitute into the ARG_TYPES of a function type. */
8442 tsubst_arg_types (tree arg_types,
8444 tsubst_flags_t complain,
8447 tree remaining_arg_types;
8448 tree type = NULL_TREE;
8450 tree expanded_args = NULL_TREE;
8453 if (!arg_types || arg_types == void_list_node)
8456 remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types),
8457 args, complain, in_decl);
8458 if (remaining_arg_types == error_mark_node)
8459 return error_mark_node;
8461 if (PACK_EXPANSION_P (TREE_VALUE (arg_types)))
8463 /* For a pack expansion, perform substitution on the
8464 entire expression. Later on, we'll handle the arguments
8466 expanded_args = tsubst_pack_expansion (TREE_VALUE (arg_types),
8467 args, complain, in_decl);
8469 if (TREE_CODE (expanded_args) == TREE_VEC)
8470 /* So that we'll spin through the parameters, one by one. */
8471 i = TREE_VEC_LENGTH (expanded_args);
8474 /* We only partially substituted into the parameter
8475 pack. Our type is TYPE_PACK_EXPANSION. */
8476 type = expanded_args;
8477 expanded_args = NULL_TREE;
8485 type = TREE_VEC_ELT (expanded_args, i);
8487 type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
8489 if (type == error_mark_node)
8490 return error_mark_node;
8491 if (VOID_TYPE_P (type))
8493 if (complain & tf_error)
8495 error ("invalid parameter type %qT", type);
8497 error ("in declaration %q+D", in_decl);
8499 return error_mark_node;
8502 /* Do array-to-pointer, function-to-pointer conversion, and ignore
8503 top-level qualifiers as required. */
8504 type = TYPE_MAIN_VARIANT (type_decays_to (type));
8506 /* We do not substitute into default arguments here. The standard
8507 mandates that they be instantiated only when needed, which is
8508 done in build_over_call. */
8509 default_arg = TREE_PURPOSE (arg_types);
8511 if (default_arg && TREE_CODE (default_arg) == DEFAULT_ARG)
8513 /* We've instantiated a template before its default arguments
8514 have been parsed. This can happen for a nested template
8515 class, and is not an error unless we require the default
8516 argument in a call of this function. */
8517 remaining_arg_types =
8518 tree_cons (default_arg, type, remaining_arg_types);
8519 VEC_safe_push (tree, gc, DEFARG_INSTANTIATIONS (default_arg),
8520 remaining_arg_types);
8523 remaining_arg_types =
8524 hash_tree_cons (default_arg, type, remaining_arg_types);
8527 return remaining_arg_types;
8530 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
8531 *not* handle the exception-specification for FNTYPE, because the
8532 initial substitution of explicitly provided template parameters
8533 during argument deduction forbids substitution into the
8534 exception-specification:
8538 All references in the function type of the function template to the
8539 corresponding template parameters are replaced by the specified tem-
8540 plate argument values. If a substitution in a template parameter or
8541 in the function type of the function template results in an invalid
8542 type, type deduction fails. [Note: The equivalent substitution in
8543 exception specifications is done only when the function is instanti-
8544 ated, at which point a program is ill-formed if the substitution
8545 results in an invalid type.] */
8548 tsubst_function_type (tree t,
8550 tsubst_flags_t complain,
8557 /* The TYPE_CONTEXT is not used for function/method types. */
8558 gcc_assert (TYPE_CONTEXT (t) == NULL_TREE);
8560 /* Substitute the return type. */
8561 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8562 if (return_type == error_mark_node)
8563 return error_mark_node;
8564 /* The standard does not presently indicate that creation of a
8565 function type with an invalid return type is a deduction failure.
8566 However, that is clearly analogous to creating an array of "void"
8567 or a reference to a reference. This is core issue #486. */
8568 if (TREE_CODE (return_type) == ARRAY_TYPE
8569 || TREE_CODE (return_type) == FUNCTION_TYPE)
8571 if (complain & tf_error)
8573 if (TREE_CODE (return_type) == ARRAY_TYPE)
8574 error ("function returning an array");
8576 error ("function returning a function");
8578 return error_mark_node;
8581 /* Substitute the argument types. */
8582 arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args,
8584 if (arg_types == error_mark_node)
8585 return error_mark_node;
8587 if (TYPE_QUALS (return_type) != TYPE_UNQUALIFIED
8588 && in_decl != NULL_TREE
8589 && !TREE_NO_WARNING (in_decl)
8590 && (SCALAR_TYPE_P (return_type) || VOID_TYPE_P (return_type)))
8591 warning (OPT_Wreturn_type,
8592 "type qualifiers ignored on function return type");
8594 /* Construct a new type node and return it. */
8595 if (TREE_CODE (t) == FUNCTION_TYPE)
8596 fntype = build_function_type (return_type, arg_types);
8599 tree r = TREE_TYPE (TREE_VALUE (arg_types));
8600 if (! IS_AGGR_TYPE (r))
8604 Type deduction may fail for any of the following
8607 -- Attempting to create "pointer to member of T" when T
8608 is not a class type. */
8609 if (complain & tf_error)
8610 error ("creating pointer to member function of non-class type %qT",
8612 return error_mark_node;
8615 fntype = build_method_type_directly (r, return_type,
8616 TREE_CHAIN (arg_types));
8618 fntype = cp_build_qualified_type_real (fntype, TYPE_QUALS (t), complain);
8619 fntype = cp_build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t));
8624 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
8625 ARGS into that specification, and return the substituted
8626 specification. If there is no specification, return NULL_TREE. */
8629 tsubst_exception_specification (tree fntype,
8631 tsubst_flags_t complain,
8637 specs = TYPE_RAISES_EXCEPTIONS (fntype);
8638 new_specs = NULL_TREE;
8641 if (! TREE_VALUE (specs))
8648 tree expanded_specs = NULL_TREE;
8650 if (PACK_EXPANSION_P (TREE_VALUE (specs)))
8652 /* Expand the pack expansion type. */
8653 expanded_specs = tsubst_pack_expansion (TREE_VALUE (specs),
8656 len = TREE_VEC_LENGTH (expanded_specs);
8659 for (i = 0; i < len; ++i)
8662 spec = TREE_VEC_ELT (expanded_specs, i);
8664 spec = tsubst (TREE_VALUE (specs), args, complain, in_decl);
8665 if (spec == error_mark_node)
8667 new_specs = add_exception_specifier (new_specs, spec,
8671 specs = TREE_CHAIN (specs);
8677 /* Take the tree structure T and replace template parameters used
8678 therein with the argument vector ARGS. IN_DECL is an associated
8679 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
8680 Issue error and warning messages under control of COMPLAIN. Note
8681 that we must be relatively non-tolerant of extensions here, in
8682 order to preserve conformance; if we allow substitutions that
8683 should not be allowed, we may allow argument deductions that should
8684 not succeed, and therefore report ambiguous overload situations
8685 where there are none. In theory, we could allow the substitution,
8686 but indicate that it should have failed, and allow our caller to
8687 make sure that the right thing happens, but we don't try to do this
8690 This function is used for dealing with types, decls and the like;
8691 for expressions, use tsubst_expr or tsubst_copy. */
8694 tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
8698 if (t == NULL_TREE || t == error_mark_node
8699 || t == integer_type_node
8700 || t == void_type_node
8701 || t == char_type_node
8702 || t == unknown_type_node
8703 || TREE_CODE (t) == NAMESPACE_DECL)
8707 return tsubst_decl (t, args, complain);
8709 if (TREE_CODE (t) == IDENTIFIER_NODE)
8710 type = IDENTIFIER_TYPE_VALUE (t);
8712 type = TREE_TYPE (t);
8714 gcc_assert (type != unknown_type_node);
8716 /* Reuse typedefs. We need to do this to handle dependent attributes,
8717 such as attribute aligned. */
8720 && TYPE_NAME (t) != TYPE_MAIN_DECL (t))
8722 tree decl = TYPE_NAME (t);
8724 if (DECL_CLASS_SCOPE_P (decl)
8725 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl)))
8727 tree tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
8728 tree gen_args = tsubst (DECL_TI_ARGS (decl), args, complain, in_decl);
8729 r = retrieve_specialization (tmpl, gen_args, false);
8731 else if (DECL_FUNCTION_SCOPE_P (decl))
8732 r = retrieve_local_specialization (decl);
8739 r = cp_build_qualified_type_real
8740 (r, cp_type_quals (t) | cp_type_quals (r),
8741 complain | tf_ignore_bad_quals);
8744 /* Else we must be instantiating the typedef, so fall through. */
8748 && TREE_CODE (t) != TYPENAME_TYPE
8749 && TREE_CODE (t) != IDENTIFIER_NODE
8750 && TREE_CODE (t) != FUNCTION_TYPE
8751 && TREE_CODE (t) != METHOD_TYPE)
8752 type = tsubst (type, args, complain, in_decl);
8753 if (type == error_mark_node)
8754 return error_mark_node;
8756 switch (TREE_CODE (t))
8761 return tsubst_aggr_type (t, args, complain, in_decl,
8762 /*entering_scope=*/0);
8765 case IDENTIFIER_NODE:
8777 if (t == integer_type_node)
8780 if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
8781 && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
8785 tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);
8787 max = tsubst_expr (omax, args, complain, in_decl,
8788 /*integral_constant_expression_p=*/false);
8789 max = fold_decl_constant_value (max);
8791 if (TREE_CODE (max) != INTEGER_CST
8792 && TREE_CODE (max) != TEMPLATE_PARM_INDEX
8793 && !at_function_scope_p ())
8795 if (complain & tf_error)
8796 error ("array bound is not an integer constant");
8797 return error_mark_node;
8802 Type deduction may fail for any of the following
8805 Attempting to create an array with a size that is
8806 zero or negative. */
8807 if (integer_zerop (max) && !(complain & tf_error))
8808 /* We must fail if performing argument deduction (as
8809 indicated by the state of complain), so that
8810 another substitution can be found. */
8811 return error_mark_node;
8812 else if (TREE_CODE (max) == INTEGER_CST
8813 && INT_CST_LT (max, integer_zero_node))
8815 if (complain & tf_error)
8816 error ("creating array with negative size (%qE)", max);
8818 return error_mark_node;
8821 return compute_array_index_type (NULL_TREE, max);
8824 case TEMPLATE_TYPE_PARM:
8825 case TEMPLATE_TEMPLATE_PARM:
8826 case BOUND_TEMPLATE_TEMPLATE_PARM:
8827 case TEMPLATE_PARM_INDEX:
8832 tree arg = NULL_TREE;
8836 gcc_assert (TREE_VEC_LENGTH (args) > 0);
8837 template_parm_level_and_index (t, &level, &idx);
8839 levels = TMPL_ARGS_DEPTH (args);
8840 if (level <= levels)
8842 arg = TMPL_ARG (args, level, idx);
8844 if (arg && TREE_CODE (arg) == ARGUMENT_PACK_SELECT)
8845 /* See through ARGUMENT_PACK_SELECT arguments. */
8846 arg = ARGUMENT_PACK_SELECT_ARG (arg);
8849 if (arg == error_mark_node)
8850 return error_mark_node;
8851 else if (arg != NULL_TREE)
8853 if (ARGUMENT_PACK_P (arg))
8854 /* If ARG is an argument pack, we don't actually want to
8855 perform a substitution here, because substitutions
8856 for argument packs are only done
8857 element-by-element. We can get to this point when
8858 substituting the type of a non-type template
8859 parameter pack, when that type actually contains
8860 template parameter packs from an outer template, e.g.,
8862 template<typename... Types> struct A {
8863 template<Types... Values> struct B { };
8867 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
8870 gcc_assert (TYPE_P (arg));
8872 /* cv-quals from the template are discarded when
8873 substituting in a function or reference type. */
8874 if (TREE_CODE (arg) == FUNCTION_TYPE
8875 || TREE_CODE (arg) == METHOD_TYPE
8876 || TREE_CODE (arg) == REFERENCE_TYPE)
8877 quals = cp_type_quals (arg);
8879 quals = cp_type_quals (arg) | cp_type_quals (t);
8881 return cp_build_qualified_type_real
8882 (arg, quals, complain | tf_ignore_bad_quals);
8884 else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
8886 /* We are processing a type constructed from a
8887 template template parameter. */
8888 tree argvec = tsubst (TYPE_TI_ARGS (t),
8889 args, complain, in_decl);
8890 if (argvec == error_mark_node)
8891 return error_mark_node;
8893 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
8894 are resolving nested-types in the signature of a
8895 member function templates. Otherwise ARG is a
8896 TEMPLATE_DECL and is the real template to be
8898 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
8899 arg = TYPE_NAME (arg);
8901 r = lookup_template_class (arg,
8904 /*entering_scope=*/0,
8906 return cp_build_qualified_type_real
8907 (r, TYPE_QUALS (t), complain);
8910 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
8915 /* This can happen during the attempted tsubst'ing in
8916 unify. This means that we don't yet have any information
8917 about the template parameter in question. */
8920 /* If we get here, we must have been looking at a parm for a
8921 more deeply nested template. Make a new version of this
8922 template parameter, but with a lower level. */
8923 switch (TREE_CODE (t))
8925 case TEMPLATE_TYPE_PARM:
8926 case TEMPLATE_TEMPLATE_PARM:
8927 case BOUND_TEMPLATE_TEMPLATE_PARM:
8928 if (cp_type_quals (t))
8930 r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
8931 r = cp_build_qualified_type_real
8932 (r, cp_type_quals (t),
8933 complain | (TREE_CODE (t) == TEMPLATE_TYPE_PARM
8934 ? tf_ignore_bad_quals : 0));
8939 TEMPLATE_TYPE_PARM_INDEX (r)
8940 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t),
8941 r, levels, args, complain);
8942 TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r);
8943 TYPE_MAIN_VARIANT (r) = r;
8944 TYPE_POINTER_TO (r) = NULL_TREE;
8945 TYPE_REFERENCE_TO (r) = NULL_TREE;
8947 if (TREE_CODE (r) == TEMPLATE_TEMPLATE_PARM)
8948 /* We have reduced the level of the template
8949 template parameter, but not the levels of its
8950 template parameters, so canonical_type_parameter
8951 will not be able to find the canonical template
8952 template parameter for this level. Thus, we
8953 require structural equality checking to compare
8954 TEMPLATE_TEMPLATE_PARMs. */
8955 SET_TYPE_STRUCTURAL_EQUALITY (r);
8956 else if (TYPE_STRUCTURAL_EQUALITY_P (t))
8957 SET_TYPE_STRUCTURAL_EQUALITY (r);
8959 TYPE_CANONICAL (r) = canonical_type_parameter (r);
8961 if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
8963 tree argvec = tsubst (TYPE_TI_ARGS (t), args,
8965 if (argvec == error_mark_node)
8966 return error_mark_node;
8968 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r)
8969 = tree_cons (TYPE_TI_TEMPLATE (t), argvec, NULL_TREE);
8974 case TEMPLATE_PARM_INDEX:
8975 r = reduce_template_parm_level (t, type, levels, args, complain);
8987 tree purpose, value, chain;
8989 if (t == void_list_node)
8992 purpose = TREE_PURPOSE (t);
8995 purpose = tsubst (purpose, args, complain, in_decl);
8996 if (purpose == error_mark_node)
8997 return error_mark_node;
8999 value = TREE_VALUE (t);
9002 value = tsubst (value, args, complain, in_decl);
9003 if (value == error_mark_node)
9004 return error_mark_node;
9006 chain = TREE_CHAIN (t);
9007 if (chain && chain != void_type_node)
9009 chain = tsubst (chain, args, complain, in_decl);
9010 if (chain == error_mark_node)
9011 return error_mark_node;
9013 if (purpose == TREE_PURPOSE (t)
9014 && value == TREE_VALUE (t)
9015 && chain == TREE_CHAIN (t))
9017 return hash_tree_cons (purpose, value, chain);
9021 /* We should never be tsubsting a binfo. */
9025 /* A vector of template arguments. */
9027 return tsubst_template_args (t, args, complain, in_decl);
9030 case REFERENCE_TYPE:
9032 enum tree_code code;
9034 if (type == TREE_TYPE (t) && TREE_CODE (type) != METHOD_TYPE)
9037 code = TREE_CODE (t);
9042 Type deduction may fail for any of the following
9045 -- Attempting to create a pointer to reference type.
9046 -- Attempting to create a reference to a reference type or
9047 a reference to void.
9049 Core issue 106 says that creating a reference to a reference
9050 during instantiation is no longer a cause for failure. We
9051 only enforce this check in strict C++98 mode. */
9052 if ((TREE_CODE (type) == REFERENCE_TYPE
9053 && (((cxx_dialect == cxx98) && flag_iso) || code != REFERENCE_TYPE))
9054 || (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE))
9056 static location_t last_loc;
9058 /* We keep track of the last time we issued this error
9059 message to avoid spewing a ton of messages during a
9060 single bad template instantiation. */
9061 if (complain & tf_error
9062 #ifdef USE_MAPPED_LOCATION
9063 && last_loc != input_location
9065 && (last_loc.line != input_line
9066 || last_loc.file != input_filename)
9070 if (TREE_CODE (type) == VOID_TYPE)
9071 error ("forming reference to void");
9073 error ("forming %s to reference type %qT",
9074 (code == POINTER_TYPE) ? "pointer" : "reference",
9076 last_loc = input_location;
9079 return error_mark_node;
9081 else if (code == POINTER_TYPE)
9083 r = build_pointer_type (type);
9084 if (TREE_CODE (type) == METHOD_TYPE)
9085 r = build_ptrmemfunc_type (r);
9087 else if (TREE_CODE (type) == REFERENCE_TYPE)
9088 /* In C++0x, during template argument substitution, when there is an
9089 attempt to create a reference to a reference type, reference
9090 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
9092 "If a template-argument for a template-parameter T names a type
9093 that is a reference to a type A, an attempt to create the type
9094 'lvalue reference to cv T' creates the type 'lvalue reference to
9095 A,' while an attempt to create the type type rvalue reference to
9096 cv T' creates the type T"
9098 r = cp_build_reference_type
9100 TYPE_REF_IS_RVALUE (t) && TYPE_REF_IS_RVALUE (type));
9102 r = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
9103 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
9105 if (r != error_mark_node)
9106 /* Will this ever be needed for TYPE_..._TO values? */
9113 r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
9114 if (r == error_mark_node || !IS_AGGR_TYPE (r))
9118 Type deduction may fail for any of the following
9121 -- Attempting to create "pointer to member of T" when T
9122 is not a class type. */
9123 if (complain & tf_error)
9124 error ("creating pointer to member of non-class type %qT", r);
9125 return error_mark_node;
9127 if (TREE_CODE (type) == REFERENCE_TYPE)
9129 if (complain & tf_error)
9130 error ("creating pointer to member reference type %qT", type);
9131 return error_mark_node;
9133 if (TREE_CODE (type) == VOID_TYPE)
9135 if (complain & tf_error)
9136 error ("creating pointer to member of type void");
9137 return error_mark_node;
9139 gcc_assert (TREE_CODE (type) != METHOD_TYPE);
9140 if (TREE_CODE (type) == FUNCTION_TYPE)
9142 /* The type of the implicit object parameter gets its
9143 cv-qualifiers from the FUNCTION_TYPE. */
9145 tree this_type = cp_build_qualified_type (TYPE_MAIN_VARIANT (r),
9146 cp_type_quals (type));
9148 method_type = build_method_type_directly (this_type,
9150 TYPE_ARG_TYPES (type));
9151 memptr = build_ptrmemfunc_type (build_pointer_type (method_type));
9152 return cp_build_qualified_type_real (memptr, cp_type_quals (t),
9156 return cp_build_qualified_type_real (build_ptrmem_type (r, type),
9165 fntype = tsubst_function_type (t, args, complain, in_decl);
9166 if (fntype == error_mark_node)
9167 return error_mark_node;
9169 /* Substitute the exception specification. */
9170 specs = tsubst_exception_specification (t, args, complain,
9172 if (specs == error_mark_node)
9173 return error_mark_node;
9175 fntype = build_exception_variant (fntype, specs);
9180 tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
9181 if (domain == error_mark_node)
9182 return error_mark_node;
9184 /* As an optimization, we avoid regenerating the array type if
9185 it will obviously be the same as T. */
9186 if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
9189 /* These checks should match the ones in grokdeclarator.
9193 The deduction may fail for any of the following reasons:
9195 -- Attempting to create an array with an element type that
9196 is void, a function type, or a reference type, or [DR337]
9197 an abstract class type. */
9198 if (TREE_CODE (type) == VOID_TYPE
9199 || TREE_CODE (type) == FUNCTION_TYPE
9200 || TREE_CODE (type) == REFERENCE_TYPE)
9202 if (complain & tf_error)
9203 error ("creating array of %qT", type);
9204 return error_mark_node;
9206 if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
9208 if (complain & tf_error)
9209 error ("creating array of %qT, which is an abstract class type",
9211 return error_mark_node;
9214 r = build_cplus_array_type (type, domain);
9216 if (TYPE_USER_ALIGN (t))
9218 TYPE_ALIGN (r) = TYPE_ALIGN (t);
9219 TYPE_USER_ALIGN (r) = 1;
9228 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
9229 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
9231 if (e1 == error_mark_node || e2 == error_mark_node)
9232 return error_mark_node;
9234 return fold_build2 (TREE_CODE (t), TREE_TYPE (t), e1, e2);
9240 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
9241 if (e == error_mark_node)
9242 return error_mark_node;
9244 return fold_build1 (TREE_CODE (t), TREE_TYPE (t), e);
9249 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
9250 in_decl, /*entering_scope=*/1);
9251 tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
9254 if (ctx == error_mark_node || f == error_mark_node)
9255 return error_mark_node;
9257 if (!IS_AGGR_TYPE (ctx))
9259 if (complain & tf_error)
9260 error ("%qT is not a class, struct, or union type", ctx);
9261 return error_mark_node;
9263 else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
9265 /* Normally, make_typename_type does not require that the CTX
9266 have complete type in order to allow things like:
9268 template <class T> struct S { typename S<T>::X Y; };
9270 But, such constructs have already been resolved by this
9271 point, so here CTX really should have complete type, unless
9272 it's a partial instantiation. */
9273 ctx = complete_type (ctx);
9274 if (!COMPLETE_TYPE_P (ctx))
9276 if (complain & tf_error)
9277 cxx_incomplete_type_error (NULL_TREE, ctx);
9278 return error_mark_node;
9282 f = make_typename_type (ctx, f, typename_type,
9283 (complain & tf_error) | tf_keep_type_decl);
9284 if (f == error_mark_node)
9286 if (TREE_CODE (f) == TYPE_DECL)
9288 complain |= tf_ignore_bad_quals;
9292 if (TREE_CODE (f) != TYPENAME_TYPE)
9294 if (TYPENAME_IS_ENUM_P (t) && TREE_CODE (f) != ENUMERAL_TYPE)
9295 error ("%qT resolves to %qT, which is not an enumeration type",
9297 else if (TYPENAME_IS_CLASS_P (t) && !CLASS_TYPE_P (f))
9298 error ("%qT resolves to %qT, which is is not a class type",
9302 return cp_build_qualified_type_real
9303 (f, cp_type_quals (f) | cp_type_quals (t), complain);
9306 case UNBOUND_CLASS_TEMPLATE:
9308 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
9309 in_decl, /*entering_scope=*/1);
9310 tree name = TYPE_IDENTIFIER (t);
9311 tree parm_list = DECL_TEMPLATE_PARMS (TYPE_NAME (t));
9313 if (ctx == error_mark_node || name == error_mark_node)
9314 return error_mark_node;
9317 parm_list = tsubst_template_parms (parm_list, args, complain);
9318 return make_unbound_class_template (ctx, name, parm_list, complain);
9328 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
9329 tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl,
9330 /*integral_constant_expression_p=*/false);
9331 if (e1 == error_mark_node || e2 == error_mark_node)
9332 return error_mark_node;
9334 return build_nt (ARRAY_REF, e1, e2, NULL_TREE, NULL_TREE);
9339 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
9340 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
9341 if (e1 == error_mark_node || e2 == error_mark_node)
9342 return error_mark_node;
9344 return build_qualified_name (/*type=*/NULL_TREE,
9345 e1, e2, QUALIFIED_NAME_IS_TEMPLATE (t));
9352 type = finish_typeof (tsubst_expr
9353 (TYPEOF_TYPE_EXPR (t), args,
9355 /*integral_constant_expression_p=*/false));
9356 return cp_build_qualified_type_real (type,
9358 | cp_type_quals (type),
9367 finish_decltype_type (tsubst_expr
9368 (DECLTYPE_TYPE_EXPR (t), args,
9370 /*integral_constant_expression_p=*/false),
9371 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t));
9372 return cp_build_qualified_type_real (type,
9374 | cp_type_quals (type),
9378 case TYPE_ARGUMENT_PACK:
9379 case NONTYPE_ARGUMENT_PACK:
9381 tree r = make_node (TREE_CODE (t));
9383 tsubst_template_args (ARGUMENT_PACK_ARGS (t),
9387 SET_ARGUMENT_PACK_ARGS (r, packed_out);
9389 /* For template nontype argument packs, also substitute into
9391 if (TREE_CODE (t) == NONTYPE_ARGUMENT_PACK)
9392 TREE_TYPE (r) = tsubst (TREE_TYPE (t), args, complain, in_decl);
9399 sorry ("use of %qs in template",
9400 tree_code_name [(int) TREE_CODE (t)]);
9401 return error_mark_node;
9405 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
9406 type of the expression on the left-hand side of the "." or "->"
9410 tsubst_baselink (tree baselink, tree object_type,
9411 tree args, tsubst_flags_t complain, tree in_decl)
9414 tree qualifying_scope;
9417 tree template_args = 0;
9418 bool template_id_p = false;
9420 /* A baselink indicates a function from a base class. Both the
9421 BASELINK_ACCESS_BINFO and the base class referenced may
9422 indicate bases of the template class, rather than the
9423 instantiated class. In addition, lookups that were not
9424 ambiguous before may be ambiguous now. Therefore, we perform
9425 the lookup again. */
9426 qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink));
9427 qualifying_scope = tsubst (qualifying_scope, args,
9429 fns = BASELINK_FUNCTIONS (baselink);
9430 optype = BASELINK_OPTYPE (baselink);
9431 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
9433 template_id_p = true;
9434 template_args = TREE_OPERAND (fns, 1);
9435 fns = TREE_OPERAND (fns, 0);
9437 template_args = tsubst_template_args (template_args, args,
9440 name = DECL_NAME (get_first_fn (fns));
9441 baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1);
9443 /* If lookup found a single function, mark it as used at this
9444 point. (If it lookup found multiple functions the one selected
9445 later by overload resolution will be marked as used at that
9447 if (BASELINK_P (baselink))
9448 fns = BASELINK_FUNCTIONS (baselink);
9449 if (!template_id_p && !really_overloaded_fn (fns))
9450 mark_used (OVL_CURRENT (fns));
9452 /* Add back the template arguments, if present. */
9453 if (BASELINK_P (baselink) && template_id_p)
9454 BASELINK_FUNCTIONS (baselink)
9455 = build_nt (TEMPLATE_ID_EXPR,
9456 BASELINK_FUNCTIONS (baselink),
9458 /* Update the conversion operator type. */
9459 BASELINK_OPTYPE (baselink)
9460 = tsubst (optype, args, complain, in_decl);
9463 object_type = current_class_type;
9464 return adjust_result_of_qualified_name_lookup (baselink,
9469 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
9470 true if the qualified-id will be a postfix-expression in-and-of
9471 itself; false if more of the postfix-expression follows the
9472 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
9476 tsubst_qualified_id (tree qualified_id, tree args,
9477 tsubst_flags_t complain, tree in_decl,
9478 bool done, bool address_p)
9486 gcc_assert (TREE_CODE (qualified_id) == SCOPE_REF);
9488 /* Figure out what name to look up. */
9489 name = TREE_OPERAND (qualified_id, 1);
9490 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
9493 template_args = TREE_OPERAND (name, 1);
9495 template_args = tsubst_template_args (template_args, args,
9497 name = TREE_OPERAND (name, 0);
9501 is_template = false;
9502 template_args = NULL_TREE;
9505 /* Substitute into the qualifying scope. When there are no ARGS, we
9506 are just trying to simplify a non-dependent expression. In that
9507 case the qualifying scope may be dependent, and, in any case,
9508 substituting will not help. */
9509 scope = TREE_OPERAND (qualified_id, 0);
9512 scope = tsubst (scope, args, complain, in_decl);
9513 expr = tsubst_copy (name, args, complain, in_decl);
9518 if (dependent_type_p (scope))
9519 return build_qualified_name (/*type=*/NULL_TREE,
9521 QUALIFIED_NAME_IS_TEMPLATE (qualified_id));
9523 if (!BASELINK_P (name) && !DECL_P (expr))
9525 if (TREE_CODE (expr) == BIT_NOT_EXPR)
9526 /* If this were actually a destructor call, it would have been
9527 parsed as such by the parser. */
9528 expr = error_mark_node;
9530 expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0, false);
9531 if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL
9532 ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL)
9534 if (complain & tf_error)
9536 error ("dependent-name %qE is parsed as a non-type, but "
9537 "instantiation yields a type", qualified_id);
9538 inform ("say %<typename %E%> if a type is meant", qualified_id);
9540 return error_mark_node;
9546 check_accessibility_of_qualified_id (expr, /*object_type=*/NULL_TREE,
9548 /* Remember that there was a reference to this entity. */
9552 if (expr == error_mark_node || TREE_CODE (expr) == TREE_LIST)
9554 if (complain & tf_error)
9555 qualified_name_lookup_error (scope,
9556 TREE_OPERAND (qualified_id, 1),
9558 return error_mark_node;
9562 expr = lookup_template_function (expr, template_args);
9564 if (expr == error_mark_node && complain & tf_error)
9565 qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1),
9567 else if (TYPE_P (scope))
9569 expr = (adjust_result_of_qualified_name_lookup
9570 (expr, scope, current_class_type));
9571 expr = (finish_qualified_id_expr
9572 (scope, expr, done, address_p,
9573 QUALIFIED_NAME_IS_TEMPLATE (qualified_id),
9574 /*template_arg_p=*/false));
9577 /* Expressions do not generally have reference type. */
9578 if (TREE_CODE (expr) != SCOPE_REF
9579 /* However, if we're about to form a pointer-to-member, we just
9580 want the referenced member referenced. */
9581 && TREE_CODE (expr) != OFFSET_REF)
9582 expr = convert_from_reference (expr);
9587 /* Like tsubst, but deals with expressions. This function just replaces
9588 template parms; to finish processing the resultant expression, use
9592 tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
9594 enum tree_code code;
9597 if (t == NULL_TREE || t == error_mark_node)
9600 code = TREE_CODE (t);
9605 r = retrieve_local_specialization (t);
9606 gcc_assert (r != NULL);
9607 if (TREE_CODE (r) == ARGUMENT_PACK_SELECT)
9608 r = ARGUMENT_PACK_SELECT_ARG (r);
9617 if (DECL_TEMPLATE_PARM_P (t))
9618 return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
9619 /* There is no need to substitute into namespace-scope
9621 if (DECL_NAMESPACE_SCOPE_P (t))
9623 /* If ARGS is NULL, then T is known to be non-dependent. */
9624 if (args == NULL_TREE)
9625 return integral_constant_value (t);
9627 /* Unfortunately, we cannot just call lookup_name here.
9630 template <int I> int f() {
9632 struct S { void g() { E e = a; } };
9635 When we instantiate f<7>::S::g(), say, lookup_name is not
9636 clever enough to find f<7>::a. */
9638 = tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl,
9639 /*entering_scope=*/0);
9641 for (v = TYPE_VALUES (enum_type);
9644 if (TREE_PURPOSE (v) == DECL_NAME (t))
9645 return TREE_VALUE (v);
9647 /* We didn't find the name. That should never happen; if
9648 name-lookup found it during preliminary parsing, we
9649 should find it again here during instantiation. */
9655 if (DECL_CONTEXT (t))
9659 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
9660 /*entering_scope=*/1);
9661 if (ctx != DECL_CONTEXT (t))
9663 tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
9666 if (complain & tf_error)
9667 error ("using invalid field %qD", t);
9668 return error_mark_node;
9678 if ((DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
9679 || local_variable_p (t))
9680 t = tsubst (t, args, complain, in_decl);
9685 return tsubst_baselink (t, current_class_type, args, complain, in_decl);
9688 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
9689 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
9690 args, complain, in_decl);
9691 else if (DECL_FUNCTION_TEMPLATE_P (t) && DECL_MEMBER_TEMPLATE_P (t))
9692 return tsubst (t, args, complain, in_decl);
9693 else if (DECL_CLASS_SCOPE_P (t)
9694 && uses_template_parms (DECL_CONTEXT (t)))
9696 /* Template template argument like the following example need
9699 template <template <class> class TT> struct C {};
9700 template <class T> struct D {
9701 template <class U> struct E {};
9706 We are processing the template argument `E' in #1 for
9707 the template instantiation #2. Originally, `E' is a
9708 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
9709 have to substitute this with one having context `D<int>'. */
9711 tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
9712 return lookup_field (context, DECL_NAME(t), 0, false);
9715 /* Ordinary template template argument. */
9719 case REINTERPRET_CAST_EXPR:
9720 case CONST_CAST_EXPR:
9721 case STATIC_CAST_EXPR:
9722 case DYNAMIC_CAST_EXPR:
9725 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
9726 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
9729 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
9731 /* We only want to compute the number of arguments. */
9732 tree expanded = tsubst_pack_expansion (TREE_OPERAND (t, 0), args,
9734 if (expanded == error_mark_node)
9735 return error_mark_node;
9736 return build_int_cst (size_type_node, TREE_VEC_LENGTH (expanded));
9742 case TRUTH_NOT_EXPR:
9745 case UNARY_PLUS_EXPR: /* Unary + */
9753 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
9754 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
9761 object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
9762 name = TREE_OPERAND (t, 1);
9763 if (TREE_CODE (name) == BIT_NOT_EXPR)
9765 name = tsubst_copy (TREE_OPERAND (name, 0), args,
9767 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
9769 else if (TREE_CODE (name) == SCOPE_REF
9770 && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
9772 tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
9774 name = TREE_OPERAND (name, 1);
9775 name = tsubst_copy (TREE_OPERAND (name, 0), args,
9777 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
9778 name = build_qualified_name (/*type=*/NULL_TREE,
9780 /*template_p=*/false);
9782 else if (TREE_CODE (name) == BASELINK)
9783 name = tsubst_baselink (name,
9784 non_reference (TREE_TYPE (object)),
9788 name = tsubst_copy (name, args, complain, in_decl);
9789 return build_nt (COMPONENT_REF, object, name, NULL_TREE);
9795 case TRUNC_DIV_EXPR:
9797 case FLOOR_DIV_EXPR:
9798 case ROUND_DIV_EXPR:
9799 case EXACT_DIV_EXPR:
9803 case TRUNC_MOD_EXPR:
9804 case FLOOR_MOD_EXPR:
9805 case TRUTH_ANDIF_EXPR:
9806 case TRUTH_ORIF_EXPR:
9807 case TRUTH_AND_EXPR:
9824 case PREDECREMENT_EXPR:
9825 case PREINCREMENT_EXPR:
9826 case POSTDECREMENT_EXPR:
9827 case POSTINCREMENT_EXPR:
9829 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9830 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
9833 return build_qualified_name (/*type=*/NULL_TREE,
9834 tsubst_copy (TREE_OPERAND (t, 0),
9835 args, complain, in_decl),
9836 tsubst_copy (TREE_OPERAND (t, 1),
9837 args, complain, in_decl),
9838 QUALIFIED_NAME_IS_TEMPLATE (t));
9843 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9844 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
9845 NULL_TREE, NULL_TREE);
9849 int n = VL_EXP_OPERAND_LENGTH (t);
9850 tree result = build_vl_exp (CALL_EXPR, n);
9852 for (i = 0; i < n; i++)
9853 TREE_OPERAND (t, i) = tsubst_copy (TREE_OPERAND (t, i), args,
9860 case PSEUDO_DTOR_EXPR:
9863 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9864 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
9865 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
9866 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
9873 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9874 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
9875 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
9876 NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
9883 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9884 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
9885 DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
9886 DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
9890 case TEMPLATE_ID_EXPR:
9892 /* Substituted template arguments */
9893 tree fn = TREE_OPERAND (t, 0);
9894 tree targs = TREE_OPERAND (t, 1);
9896 fn = tsubst_copy (fn, args, complain, in_decl);
9898 targs = tsubst_template_args (targs, args, complain, in_decl);
9900 return lookup_template_function (fn, targs);
9905 tree purpose, value, chain;
9907 if (t == void_list_node)
9910 purpose = TREE_PURPOSE (t);
9912 purpose = tsubst_copy (purpose, args, complain, in_decl);
9913 value = TREE_VALUE (t);
9915 value = tsubst_copy (value, args, complain, in_decl);
9916 chain = TREE_CHAIN (t);
9917 if (chain && chain != void_type_node)
9918 chain = tsubst_copy (chain, args, complain, in_decl);
9919 if (purpose == TREE_PURPOSE (t)
9920 && value == TREE_VALUE (t)
9921 && chain == TREE_CHAIN (t))
9923 return tree_cons (purpose, value, chain);
9930 case TEMPLATE_TYPE_PARM:
9931 case TEMPLATE_TEMPLATE_PARM:
9932 case BOUND_TEMPLATE_TEMPLATE_PARM:
9933 case TEMPLATE_PARM_INDEX:
9935 case REFERENCE_TYPE:
9941 case UNBOUND_CLASS_TEMPLATE:
9945 return tsubst (t, args, complain, in_decl);
9947 case IDENTIFIER_NODE:
9948 if (IDENTIFIER_TYPENAME_P (t))
9950 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
9951 return mangle_conv_op_name_for_type (new_type);
9957 /* This is handled by tsubst_copy_and_build. */
9961 return build_x_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain,
9963 tsubst (TREE_TYPE (t), args, complain, in_decl));
9965 case CLEANUP_POINT_EXPR:
9966 /* We shouldn't have built any of these during initial template
9967 generation. Instead, they should be built during instantiation
9968 in response to the saved STMT_IS_FULL_EXPR_P setting. */
9972 mark_used (TREE_OPERAND (t, 1));
9975 case EXPR_PACK_EXPANSION:
9976 error ("invalid use of pack expansion expression");
9977 return error_mark_node;
9979 case NONTYPE_ARGUMENT_PACK:
9980 error ("use %<...%> to expand argument pack");
9981 return error_mark_node;
9988 /* Like tsubst_copy, but specifically for OpenMP clauses. */
9991 tsubst_omp_clauses (tree clauses, tree args, tsubst_flags_t complain,
9994 tree new_clauses = NULL, nc, oc;
9996 for (oc = clauses; oc ; oc = OMP_CLAUSE_CHAIN (oc))
9998 nc = copy_node (oc);
9999 OMP_CLAUSE_CHAIN (nc) = new_clauses;
10002 switch (OMP_CLAUSE_CODE (nc))
10004 case OMP_CLAUSE_PRIVATE:
10005 case OMP_CLAUSE_SHARED:
10006 case OMP_CLAUSE_FIRSTPRIVATE:
10007 case OMP_CLAUSE_LASTPRIVATE:
10008 case OMP_CLAUSE_REDUCTION:
10009 case OMP_CLAUSE_COPYIN:
10010 case OMP_CLAUSE_COPYPRIVATE:
10011 case OMP_CLAUSE_IF:
10012 case OMP_CLAUSE_NUM_THREADS:
10013 case OMP_CLAUSE_SCHEDULE:
10014 OMP_CLAUSE_OPERAND (nc, 0)
10015 = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 0), args, complain,
10016 in_decl, /*integral_constant_expression_p=*/false);
10018 case OMP_CLAUSE_NOWAIT:
10019 case OMP_CLAUSE_ORDERED:
10020 case OMP_CLAUSE_DEFAULT:
10023 gcc_unreachable ();
10027 return finish_omp_clauses (nreverse (new_clauses));
10030 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
10033 tsubst_copy_asm_operands (tree t, tree args, tsubst_flags_t complain,
10036 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
10038 tree purpose, value, chain;
10043 if (TREE_CODE (t) != TREE_LIST)
10044 return tsubst_copy_and_build (t, args, complain, in_decl,
10045 /*function_p=*/false,
10046 /*integral_constant_expression_p=*/false);
10048 if (t == void_list_node)
10051 purpose = TREE_PURPOSE (t);
10053 purpose = RECUR (purpose);
10054 value = TREE_VALUE (t);
10056 value = RECUR (value);
10057 chain = TREE_CHAIN (t);
10058 if (chain && chain != void_type_node)
10059 chain = RECUR (chain);
10060 return tree_cons (purpose, value, chain);
10064 /* Like tsubst_copy for expressions, etc. but also does semantic
10068 tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl,
10069 bool integral_constant_expression_p)
10071 #define RECUR(NODE) \
10072 tsubst_expr ((NODE), args, complain, in_decl, \
10073 integral_constant_expression_p)
10077 if (t == NULL_TREE || t == error_mark_node)
10080 if (EXPR_HAS_LOCATION (t))
10081 input_location = EXPR_LOCATION (t);
10082 if (STATEMENT_CODE_P (TREE_CODE (t)))
10083 current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
10085 switch (TREE_CODE (t))
10087 case STATEMENT_LIST:
10089 tree_stmt_iterator i;
10090 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
10091 RECUR (tsi_stmt (i));
10095 case CTOR_INITIALIZER:
10096 finish_mem_initializers (tsubst_initializer_list
10097 (TREE_OPERAND (t, 0), args));
10101 finish_return_stmt (RECUR (TREE_OPERAND (t, 0)));
10105 tmp = RECUR (EXPR_STMT_EXPR (t));
10106 if (EXPR_STMT_STMT_EXPR_RESULT (t))
10107 finish_stmt_expr_expr (tmp, cur_stmt_expr);
10109 finish_expr_stmt (tmp);
10113 do_using_directive (RECUR (USING_STMT_NAMESPACE (t)));
10121 decl = DECL_EXPR_DECL (t);
10122 if (TREE_CODE (decl) == LABEL_DECL)
10123 finish_label_decl (DECL_NAME (decl));
10124 else if (TREE_CODE (decl) == USING_DECL)
10126 tree scope = USING_DECL_SCOPE (decl);
10127 tree name = DECL_NAME (decl);
10130 scope = RECUR (scope);
10131 decl = lookup_qualified_name (scope, name,
10132 /*is_type_p=*/false,
10133 /*complain=*/false);
10134 if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
10135 qualified_name_lookup_error (scope, name, decl);
10137 do_local_using_decl (decl, scope, name);
10141 init = DECL_INITIAL (decl);
10142 decl = tsubst (decl, args, complain, in_decl);
10143 if (decl != error_mark_node)
10145 /* By marking the declaration as instantiated, we avoid
10146 trying to instantiate it. Since instantiate_decl can't
10147 handle local variables, and since we've already done
10148 all that needs to be done, that's the right thing to
10150 if (TREE_CODE (decl) == VAR_DECL)
10151 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
10152 if (TREE_CODE (decl) == VAR_DECL
10153 && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
10154 /* Anonymous aggregates are a special case. */
10155 finish_anon_union (decl);
10158 maybe_push_decl (decl);
10159 if (TREE_CODE (decl) == VAR_DECL
10160 && DECL_PRETTY_FUNCTION_P (decl))
10162 /* For __PRETTY_FUNCTION__ we have to adjust the
10164 const char *const name
10165 = cxx_printable_name (current_function_decl, 2);
10166 init = cp_fname_init (name, &TREE_TYPE (decl));
10170 tree t = RECUR (init);
10173 /* If we had an initializer but it
10174 instantiated to nothing,
10175 value-initialize the object. This will
10176 only occur when the initializer was a
10177 pack expansion where the parameter packs
10178 used in that expansion were of length
10180 init = build_default_init (TREE_TYPE (decl),
10186 finish_decl (decl, init, NULL_TREE);
10191 /* A DECL_EXPR can also be used as an expression, in the condition
10192 clause of an if/for/while construct. */
10197 stmt = begin_for_stmt ();
10198 RECUR (FOR_INIT_STMT (t));
10199 finish_for_init_stmt (stmt);
10200 tmp = RECUR (FOR_COND (t));
10201 finish_for_cond (tmp, stmt);
10202 tmp = RECUR (FOR_EXPR (t));
10203 finish_for_expr (tmp, stmt);
10204 RECUR (FOR_BODY (t));
10205 finish_for_stmt (stmt);
10209 stmt = begin_while_stmt ();
10210 tmp = RECUR (WHILE_COND (t));
10211 finish_while_stmt_cond (tmp, stmt);
10212 RECUR (WHILE_BODY (t));
10213 finish_while_stmt (stmt);
10217 stmt = begin_do_stmt ();
10218 RECUR (DO_BODY (t));
10219 finish_do_body (stmt);
10220 tmp = RECUR (DO_COND (t));
10221 finish_do_stmt (tmp, stmt);
10225 stmt = begin_if_stmt ();
10226 tmp = RECUR (IF_COND (t));
10227 finish_if_stmt_cond (tmp, stmt);
10228 RECUR (THEN_CLAUSE (t));
10229 finish_then_clause (stmt);
10231 if (ELSE_CLAUSE (t))
10233 begin_else_clause (stmt);
10234 RECUR (ELSE_CLAUSE (t));
10235 finish_else_clause (stmt);
10238 finish_if_stmt (stmt);
10242 if (BIND_EXPR_BODY_BLOCK (t))
10243 stmt = begin_function_body ();
10245 stmt = begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t)
10246 ? BCS_TRY_BLOCK : 0);
10248 RECUR (BIND_EXPR_BODY (t));
10250 if (BIND_EXPR_BODY_BLOCK (t))
10251 finish_function_body (stmt);
10253 finish_compound_stmt (stmt);
10257 finish_break_stmt ();
10260 case CONTINUE_STMT:
10261 finish_continue_stmt ();
10265 stmt = begin_switch_stmt ();
10266 tmp = RECUR (SWITCH_STMT_COND (t));
10267 finish_switch_cond (tmp, stmt);
10268 RECUR (SWITCH_STMT_BODY (t));
10269 finish_switch_stmt (stmt);
10272 case CASE_LABEL_EXPR:
10273 finish_case_label (RECUR (CASE_LOW (t)),
10274 RECUR (CASE_HIGH (t)));
10278 finish_label_stmt (DECL_NAME (LABEL_EXPR_LABEL (t)));
10282 tmp = GOTO_DESTINATION (t);
10283 if (TREE_CODE (tmp) != LABEL_DECL)
10284 /* Computed goto's must be tsubst'd into. On the other hand,
10285 non-computed gotos must not be; the identifier in question
10286 will have no binding. */
10289 tmp = DECL_NAME (tmp);
10290 finish_goto_stmt (tmp);
10294 tmp = finish_asm_stmt
10295 (ASM_VOLATILE_P (t),
10296 RECUR (ASM_STRING (t)),
10297 tsubst_copy_asm_operands (ASM_OUTPUTS (t), args, complain, in_decl),
10298 tsubst_copy_asm_operands (ASM_INPUTS (t), args, complain, in_decl),
10299 tsubst_copy_asm_operands (ASM_CLOBBERS (t), args, complain, in_decl));
10301 tree asm_expr = tmp;
10302 if (TREE_CODE (asm_expr) == CLEANUP_POINT_EXPR)
10303 asm_expr = TREE_OPERAND (asm_expr, 0);
10304 ASM_INPUT_P (asm_expr) = ASM_INPUT_P (t);
10311 stmt = begin_try_block ();
10312 RECUR (TRY_STMTS (t));
10313 finish_cleanup_try_block (stmt);
10314 finish_cleanup (RECUR (TRY_HANDLERS (t)), stmt);
10318 tree compound_stmt = NULL_TREE;
10320 if (FN_TRY_BLOCK_P (t))
10321 stmt = begin_function_try_block (&compound_stmt);
10323 stmt = begin_try_block ();
10325 RECUR (TRY_STMTS (t));
10327 if (FN_TRY_BLOCK_P (t))
10328 finish_function_try_block (stmt);
10330 finish_try_block (stmt);
10332 RECUR (TRY_HANDLERS (t));
10333 if (FN_TRY_BLOCK_P (t))
10334 finish_function_handler_sequence (stmt, compound_stmt);
10336 finish_handler_sequence (stmt);
10342 tree decl = HANDLER_PARMS (t);
10346 decl = tsubst (decl, args, complain, in_decl);
10347 /* Prevent instantiate_decl from trying to instantiate
10348 this variable. We've already done all that needs to be
10350 if (decl != error_mark_node)
10351 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
10353 stmt = begin_handler ();
10354 finish_handler_parms (decl, stmt);
10355 RECUR (HANDLER_BODY (t));
10356 finish_handler (stmt);
10361 tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
10364 case STATIC_ASSERT:
10367 tsubst_expr (STATIC_ASSERT_CONDITION (t),
10370 /*integral_constant_expression_p=*/true);
10371 finish_static_assert (condition,
10372 STATIC_ASSERT_MESSAGE (t),
10373 STATIC_ASSERT_SOURCE_LOCATION (t),
10374 /*member_p=*/false);
10379 tmp = tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t),
10380 args, complain, in_decl);
10381 stmt = begin_omp_parallel ();
10382 RECUR (OMP_PARALLEL_BODY (t));
10383 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp, stmt))
10384 = OMP_PARALLEL_COMBINED (t);
10389 tree clauses, decl, init, cond, incr, body, pre_body;
10391 clauses = tsubst_omp_clauses (OMP_FOR_CLAUSES (t),
10392 args, complain, in_decl);
10393 init = OMP_FOR_INIT (t);
10394 gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
10395 decl = RECUR (TREE_OPERAND (init, 0));
10396 init = RECUR (TREE_OPERAND (init, 1));
10397 cond = RECUR (OMP_FOR_COND (t));
10398 incr = RECUR (OMP_FOR_INCR (t));
10400 stmt = begin_omp_structured_block ();
10402 pre_body = push_stmt_list ();
10403 RECUR (OMP_FOR_PRE_BODY (t));
10404 pre_body = pop_stmt_list (pre_body);
10406 body = push_stmt_list ();
10407 RECUR (OMP_FOR_BODY (t));
10408 body = pop_stmt_list (body);
10410 t = finish_omp_for (EXPR_LOCATION (t), decl, init, cond, incr, body,
10413 OMP_FOR_CLAUSES (t) = clauses;
10415 add_stmt (finish_omp_structured_block (stmt));
10421 tmp = tsubst_omp_clauses (OMP_CLAUSES (t), args, complain, in_decl);
10422 stmt = push_stmt_list ();
10423 RECUR (OMP_BODY (t));
10424 stmt = pop_stmt_list (stmt);
10427 OMP_BODY (t) = stmt;
10428 OMP_CLAUSES (t) = tmp;
10436 stmt = push_stmt_list ();
10437 RECUR (OMP_BODY (t));
10438 stmt = pop_stmt_list (stmt);
10441 OMP_BODY (t) = stmt;
10446 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t));
10448 tree op1 = TREE_OPERAND (t, 1);
10449 tree lhs = RECUR (TREE_OPERAND (op1, 0));
10450 tree rhs = RECUR (TREE_OPERAND (op1, 1));
10451 finish_omp_atomic (TREE_CODE (op1), lhs, rhs);
10455 case EXPR_PACK_EXPANSION:
10456 error ("invalid use of pack expansion expression");
10457 return error_mark_node;
10459 case NONTYPE_ARGUMENT_PACK:
10460 error ("use %<...%> to expand argument pack");
10461 return error_mark_node;
10464 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t)));
10466 return tsubst_copy_and_build (t, args, complain, in_decl,
10467 /*function_p=*/false,
10468 integral_constant_expression_p);
10475 /* T is a postfix-expression that is not being used in a function
10476 call. Return the substituted version of T. */
10479 tsubst_non_call_postfix_expression (tree t, tree args,
10480 tsubst_flags_t complain,
10483 if (TREE_CODE (t) == SCOPE_REF)
10484 t = tsubst_qualified_id (t, args, complain, in_decl,
10485 /*done=*/false, /*address_p=*/false);
10487 t = tsubst_copy_and_build (t, args, complain, in_decl,
10488 /*function_p=*/false,
10489 /*integral_constant_expression_p=*/false);
10494 /* Like tsubst but deals with expressions and performs semantic
10495 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
10498 tsubst_copy_and_build (tree t,
10500 tsubst_flags_t complain,
10503 bool integral_constant_expression_p)
10505 #define RECUR(NODE) \
10506 tsubst_copy_and_build (NODE, args, complain, in_decl, \
10507 /*function_p=*/false, \
10508 integral_constant_expression_p)
10512 if (t == NULL_TREE || t == error_mark_node)
10515 switch (TREE_CODE (t))
10519 /* Fall through. */
10520 case IDENTIFIER_NODE:
10524 bool non_integral_constant_expression_p;
10525 const char *error_msg;
10527 if (IDENTIFIER_TYPENAME_P (t))
10529 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10530 t = mangle_conv_op_name_for_type (new_type);
10533 /* Look up the name. */
10534 decl = lookup_name (t);
10536 /* By convention, expressions use ERROR_MARK_NODE to indicate
10537 failure, not NULL_TREE. */
10538 if (decl == NULL_TREE)
10539 decl = error_mark_node;
10541 decl = finish_id_expression (t, decl, NULL_TREE,
10543 integral_constant_expression_p,
10544 /*allow_non_integral_constant_expression_p=*/false,
10545 &non_integral_constant_expression_p,
10546 /*template_p=*/false,
10548 /*address_p=*/false,
10549 /*template_arg_p=*/false,
10553 if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE)
10554 decl = unqualified_name_lookup_error (decl);
10558 case TEMPLATE_ID_EXPR:
10561 tree template = RECUR (TREE_OPERAND (t, 0));
10562 tree targs = TREE_OPERAND (t, 1);
10565 targs = tsubst_template_args (targs, args, complain, in_decl);
10567 if (TREE_CODE (template) == COMPONENT_REF)
10569 object = TREE_OPERAND (template, 0);
10570 template = TREE_OPERAND (template, 1);
10573 object = NULL_TREE;
10574 template = lookup_template_function (template, targs);
10577 return build3 (COMPONENT_REF, TREE_TYPE (template),
10578 object, template, NULL_TREE);
10580 return baselink_for_fns (template);
10585 tree r = RECUR (TREE_OPERAND (t, 0));
10587 if (REFERENCE_REF_P (t))
10589 /* A type conversion to reference type will be enclosed in
10590 such an indirect ref, but the substitution of the cast
10591 will have also added such an indirect ref. */
10592 if (TREE_CODE (TREE_TYPE (r)) == REFERENCE_TYPE)
10593 r = convert_from_reference (r);
10596 r = build_x_indirect_ref (r, "unary *");
10602 (tsubst (TREE_TYPE (t), args, complain, in_decl),
10603 RECUR (TREE_OPERAND (t, 0)));
10606 case REINTERPRET_CAST_EXPR:
10607 case CONST_CAST_EXPR:
10608 case DYNAMIC_CAST_EXPR:
10609 case STATIC_CAST_EXPR:
10614 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10615 if (integral_constant_expression_p
10616 && !cast_valid_in_integral_constant_expression_p (type))
10618 error ("a cast to a type other than an integral or "
10619 "enumeration type cannot appear in a constant-expression");
10620 return error_mark_node;
10623 op = RECUR (TREE_OPERAND (t, 0));
10625 switch (TREE_CODE (t))
10628 return build_functional_cast (type, op);
10629 case REINTERPRET_CAST_EXPR:
10630 return build_reinterpret_cast (type, op);
10631 case CONST_CAST_EXPR:
10632 return build_const_cast (type, op);
10633 case DYNAMIC_CAST_EXPR:
10634 return build_dynamic_cast (type, op);
10635 case STATIC_CAST_EXPR:
10636 return build_static_cast (type, op);
10638 gcc_unreachable ();
10642 case POSTDECREMENT_EXPR:
10643 case POSTINCREMENT_EXPR:
10644 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
10645 args, complain, in_decl);
10646 return build_x_unary_op (TREE_CODE (t), op1);
10648 case PREDECREMENT_EXPR:
10649 case PREINCREMENT_EXPR:
10653 case TRUTH_NOT_EXPR:
10654 case UNARY_PLUS_EXPR: /* Unary + */
10655 case REALPART_EXPR:
10656 case IMAGPART_EXPR:
10657 return build_x_unary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0)));
10660 op1 = TREE_OPERAND (t, 0);
10661 if (TREE_CODE (op1) == SCOPE_REF)
10662 op1 = tsubst_qualified_id (op1, args, complain, in_decl,
10663 /*done=*/true, /*address_p=*/true);
10665 op1 = tsubst_non_call_postfix_expression (op1, args, complain,
10667 if (TREE_CODE (op1) == LABEL_DECL)
10668 return finish_label_address_expr (DECL_NAME (op1));
10669 return build_x_unary_op (ADDR_EXPR, op1);
10674 case TRUNC_DIV_EXPR:
10675 case CEIL_DIV_EXPR:
10676 case FLOOR_DIV_EXPR:
10677 case ROUND_DIV_EXPR:
10678 case EXACT_DIV_EXPR:
10682 case TRUNC_MOD_EXPR:
10683 case FLOOR_MOD_EXPR:
10684 case TRUTH_ANDIF_EXPR:
10685 case TRUTH_ORIF_EXPR:
10686 case TRUTH_AND_EXPR:
10687 case TRUTH_OR_EXPR:
10702 return build_x_binary_op
10704 RECUR (TREE_OPERAND (t, 0)),
10705 (TREE_NO_WARNING (TREE_OPERAND (t, 0))
10707 : TREE_CODE (TREE_OPERAND (t, 0))),
10708 RECUR (TREE_OPERAND (t, 1)),
10709 (TREE_NO_WARNING (TREE_OPERAND (t, 1))
10711 : TREE_CODE (TREE_OPERAND (t, 1))),
10712 /*overloaded_p=*/NULL);
10715 return tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
10716 /*address_p=*/false);
10718 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
10719 args, complain, in_decl);
10720 return build_x_binary_op (ARRAY_REF, op1,
10721 (TREE_NO_WARNING (TREE_OPERAND (t, 0))
10723 : TREE_CODE (TREE_OPERAND (t, 0))),
10724 RECUR (TREE_OPERAND (t, 1)),
10725 (TREE_NO_WARNING (TREE_OPERAND (t, 1))
10727 : TREE_CODE (TREE_OPERAND (t, 1))),
10728 /*overloaded_p=*/NULL);
10731 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
10733 /* We only want to compute the number of arguments. */
10734 tree expanded = tsubst_pack_expansion (TREE_OPERAND (t, 0), args,
10735 complain, in_decl);
10736 if (expanded == error_mark_node)
10737 return error_mark_node;
10738 return build_int_cst (size_type_node, TREE_VEC_LENGTH (expanded));
10743 op1 = TREE_OPERAND (t, 0);
10746 /* When there are no ARGS, we are trying to evaluate a
10747 non-dependent expression from the parser. Trying to do
10748 the substitutions may not work. */
10750 op1 = TREE_TYPE (op1);
10755 op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
10756 /*function_p=*/false,
10757 /*integral_constant_expression_p=*/false);
10761 return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t), true);
10763 return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t));
10767 tree r = build_x_modify_expr
10768 (RECUR (TREE_OPERAND (t, 0)),
10769 TREE_CODE (TREE_OPERAND (t, 1)),
10770 RECUR (TREE_OPERAND (t, 2)));
10771 /* TREE_NO_WARNING must be set if either the expression was
10772 parenthesized or it uses an operator such as >>= rather
10773 than plain assignment. In the former case, it was already
10774 set and must be copied. In the latter case,
10775 build_x_modify_expr sets it and it must not be reset
10777 if (TREE_NO_WARNING (t))
10778 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
10783 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
10784 args, complain, in_decl);
10785 /* Remember that there was a reference to this entity. */
10788 return build_x_arrow (op1);
10792 tree init = RECUR (TREE_OPERAND (t, 3));
10794 if (TREE_OPERAND (t, 3) && !init)
10795 /* If there was an initializer in the the original tree, but
10796 it instantiated to an empty list, then we should pass on
10797 VOID_ZERO_NODE to tell build_new that it was an empty
10798 initializer () rather than no initializer. This can only
10799 happen when the initializer is a pack expansion whose
10800 parameter packs are of length zero. */
10801 init = void_zero_node;
10804 (RECUR (TREE_OPERAND (t, 0)),
10805 RECUR (TREE_OPERAND (t, 1)),
10806 RECUR (TREE_OPERAND (t, 2)),
10808 NEW_EXPR_USE_GLOBAL (t));
10812 return delete_sanity
10813 (RECUR (TREE_OPERAND (t, 0)),
10814 RECUR (TREE_OPERAND (t, 1)),
10815 DELETE_EXPR_USE_VEC (t),
10816 DELETE_EXPR_USE_GLOBAL (t));
10818 case COMPOUND_EXPR:
10819 return build_x_compound_expr (RECUR (TREE_OPERAND (t, 0)),
10820 RECUR (TREE_OPERAND (t, 1)));
10829 function = CALL_EXPR_FN (t);
10830 /* When we parsed the expression, we determined whether or
10831 not Koenig lookup should be performed. */
10832 koenig_p = KOENIG_LOOKUP_P (t);
10833 if (TREE_CODE (function) == SCOPE_REF)
10835 qualified_p = true;
10836 function = tsubst_qualified_id (function, args, complain, in_decl,
10838 /*address_p=*/false);
10842 if (TREE_CODE (function) == COMPONENT_REF)
10844 tree op = TREE_OPERAND (function, 1);
10846 qualified_p = (TREE_CODE (op) == SCOPE_REF
10847 || (BASELINK_P (op)
10848 && BASELINK_QUALIFIED_P (op)));
10851 qualified_p = false;
10853 function = tsubst_copy_and_build (function, args, complain,
10856 integral_constant_expression_p);
10858 if (BASELINK_P (function))
10859 qualified_p = true;
10862 /* FIXME: Rewrite this so as not to construct an arglist. */
10863 call_args = RECUR (CALL_EXPR_ARGS (t));
10865 /* We do not perform argument-dependent lookup if normal
10866 lookup finds a non-function, in accordance with the
10867 expected resolution of DR 218. */
10869 && ((is_overloaded_fn (function)
10870 /* If lookup found a member function, the Koenig lookup is
10871 not appropriate, even if an unqualified-name was used
10872 to denote the function. */
10873 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function)))
10874 || TREE_CODE (function) == IDENTIFIER_NODE))
10875 function = perform_koenig_lookup (function, call_args);
10877 if (TREE_CODE (function) == IDENTIFIER_NODE)
10879 unqualified_name_lookup_error (function);
10880 return error_mark_node;
10883 /* Remember that there was a reference to this entity. */
10884 if (DECL_P (function))
10885 mark_used (function);
10887 if (TREE_CODE (function) == OFFSET_REF)
10888 return build_offset_ref_call_from_tree (function, call_args);
10889 if (TREE_CODE (function) == COMPONENT_REF)
10891 if (!BASELINK_P (TREE_OPERAND (function, 1)))
10892 return finish_call_expr (function, call_args,
10893 /*disallow_virtual=*/false,
10894 /*koenig_p=*/false);
10896 return (build_new_method_call
10897 (TREE_OPERAND (function, 0),
10898 TREE_OPERAND (function, 1),
10899 call_args, NULL_TREE,
10900 qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL,
10903 return finish_call_expr (function, call_args,
10904 /*disallow_virtual=*/qualified_p,
10909 return build_x_conditional_expr
10910 (RECUR (TREE_OPERAND (t, 0)),
10911 RECUR (TREE_OPERAND (t, 1)),
10912 RECUR (TREE_OPERAND (t, 2)));
10914 case PSEUDO_DTOR_EXPR:
10915 return finish_pseudo_destructor_expr
10916 (RECUR (TREE_OPERAND (t, 0)),
10917 RECUR (TREE_OPERAND (t, 1)),
10918 RECUR (TREE_OPERAND (t, 2)));
10922 tree purpose, value, chain;
10924 if (t == void_list_node)
10927 if ((TREE_PURPOSE (t) && PACK_EXPANSION_P (TREE_PURPOSE (t)))
10928 || (TREE_VALUE (t) && PACK_EXPANSION_P (TREE_VALUE (t))))
10930 /* We have pack expansions, so expand those and
10931 create a new list out of it. */
10932 tree purposevec = NULL_TREE;
10933 tree valuevec = NULL_TREE;
10937 /* Expand the argument expressions. */
10938 if (TREE_PURPOSE (t))
10939 purposevec = tsubst_pack_expansion (TREE_PURPOSE (t), args,
10940 complain, in_decl);
10941 if (TREE_VALUE (t))
10942 valuevec = tsubst_pack_expansion (TREE_VALUE (t), args,
10943 complain, in_decl);
10945 /* Build the rest of the list. */
10946 chain = TREE_CHAIN (t);
10947 if (chain && chain != void_type_node)
10948 chain = RECUR (chain);
10950 /* Determine the number of arguments. */
10951 if (purposevec && TREE_CODE (purposevec) == TREE_VEC)
10953 len = TREE_VEC_LENGTH (purposevec);
10954 gcc_assert (!valuevec || len == TREE_VEC_LENGTH (valuevec));
10956 else if (TREE_CODE (valuevec) == TREE_VEC)
10957 len = TREE_VEC_LENGTH (valuevec);
10960 /* Since we only performed a partial substitution into
10961 the argument pack, we only return a single list
10963 if (purposevec == TREE_PURPOSE (t)
10964 && valuevec == TREE_VALUE (t)
10965 && chain == TREE_CHAIN (t))
10968 return tree_cons (purposevec, valuevec, chain);
10971 /* Convert the argument vectors into a TREE_LIST */
10975 /* Grab the Ith values. */
10977 purpose = purposevec ? TREE_VEC_ELT (purposevec, i)
10980 = valuevec ? convert_from_reference (TREE_VEC_ELT (valuevec, i))
10983 /* Build the list (backwards). */
10984 chain = tree_cons (purpose, value, chain);
10990 purpose = TREE_PURPOSE (t);
10992 purpose = RECUR (purpose);
10993 value = TREE_VALUE (t);
10995 value = RECUR (value);
10996 chain = TREE_CHAIN (t);
10997 if (chain && chain != void_type_node)
10998 chain = RECUR (chain);
10999 if (purpose == TREE_PURPOSE (t)
11000 && value == TREE_VALUE (t)
11001 && chain == TREE_CHAIN (t))
11003 return tree_cons (purpose, value, chain);
11006 case COMPONENT_REF:
11012 object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
11013 args, complain, in_decl);
11014 /* Remember that there was a reference to this entity. */
11015 if (DECL_P (object))
11016 mark_used (object);
11017 object_type = TREE_TYPE (object);
11019 member = TREE_OPERAND (t, 1);
11020 if (BASELINK_P (member))
11021 member = tsubst_baselink (member,
11022 non_reference (TREE_TYPE (object)),
11023 args, complain, in_decl);
11025 member = tsubst_copy (member, args, complain, in_decl);
11026 if (member == error_mark_node)
11027 return error_mark_node;
11029 if (object_type && !CLASS_TYPE_P (object_type))
11031 if (SCALAR_TYPE_P (object_type))
11033 tree s = NULL_TREE;
11034 tree dtor = member;
11036 if (TREE_CODE (dtor) == SCOPE_REF)
11038 s = TREE_OPERAND (dtor, 0);
11039 dtor = TREE_OPERAND (dtor, 1);
11041 if (TREE_CODE (dtor) == BIT_NOT_EXPR)
11043 dtor = TREE_OPERAND (dtor, 0);
11045 return finish_pseudo_destructor_expr (object, s, dtor);
11049 else if (TREE_CODE (member) == SCOPE_REF
11050 && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
11055 /* Lookup the template functions now that we know what the
11057 tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
11058 args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
11059 member = lookup_qualified_name (TREE_OPERAND (member, 0), tmpl,
11060 /*is_type_p=*/false,
11061 /*complain=*/false);
11062 if (BASELINK_P (member))
11064 BASELINK_FUNCTIONS (member)
11065 = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
11067 member = (adjust_result_of_qualified_name_lookup
11068 (member, BINFO_TYPE (BASELINK_BINFO (member)),
11073 qualified_name_lookup_error (object_type, tmpl, member);
11074 return error_mark_node;
11077 else if (TREE_CODE (member) == SCOPE_REF
11078 && !CLASS_TYPE_P (TREE_OPERAND (member, 0))
11079 && TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL)
11081 if (complain & tf_error)
11083 if (TYPE_P (TREE_OPERAND (member, 0)))
11084 error ("%qT is not a class or namespace",
11085 TREE_OPERAND (member, 0));
11087 error ("%qD is not a class or namespace",
11088 TREE_OPERAND (member, 0));
11090 return error_mark_node;
11092 else if (TREE_CODE (member) == FIELD_DECL)
11093 return finish_non_static_data_member (member, object, NULL_TREE);
11095 return finish_class_member_access_expr (object, member,
11096 /*template_p=*/false);
11101 (RECUR (TREE_OPERAND (t, 0)));
11105 VEC(constructor_elt,gc) *n;
11106 constructor_elt *ce;
11107 unsigned HOST_WIDE_INT idx;
11108 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
11109 bool process_index_p;
11111 bool need_copy_p = false;
11113 if (type == error_mark_node)
11114 return error_mark_node;
11116 /* digest_init will do the wrong thing if we let it. */
11117 if (type && TYPE_PTRMEMFUNC_P (type))
11120 /* We do not want to process the index of aggregate
11121 initializers as they are identifier nodes which will be
11122 looked up by digest_init. */
11123 process_index_p = !(type && IS_AGGR_TYPE (type));
11125 n = VEC_copy (constructor_elt, gc, CONSTRUCTOR_ELTS (t));
11126 newlen = VEC_length (constructor_elt, n);
11127 for (idx = 0; VEC_iterate (constructor_elt, n, idx, ce); idx++)
11129 if (ce->index && process_index_p)
11130 ce->index = RECUR (ce->index);
11132 if (PACK_EXPANSION_P (ce->value))
11134 /* Substitute into the pack expansion. */
11135 ce->value = tsubst_pack_expansion (ce->value, args, complain,
11138 if (ce->value == error_mark_node)
11140 else if (TREE_VEC_LENGTH (ce->value) == 1)
11141 /* Just move the argument into place. */
11142 ce->value = TREE_VEC_ELT (ce->value, 0);
11145 /* Update the length of the final CONSTRUCTOR
11146 arguments vector, and note that we will need to
11148 newlen = newlen + TREE_VEC_LENGTH (ce->value) - 1;
11149 need_copy_p = true;
11153 ce->value = RECUR (ce->value);
11158 VEC(constructor_elt,gc) *old_n = n;
11160 n = VEC_alloc (constructor_elt, gc, newlen);
11161 for (idx = 0; VEC_iterate (constructor_elt, old_n, idx, ce);
11164 if (TREE_CODE (ce->value) == TREE_VEC)
11166 int i, len = TREE_VEC_LENGTH (ce->value);
11167 for (i = 0; i < len; ++i)
11168 CONSTRUCTOR_APPEND_ELT (n, 0,
11169 TREE_VEC_ELT (ce->value, i));
11172 CONSTRUCTOR_APPEND_ELT (n, 0, ce->value);
11176 if (TREE_HAS_CONSTRUCTOR (t))
11177 return finish_compound_literal (type, n);
11179 return build_constructor (NULL_TREE, n);
11184 tree operand_0 = RECUR (TREE_OPERAND (t, 0));
11185 if (TYPE_P (operand_0))
11186 return get_typeid (operand_0);
11187 return build_typeid (operand_0);
11197 tree r = tsubst_copy (t, args, complain, in_decl);
11199 if (TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
11200 /* If the original type was a reference, we'll be wrapped in
11201 the appropriate INDIRECT_REF. */
11202 r = convert_from_reference (r);
11207 return build_x_va_arg (RECUR (TREE_OPERAND (t, 0)),
11208 tsubst_copy (TREE_TYPE (t), args, complain,
11211 case OFFSETOF_EXPR:
11212 return finish_offsetof (RECUR (TREE_OPERAND (t, 0)));
11216 tree type1 = tsubst_copy (TRAIT_EXPR_TYPE1 (t), args,
11217 complain, in_decl);
11219 tree type2 = TRAIT_EXPR_TYPE2 (t);
11221 type2 = tsubst_copy (type2, args, complain, in_decl);
11223 return finish_trait_expr (TRAIT_EXPR_KIND (t), type1, type2);
11228 tree old_stmt_expr = cur_stmt_expr;
11229 tree stmt_expr = begin_stmt_expr ();
11231 cur_stmt_expr = stmt_expr;
11232 tsubst_expr (STMT_EXPR_STMT (t), args, complain, in_decl,
11233 integral_constant_expression_p);
11234 stmt_expr = finish_stmt_expr (stmt_expr, false);
11235 cur_stmt_expr = old_stmt_expr;
11241 t = tsubst_copy (t, args, complain, in_decl);
11242 /* As in finish_id_expression, we resolve enumeration constants
11243 to their underlying values. */
11244 if (TREE_CODE (t) == CONST_DECL)
11246 used_types_insert (TREE_TYPE (t));
11247 return DECL_INITIAL (t);
11252 /* Handle Objective-C++ constructs, if appropriate. */
11255 = objcp_tsubst_copy_and_build (t, args, complain,
11256 in_decl, /*function_p=*/false);
11260 return tsubst_copy (t, args, complain, in_decl);
11266 /* Verify that the instantiated ARGS are valid. For type arguments,
11267 make sure that the type's linkage is ok. For non-type arguments,
11268 make sure they are constants if they are integral or enumerations.
11269 Emit an error under control of COMPLAIN, and return TRUE on error. */
11272 check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain)
11274 int ix, len = DECL_NTPARMS (tmpl);
11275 bool result = false;
11277 for (ix = 0; ix != len; ix++)
11279 tree t = TREE_VEC_ELT (args, ix);
11283 /* [basic.link]: A name with no linkage (notably, the name
11284 of a class or enumeration declared in a local scope)
11285 shall not be used to declare an entity with linkage.
11286 This implies that names with no linkage cannot be used as
11287 template arguments. */
11288 tree nt = no_linkage_check (t, /*relaxed_p=*/false);
11292 /* DR 488 makes use of a type with no linkage cause
11293 type deduction to fail. */
11294 if (complain & tf_error)
11296 if (TYPE_ANONYMOUS_P (nt))
11297 error ("%qT is/uses anonymous type", t);
11299 error ("template argument for %qD uses local type %qT",
11304 /* In order to avoid all sorts of complications, we do not
11305 allow variably-modified types as template arguments. */
11306 else if (variably_modified_type_p (t, NULL_TREE))
11308 if (complain & tf_error)
11309 error ("%qT is a variably modified type", t);
11313 /* A non-type argument of integral or enumerated type must be a
11315 else if (TREE_TYPE (t)
11316 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t))
11317 && !TREE_CONSTANT (t))
11319 if (complain & tf_error)
11320 error ("integral expression %qE is not constant", t);
11324 if (result && (complain & tf_error))
11325 error (" trying to instantiate %qD", tmpl);
11329 /* Instantiate the indicated variable or function template TMPL with
11330 the template arguments in TARG_PTR. */
11333 instantiate_template (tree tmpl, tree targ_ptr, tsubst_flags_t complain)
11338 HOST_WIDE_INT saved_processing_template_decl;
11340 if (tmpl == error_mark_node)
11341 return error_mark_node;
11343 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
11345 /* If this function is a clone, handle it specially. */
11346 if (DECL_CLONED_FUNCTION_P (tmpl))
11351 spec = instantiate_template (DECL_CLONED_FUNCTION (tmpl), targ_ptr,
11353 if (spec == error_mark_node)
11354 return error_mark_node;
11356 /* Look for the clone. */
11357 FOR_EACH_CLONE (clone, spec)
11358 if (DECL_NAME (clone) == DECL_NAME (tmpl))
11360 /* We should always have found the clone by now. */
11361 gcc_unreachable ();
11365 /* Check to see if we already have this specialization. */
11366 spec = retrieve_specialization (tmpl, targ_ptr,
11367 /*class_specializations_p=*/false);
11368 if (spec != NULL_TREE)
11371 gen_tmpl = most_general_template (tmpl);
11372 if (tmpl != gen_tmpl)
11374 /* The TMPL is a partial instantiation. To get a full set of
11375 arguments we must add the arguments used to perform the
11376 partial instantiation. */
11377 targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl),
11380 /* Check to see if we already have this specialization. */
11381 spec = retrieve_specialization (gen_tmpl, targ_ptr,
11382 /*class_specializations_p=*/false);
11383 if (spec != NULL_TREE)
11387 if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr),
11389 return error_mark_node;
11391 /* We are building a FUNCTION_DECL, during which the access of its
11392 parameters and return types have to be checked. However this
11393 FUNCTION_DECL which is the desired context for access checking
11394 is not built yet. We solve this chicken-and-egg problem by
11395 deferring all checks until we have the FUNCTION_DECL. */
11396 push_deferring_access_checks (dk_deferred);
11398 /* Although PROCESSING_TEMPLATE_DECL may be true at this point
11399 (because, for example, we have encountered a non-dependent
11400 function call in the body of a template function and must now
11401 determine which of several overloaded functions will be called),
11402 within the instantiation itself we are not processing a
11404 saved_processing_template_decl = processing_template_decl;
11405 processing_template_decl = 0;
11406 /* Substitute template parameters to obtain the specialization. */
11407 fndecl = tsubst (DECL_TEMPLATE_RESULT (gen_tmpl),
11408 targ_ptr, complain, gen_tmpl);
11409 processing_template_decl = saved_processing_template_decl;
11410 if (fndecl == error_mark_node)
11411 return error_mark_node;
11413 /* Now we know the specialization, compute access previously
11415 push_access_scope (fndecl);
11416 perform_deferred_access_checks ();
11417 pop_access_scope (fndecl);
11418 pop_deferring_access_checks ();
11420 /* The DECL_TI_TEMPLATE should always be the immediate parent
11421 template, not the most general template. */
11422 DECL_TI_TEMPLATE (fndecl) = tmpl;
11424 /* If we've just instantiated the main entry point for a function,
11425 instantiate all the alternate entry points as well. We do this
11426 by cloning the instantiation of the main entry point, not by
11427 instantiating the template clones. */
11428 if (TREE_CHAIN (gen_tmpl) && DECL_CLONED_FUNCTION_P (TREE_CHAIN (gen_tmpl)))
11429 clone_function_decl (fndecl, /*update_method_vec_p=*/0);
11434 /* The FN is a TEMPLATE_DECL for a function. The ARGS are the
11435 arguments that are being used when calling it. TARGS is a vector
11436 into which the deduced template arguments are placed.
11438 Return zero for success, 2 for an incomplete match that doesn't resolve
11439 all the types, and 1 for complete failure. An error message will be
11440 printed only for an incomplete match.
11442 If FN is a conversion operator, or we are trying to produce a specific
11443 specialization, RETURN_TYPE is the return type desired.
11445 The EXPLICIT_TARGS are explicit template arguments provided via a
11448 The parameter STRICT is one of:
11451 We are deducing arguments for a function call, as in
11452 [temp.deduct.call].
11455 We are deducing arguments for a conversion function, as in
11456 [temp.deduct.conv].
11459 We are deducing arguments when doing an explicit instantiation
11460 as in [temp.explicit], when determining an explicit specialization
11461 as in [temp.expl.spec], or when taking the address of a function
11462 template, as in [temp.deduct.funcaddr]. */
11465 fn_type_unification (tree fn,
11466 tree explicit_targs,
11470 unification_kind_t strict,
11476 bool incomplete_argument_packs_p = false;
11478 gcc_assert (TREE_CODE (fn) == TEMPLATE_DECL);
11480 fntype = TREE_TYPE (fn);
11481 if (explicit_targs)
11485 The specified template arguments must match the template
11486 parameters in kind (i.e., type, nontype, template), and there
11487 must not be more arguments than there are parameters;
11488 otherwise type deduction fails.
11490 Nontype arguments must match the types of the corresponding
11491 nontype template parameters, or must be convertible to the
11492 types of the corresponding nontype parameters as specified in
11493 _temp.arg.nontype_, otherwise type deduction fails.
11495 All references in the function type of the function template
11496 to the corresponding template parameters are replaced by the
11497 specified template argument values. If a substitution in a
11498 template parameter or in the function type of the function
11499 template results in an invalid type, type deduction fails. */
11500 tree tparms = DECL_INNERMOST_TEMPLATE_PARMS (fn);
11501 int i, len = TREE_VEC_LENGTH (tparms);
11502 tree converted_args;
11503 bool incomplete = false;
11505 if (explicit_targs == error_mark_node)
11509 = (coerce_template_parms (tparms, explicit_targs, NULL_TREE, tf_none,
11510 /*require_all_args=*/false,
11511 /*use_default_args=*/false));
11512 if (converted_args == error_mark_node)
11515 /* Substitute the explicit args into the function type. This is
11516 necessary so that, for instance, explicitly declared function
11517 arguments can match null pointed constants. If we were given
11518 an incomplete set of explicit args, we must not do semantic
11519 processing during substitution as we could create partial
11521 for (i = 0; i < len; i++)
11523 tree parm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
11524 bool parameter_pack = false;
11526 /* Dig out the actual parm. */
11527 if (TREE_CODE (parm) == TYPE_DECL
11528 || TREE_CODE (parm) == TEMPLATE_DECL)
11530 parm = TREE_TYPE (parm);
11531 parameter_pack = TEMPLATE_TYPE_PARAMETER_PACK (parm);
11533 else if (TREE_CODE (parm) == PARM_DECL)
11535 parm = DECL_INITIAL (parm);
11536 parameter_pack = TEMPLATE_PARM_PARAMETER_PACK (parm);
11539 if (parameter_pack)
11543 template_parm_level_and_index (parm, &level, &idx);
11545 /* Mark the argument pack as "incomplete". We could
11546 still deduce more arguments during unification. */
11547 targ = TMPL_ARG (converted_args, level, idx);
11550 ARGUMENT_PACK_INCOMPLETE_P(targ) = 1;
11551 ARGUMENT_PACK_EXPLICIT_ARGS (targ)
11552 = ARGUMENT_PACK_ARGS (targ);
11555 /* We have some incomplete argument packs. */
11556 incomplete_argument_packs_p = true;
11560 if (incomplete_argument_packs_p)
11561 /* Any substitution is guaranteed to be incomplete if there
11562 are incomplete argument packs, because we can still deduce
11566 incomplete = NUM_TMPL_ARGS (explicit_targs) != NUM_TMPL_ARGS (targs);
11568 processing_template_decl += incomplete;
11569 fntype = tsubst (fntype, converted_args, tf_none, NULL_TREE);
11570 processing_template_decl -= incomplete;
11572 if (fntype == error_mark_node)
11575 /* Place the explicitly specified arguments in TARGS. */
11576 for (i = NUM_TMPL_ARGS (converted_args); i--;)
11577 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i);
11580 /* Never do unification on the 'this' parameter. */
11581 parms = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (fntype));
11585 parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms);
11586 args = tree_cons (NULL_TREE, return_type, args);
11589 /* We allow incomplete unification without an error message here
11590 because the standard doesn't seem to explicitly prohibit it. Our
11591 callers must be ready to deal with unification failures in any
11593 result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
11594 targs, parms, args, /*subr=*/0,
11597 if (result == 0 && incomplete_argument_packs_p)
11599 int i, len = NUM_TMPL_ARGS (targs);
11601 /* Clear the "incomplete" flags on all argument packs. */
11602 for (i = 0; i < len; i++)
11604 tree arg = TREE_VEC_ELT (targs, i);
11605 if (ARGUMENT_PACK_P (arg))
11607 ARGUMENT_PACK_INCOMPLETE_P (arg) = 0;
11608 ARGUMENT_PACK_EXPLICIT_ARGS (arg) = NULL_TREE;
11614 /* All is well so far. Now, check:
11618 When all template arguments have been deduced, all uses of
11619 template parameters in nondeduced contexts are replaced with
11620 the corresponding deduced argument values. If the
11621 substitution results in an invalid type, as described above,
11622 type deduction fails. */
11623 if (tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE)
11624 == error_mark_node)
11630 /* Adjust types before performing type deduction, as described in
11631 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
11632 sections are symmetric. PARM is the type of a function parameter
11633 or the return type of the conversion function. ARG is the type of
11634 the argument passed to the call, or the type of the value
11635 initialized with the result of the conversion function.
11636 ARG_EXPR is the original argument expression, which may be null. */
11639 maybe_adjust_types_for_deduction (unification_kind_t strict,
11653 /* Swap PARM and ARG throughout the remainder of this
11654 function; the handling is precisely symmetric since PARM
11655 will initialize ARG rather than vice versa. */
11663 /* There is nothing to do in this case. */
11667 gcc_unreachable ();
11670 if (TREE_CODE (*parm) != REFERENCE_TYPE)
11672 /* [temp.deduct.call]
11674 If P is not a reference type:
11676 --If A is an array type, the pointer type produced by the
11677 array-to-pointer standard conversion (_conv.array_) is
11678 used in place of A for type deduction; otherwise,
11680 --If A is a function type, the pointer type produced by
11681 the function-to-pointer standard conversion
11682 (_conv.func_) is used in place of A for type deduction;
11685 --If A is a cv-qualified type, the top level
11686 cv-qualifiers of A's type are ignored for type
11688 if (TREE_CODE (*arg) == ARRAY_TYPE)
11689 *arg = build_pointer_type (TREE_TYPE (*arg));
11690 else if (TREE_CODE (*arg) == FUNCTION_TYPE)
11691 *arg = build_pointer_type (*arg);
11693 *arg = TYPE_MAIN_VARIANT (*arg);
11696 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
11697 of the form T&&, where T is a template parameter, and the argument
11698 is an lvalue, T is deduced as A& */
11699 if (TREE_CODE (*parm) == REFERENCE_TYPE
11700 && TYPE_REF_IS_RVALUE (*parm)
11701 && TREE_CODE (TREE_TYPE (*parm)) == TEMPLATE_TYPE_PARM
11702 && cp_type_quals (TREE_TYPE (*parm)) == TYPE_UNQUALIFIED
11703 && arg_expr && real_lvalue_p (arg_expr))
11704 *arg = build_reference_type (*arg);
11706 /* [temp.deduct.call]
11708 If P is a cv-qualified type, the top level cv-qualifiers
11709 of P's type are ignored for type deduction. If P is a
11710 reference type, the type referred to by P is used for
11712 *parm = TYPE_MAIN_VARIANT (*parm);
11713 if (TREE_CODE (*parm) == REFERENCE_TYPE)
11715 *parm = TREE_TYPE (*parm);
11716 result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
11719 /* DR 322. For conversion deduction, remove a reference type on parm
11720 too (which has been swapped into ARG). */
11721 if (strict == DEDUCE_CONV && TREE_CODE (*arg) == REFERENCE_TYPE)
11722 *arg = TREE_TYPE (*arg);
11727 /* Most parms like fn_type_unification.
11729 If SUBR is 1, we're being called recursively (to unify the
11730 arguments of a function or method parameter of a function
11734 type_unification_real (tree tparms,
11739 unification_kind_t strict,
11742 tree parm, arg, arg_expr;
11744 int ntparms = TREE_VEC_LENGTH (tparms);
11746 int saw_undeduced = 0;
11749 gcc_assert (TREE_CODE (tparms) == TREE_VEC);
11750 gcc_assert (xparms == NULL_TREE || TREE_CODE (xparms) == TREE_LIST);
11751 gcc_assert (!xargs || TREE_CODE (xargs) == TREE_LIST);
11752 gcc_assert (ntparms > 0);
11757 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL | UNIFY_ALLOW_MORE_CV_QUAL
11758 | UNIFY_ALLOW_DERIVED);
11762 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
11766 sub_strict = UNIFY_ALLOW_NONE;
11770 gcc_unreachable ();
11777 while (parms && parms != void_list_node
11778 && args && args != void_list_node)
11780 if (TREE_CODE (TREE_VALUE (parms)) == TYPE_PACK_EXPANSION)
11783 parm = TREE_VALUE (parms);
11784 parms = TREE_CHAIN (parms);
11785 arg = TREE_VALUE (args);
11786 args = TREE_CHAIN (args);
11789 if (arg == error_mark_node)
11791 if (arg == unknown_type_node)
11792 /* We can't deduce anything from this, but we might get all the
11793 template args from other function args. */
11796 /* Conversions will be performed on a function argument that
11797 corresponds with a function parameter that contains only
11798 non-deducible template parameters and explicitly specified
11799 template parameters. */
11800 if (!uses_template_parms (parm))
11805 type = TREE_TYPE (arg);
11809 if (same_type_p (parm, type))
11811 if (strict != DEDUCE_EXACT
11812 && can_convert_arg (parm, type, TYPE_P (arg) ? NULL_TREE : arg,
11821 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
11822 if (type_unknown_p (arg))
11824 /* [temp.deduct.type]
11826 A template-argument can be deduced from a pointer to
11827 function or pointer to member function argument if
11828 the set of overloaded functions does not contain
11829 function templates and at most one of a set of
11830 overloaded functions provides a unique match. */
11831 if (resolve_overloaded_unification
11832 (tparms, targs, parm, arg, strict, sub_strict))
11838 arg = unlowered_expr_type (arg);
11839 if (arg == error_mark_node)
11844 int arg_strict = sub_strict;
11847 arg_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg,
11850 if (unify (tparms, targs, parm, arg, arg_strict))
11857 && parms != void_list_node
11858 && TREE_CODE (TREE_VALUE (parms)) == TYPE_PACK_EXPANSION)
11860 /* Unify the remaining arguments with the pack expansion type. */
11862 tree parmvec = make_tree_vec (1);
11866 /* Count the number of arguments that remain. */
11867 for (t = args; t && t != void_list_node; t = TREE_CHAIN (t))
11870 /* Allocate a TREE_VEC and copy in all of the arguments */
11871 argvec = make_tree_vec (len);
11872 for (i = 0; args && args != void_list_node; args = TREE_CHAIN (args))
11874 TREE_VEC_ELT (argvec, i) = TREE_VALUE (args);
11878 /* Copy the parameter into parmvec. */
11879 TREE_VEC_ELT (parmvec, 0) = TREE_VALUE (parms);
11880 if (unify_pack_expansion (tparms, targs, parmvec, argvec, strict,
11881 /*call_args_p=*/true, /*subr=*/subr))
11884 /* Advance to the end of the list of parameters. */
11885 parms = TREE_CHAIN (parms);
11888 /* Fail if we've reached the end of the parm list, and more args
11889 are present, and the parm list isn't variadic. */
11890 if (args && args != void_list_node && parms == void_list_node)
11892 /* Fail if parms are left and they don't have default values. */
11893 if (parms && parms != void_list_node
11894 && TREE_PURPOSE (parms) == NULL_TREE)
11898 for (i = 0; i < ntparms; i++)
11899 if (!TREE_VEC_ELT (targs, i))
11903 if (TREE_VEC_ELT (tparms, i) == error_mark_node)
11906 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
11908 /* If this is an undeduced nontype parameter that depends on
11909 a type parameter, try another pass; its type may have been
11910 deduced from a later argument than the one from which
11911 this parameter can be deduced. */
11912 if (TREE_CODE (tparm) == PARM_DECL
11913 && uses_template_parms (TREE_TYPE (tparm))
11914 && !saw_undeduced++)
11917 /* Core issue #226 (C++0x) [temp.deduct]:
11919 If a template argument has not been deduced, its
11920 default template argument, if any, is used.
11922 When we are in C++98 mode, TREE_PURPOSE will either
11923 be NULL_TREE or ERROR_MARK_NODE, so we do not need
11924 to explicitly check cxx_dialect here. */
11925 if (TREE_PURPOSE (TREE_VEC_ELT (tparms, i)))
11927 tree arg = tsubst (TREE_PURPOSE (TREE_VEC_ELT (tparms, i)),
11928 targs, tf_none, NULL_TREE);
11929 if (arg == error_mark_node)
11933 TREE_VEC_ELT (targs, i) = arg;
11938 /* If the type parameter is a parameter pack, then it will
11939 be deduced to an empty parameter pack. */
11940 if (template_parameter_pack_p (tparm))
11944 if (TREE_CODE (tparm) == TEMPLATE_PARM_INDEX)
11946 arg = make_node (NONTYPE_ARGUMENT_PACK);
11947 TREE_TYPE (arg) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm));
11948 TREE_CONSTANT (arg) = 1;
11951 arg = make_node (TYPE_ARGUMENT_PACK);
11953 SET_ARGUMENT_PACK_ARGS (arg, make_tree_vec (0));
11955 TREE_VEC_ELT (targs, i) = arg;
11965 /* Subroutine of type_unification_real. Args are like the variables
11966 at the call site. ARG is an overloaded function (or template-id);
11967 we try deducing template args from each of the overloads, and if
11968 only one succeeds, we go with that. Modifies TARGS and returns
11969 true on success. */
11972 resolve_overloaded_unification (tree tparms,
11976 unification_kind_t strict,
11979 tree tempargs = copy_node (targs);
11983 if (TREE_CODE (arg) == ADDR_EXPR)
11985 arg = TREE_OPERAND (arg, 0);
11991 if (TREE_CODE (arg) == COMPONENT_REF)
11992 /* Handle `&x' where `x' is some static or non-static member
11994 arg = TREE_OPERAND (arg, 1);
11996 if (TREE_CODE (arg) == OFFSET_REF)
11997 arg = TREE_OPERAND (arg, 1);
11999 /* Strip baselink information. */
12000 if (BASELINK_P (arg))
12001 arg = BASELINK_FUNCTIONS (arg);
12003 if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
12005 /* If we got some explicit template args, we need to plug them into
12006 the affected templates before we try to unify, in case the
12007 explicit args will completely resolve the templates in question. */
12009 tree expl_subargs = TREE_OPERAND (arg, 1);
12010 arg = TREE_OPERAND (arg, 0);
12012 for (; arg; arg = OVL_NEXT (arg))
12014 tree fn = OVL_CURRENT (arg);
12015 tree subargs, elem;
12017 if (TREE_CODE (fn) != TEMPLATE_DECL)
12020 subargs = get_bindings (fn, DECL_TEMPLATE_RESULT (fn),
12021 expl_subargs, /*check_ret=*/false);
12024 elem = tsubst (TREE_TYPE (fn), subargs, tf_none, NULL_TREE);
12025 good += try_one_overload (tparms, targs, tempargs, parm,
12026 elem, strict, sub_strict, addr_p);
12030 else if (TREE_CODE (arg) != OVERLOAD
12031 && TREE_CODE (arg) != FUNCTION_DECL)
12032 /* If ARG is, for example, "(0, &f)" then its type will be unknown
12033 -- but the deduction does not succeed because the expression is
12034 not just the function on its own. */
12037 for (; arg; arg = OVL_NEXT (arg))
12038 good += try_one_overload (tparms, targs, tempargs, parm,
12039 TREE_TYPE (OVL_CURRENT (arg)),
12040 strict, sub_strict, addr_p);
12042 /* [temp.deduct.type] A template-argument can be deduced from a pointer
12043 to function or pointer to member function argument if the set of
12044 overloaded functions does not contain function templates and at most
12045 one of a set of overloaded functions provides a unique match.
12047 So if we found multiple possibilities, we return success but don't
12048 deduce anything. */
12052 int i = TREE_VEC_LENGTH (targs);
12054 if (TREE_VEC_ELT (tempargs, i))
12055 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i);
12063 /* Subroutine of resolve_overloaded_unification; does deduction for a single
12064 overload. Fills TARGS with any deduced arguments, or error_mark_node if
12065 different overloads deduce different arguments for a given parm.
12066 ADDR_P is true if the expression for which deduction is being
12067 performed was of the form "& fn" rather than simply "fn".
12069 Returns 1 on success. */
12072 try_one_overload (tree tparms,
12077 unification_kind_t strict,
12085 /* [temp.deduct.type] A template-argument can be deduced from a pointer
12086 to function or pointer to member function argument if the set of
12087 overloaded functions does not contain function templates and at most
12088 one of a set of overloaded functions provides a unique match.
12090 So if this is a template, just return success. */
12092 if (uses_template_parms (arg))
12095 if (TREE_CODE (arg) == METHOD_TYPE)
12096 arg = build_ptrmemfunc_type (build_pointer_type (arg));
12098 arg = build_pointer_type (arg);
12100 sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg, NULL);
12102 /* We don't copy orig_targs for this because if we have already deduced
12103 some template args from previous args, unify would complain when we
12104 try to deduce a template parameter for the same argument, even though
12105 there isn't really a conflict. */
12106 nargs = TREE_VEC_LENGTH (targs);
12107 tempargs = make_tree_vec (nargs);
12109 if (unify (tparms, tempargs, parm, arg, sub_strict) != 0)
12112 /* First make sure we didn't deduce anything that conflicts with
12113 explicitly specified args. */
12114 for (i = nargs; i--; )
12116 tree elt = TREE_VEC_ELT (tempargs, i);
12117 tree oldelt = TREE_VEC_ELT (orig_targs, i);
12121 else if (uses_template_parms (elt))
12122 /* Since we're unifying against ourselves, we will fill in
12123 template args used in the function parm list with our own
12124 template parms. Discard them. */
12125 TREE_VEC_ELT (tempargs, i) = NULL_TREE;
12126 else if (oldelt && !template_args_equal (oldelt, elt))
12130 for (i = nargs; i--; )
12132 tree elt = TREE_VEC_ELT (tempargs, i);
12135 TREE_VEC_ELT (targs, i) = elt;
12141 /* PARM is a template class (perhaps with unbound template
12142 parameters). ARG is a fully instantiated type. If ARG can be
12143 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
12144 TARGS are as for unify. */
12147 try_class_unification (tree tparms, tree targs, tree parm, tree arg)
12149 tree copy_of_targs;
12151 if (!CLASSTYPE_TEMPLATE_INFO (arg)
12152 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg))
12153 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm))))
12156 /* We need to make a new template argument vector for the call to
12157 unify. If we used TARGS, we'd clutter it up with the result of
12158 the attempted unification, even if this class didn't work out.
12159 We also don't want to commit ourselves to all the unifications
12160 we've already done, since unification is supposed to be done on
12161 an argument-by-argument basis. In other words, consider the
12162 following pathological case:
12164 template <int I, int J, int K>
12167 template <int I, int J>
12168 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
12170 template <int I, int J, int K>
12171 void f(S<I, J, K>, S<I, I, I>);
12180 Now, by the time we consider the unification involving `s2', we
12181 already know that we must have `f<0, 0, 0>'. But, even though
12182 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
12183 because there are two ways to unify base classes of S<0, 1, 2>
12184 with S<I, I, I>. If we kept the already deduced knowledge, we
12185 would reject the possibility I=1. */
12186 copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs));
12188 /* If unification failed, we're done. */
12189 if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm),
12190 CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE))
12196 /* Given a template type PARM and a class type ARG, find the unique
12197 base type in ARG that is an instance of PARM. We do not examine
12198 ARG itself; only its base-classes. If there is not exactly one
12199 appropriate base class, return NULL_TREE. PARM may be the type of
12200 a partial specialization, as well as a plain template type. Used
12204 get_template_base (tree tparms, tree targs, tree parm, tree arg)
12206 tree rval = NULL_TREE;
12209 gcc_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg)));
12211 binfo = TYPE_BINFO (complete_type (arg));
12213 /* The type could not be completed. */
12216 /* Walk in inheritance graph order. The search order is not
12217 important, and this avoids multiple walks of virtual bases. */
12218 for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo))
12220 tree r = try_class_unification (tparms, targs, parm, BINFO_TYPE (binfo));
12224 /* If there is more than one satisfactory baseclass, then:
12228 If they yield more than one possible deduced A, the type
12232 if (rval && !same_type_p (r, rval))
12242 /* Returns the level of DECL, which declares a template parameter. */
12245 template_decl_level (tree decl)
12247 switch (TREE_CODE (decl))
12250 case TEMPLATE_DECL:
12251 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl));
12254 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
12257 gcc_unreachable ();
12262 /* Decide whether ARG can be unified with PARM, considering only the
12263 cv-qualifiers of each type, given STRICT as documented for unify.
12264 Returns nonzero iff the unification is OK on that basis. */
12267 check_cv_quals_for_unify (int strict, tree arg, tree parm)
12269 int arg_quals = cp_type_quals (arg);
12270 int parm_quals = cp_type_quals (parm);
12272 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
12273 && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
12275 /* Although a CVR qualifier is ignored when being applied to a
12276 substituted template parameter ([8.3.2]/1 for example), that
12277 does not apply during deduction [14.8.2.4]/1, (even though
12278 that is not explicitly mentioned, [14.8.2.4]/9 indicates
12279 this). Except when we're allowing additional CV qualifiers
12280 at the outer level [14.8.2.1]/3,1st bullet. */
12281 if ((TREE_CODE (arg) == REFERENCE_TYPE
12282 || TREE_CODE (arg) == FUNCTION_TYPE
12283 || TREE_CODE (arg) == METHOD_TYPE)
12284 && (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)))
12287 if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
12288 && (parm_quals & TYPE_QUAL_RESTRICT))
12292 if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
12293 && (arg_quals & parm_quals) != parm_quals)
12296 if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL))
12297 && (parm_quals & arg_quals) != arg_quals)
12303 /* Determines the LEVEL and INDEX for the template parameter PARM. */
12305 template_parm_level_and_index (tree parm, int* level, int* index)
12307 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
12308 || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
12309 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
12311 *index = TEMPLATE_TYPE_IDX (parm);
12312 *level = TEMPLATE_TYPE_LEVEL (parm);
12316 *index = TEMPLATE_PARM_IDX (parm);
12317 *level = TEMPLATE_PARM_LEVEL (parm);
12321 /* Unifies the remaining arguments in PACKED_ARGS with the pack
12322 expansion at the end of PACKED_PARMS. Returns 0 if the type
12323 deduction succeeds, 1 otherwise. STRICT is the same as in
12324 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
12325 call argument list. We'll need to adjust the arguments to make them
12326 types. SUBR tells us if this is from a recursive call to
12327 type_unification_real. */
12329 unify_pack_expansion (tree tparms, tree targs, tree packed_parms,
12330 tree packed_args, int strict, bool call_args_p,
12334 = TREE_VEC_ELT (packed_parms, TREE_VEC_LENGTH (packed_parms) - 1);
12335 tree pattern = PACK_EXPANSION_PATTERN (parm);
12336 tree pack, packs = NULL_TREE;
12337 int i, start = TREE_VEC_LENGTH (packed_parms) - 1;
12338 int len = TREE_VEC_LENGTH (packed_args);
12340 /* Determine the parameter packs we will be deducing from the
12341 pattern, and record their current deductions. */
12342 for (pack = PACK_EXPANSION_PARAMETER_PACKS (parm);
12343 pack; pack = TREE_CHAIN (pack))
12345 tree parm_pack = TREE_VALUE (pack);
12348 /* Determine the index and level of this parameter pack. */
12349 template_parm_level_and_index (parm_pack, &level, &idx);
12351 /* Keep track of the parameter packs and their corresponding
12353 packs = tree_cons (parm_pack, TMPL_ARG (targs, level, idx), packs);
12354 TREE_TYPE (packs) = make_tree_vec (len - start);
12357 /* Loop through all of the arguments that have not yet been
12358 unified and unify each with the pattern. */
12359 for (i = start; i < len; i++)
12361 tree parm = pattern;
12363 /* For each parameter pack, clear out the deduced value so that
12364 we can deduce it again. */
12365 for (pack = packs; pack; pack = TREE_CHAIN (pack))
12368 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12370 TMPL_ARG (targs, level, idx) = NULL_TREE;
12373 /* Unify the pattern with the current argument. */
12375 tree arg = TREE_VEC_ELT (packed_args, i);
12376 tree arg_expr = NULL_TREE;
12377 int arg_strict = strict;
12378 bool skip_arg_p = false;
12384 /* This mirrors what we do in type_unification_real. */
12388 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL
12389 | UNIFY_ALLOW_MORE_CV_QUAL
12390 | UNIFY_ALLOW_DERIVED);
12394 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
12398 sub_strict = UNIFY_ALLOW_NONE;
12402 gcc_unreachable ();
12407 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
12408 if (type_unknown_p (arg))
12410 /* [temp.deduct.type] A template-argument can be
12411 deduced from a pointer to function or pointer
12412 to member function argument if the set of
12413 overloaded functions does not contain function
12414 templates and at most one of a set of
12415 overloaded functions provides a unique
12418 if (resolve_overloaded_unification
12419 (tparms, targs, parm, arg, strict, sub_strict)
12428 arg = unlowered_expr_type (arg);
12429 if (arg == error_mark_node)
12434 arg_strict = sub_strict;
12438 maybe_adjust_types_for_deduction (strict, &parm, &arg,
12444 if (unify (tparms, targs, parm, arg, arg_strict))
12449 /* For each parameter pack, collect the deduced value. */
12450 for (pack = packs; pack; pack = TREE_CHAIN (pack))
12453 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12455 TREE_VEC_ELT (TREE_TYPE (pack), i - start) =
12456 TMPL_ARG (targs, level, idx);
12460 /* Verify that the results of unification with the parameter packs
12461 produce results consistent with what we've seen before, and make
12462 the deduced argument packs available. */
12463 for (pack = packs; pack; pack = TREE_CHAIN (pack))
12465 tree old_pack = TREE_VALUE (pack);
12466 tree new_args = TREE_TYPE (pack);
12468 if (old_pack && ARGUMENT_PACK_INCOMPLETE_P (old_pack))
12470 /* Prepend the explicit arguments onto NEW_ARGS. */
12471 tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
12472 tree old_args = new_args;
12473 int i, explicit_len = TREE_VEC_LENGTH (explicit_args);
12474 int len = explicit_len + TREE_VEC_LENGTH (old_args);
12476 /* Copy the explicit arguments. */
12477 new_args = make_tree_vec (len);
12478 for (i = 0; i < explicit_len; i++)
12479 TREE_VEC_ELT (new_args, i) = TREE_VEC_ELT (explicit_args, i);
12481 /* Copy the deduced arguments. */
12482 for (; i < len; i++)
12483 TREE_VEC_ELT (new_args, i) =
12484 TREE_VEC_ELT (old_args, i - explicit_len);
12492 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12494 /* Build the deduced *_ARGUMENT_PACK. */
12495 if (TREE_CODE (TREE_PURPOSE (pack)) == TEMPLATE_PARM_INDEX)
12497 result = make_node (NONTYPE_ARGUMENT_PACK);
12498 TREE_TYPE (result) =
12499 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack)));
12500 TREE_CONSTANT (result) = 1;
12503 result = make_node (TYPE_ARGUMENT_PACK);
12505 SET_ARGUMENT_PACK_ARGS (result, new_args);
12507 /* Note the deduced argument packs for this parameter
12509 TMPL_ARG (targs, level, idx) = result;
12511 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack)
12512 && (ARGUMENT_PACK_ARGS (old_pack)
12513 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack)))
12515 /* We only had the explicitly-provided arguments before, but
12516 now we have a complete set of arguments. */
12518 tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
12519 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12521 /* Keep the original deduced argument pack. */
12522 TMPL_ARG (targs, level, idx) = old_pack;
12524 SET_ARGUMENT_PACK_ARGS (old_pack, new_args);
12525 ARGUMENT_PACK_INCOMPLETE_P (old_pack) = 1;
12526 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack) = explicit_args;
12528 else if (!comp_template_args (ARGUMENT_PACK_ARGS (old_pack),
12530 /* Inconsistent unification of this parameter pack. */
12536 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12538 /* Keep the original deduced argument pack. */
12539 TMPL_ARG (targs, level, idx) = old_pack;
12546 /* Deduce the value of template parameters. TPARMS is the (innermost)
12547 set of template parameters to a template. TARGS is the bindings
12548 for those template parameters, as determined thus far; TARGS may
12549 include template arguments for outer levels of template parameters
12550 as well. PARM is a parameter to a template function, or a
12551 subcomponent of that parameter; ARG is the corresponding argument.
12552 This function attempts to match PARM with ARG in a manner
12553 consistent with the existing assignments in TARGS. If more values
12554 are deduced, then TARGS is updated.
12556 Returns 0 if the type deduction succeeds, 1 otherwise. The
12557 parameter STRICT is a bitwise or of the following flags:
12560 Require an exact match between PARM and ARG.
12561 UNIFY_ALLOW_MORE_CV_QUAL:
12562 Allow the deduced ARG to be more cv-qualified (by qualification
12563 conversion) than ARG.
12564 UNIFY_ALLOW_LESS_CV_QUAL:
12565 Allow the deduced ARG to be less cv-qualified than ARG.
12566 UNIFY_ALLOW_DERIVED:
12567 Allow the deduced ARG to be a template base class of ARG,
12568 or a pointer to a template base class of the type pointed to by
12570 UNIFY_ALLOW_INTEGER:
12571 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
12572 case for more information.
12573 UNIFY_ALLOW_OUTER_LEVEL:
12574 This is the outermost level of a deduction. Used to determine validity
12575 of qualification conversions. A valid qualification conversion must
12576 have const qualified pointers leading up to the inner type which
12577 requires additional CV quals, except at the outer level, where const
12578 is not required [conv.qual]. It would be normal to set this flag in
12579 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
12580 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
12581 This is the outermost level of a deduction, and PARM can be more CV
12582 qualified at this point.
12583 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
12584 This is the outermost level of a deduction, and PARM can be less CV
12585 qualified at this point. */
12588 unify (tree tparms, tree targs, tree parm, tree arg, int strict)
12593 int strict_in = strict;
12595 /* I don't think this will do the right thing with respect to types.
12596 But the only case I've seen it in so far has been array bounds, where
12597 signedness is the only information lost, and I think that will be
12599 while (TREE_CODE (parm) == NOP_EXPR)
12600 parm = TREE_OPERAND (parm, 0);
12602 if (arg == error_mark_node)
12604 if (arg == unknown_type_node)
12605 /* We can't deduce anything from this, but we might get all the
12606 template args from other function args. */
12609 /* If PARM uses template parameters, then we can't bail out here,
12610 even if ARG == PARM, since we won't record unifications for the
12611 template parameters. We might need them if we're trying to
12612 figure out which of two things is more specialized. */
12613 if (arg == parm && !uses_template_parms (parm))
12616 /* Immediately reject some pairs that won't unify because of
12617 cv-qualification mismatches. */
12618 if (TREE_CODE (arg) == TREE_CODE (parm)
12620 /* It is the elements of the array which hold the cv quals of an array
12621 type, and the elements might be template type parms. We'll check
12622 when we recurse. */
12623 && TREE_CODE (arg) != ARRAY_TYPE
12624 /* We check the cv-qualifiers when unifying with template type
12625 parameters below. We want to allow ARG `const T' to unify with
12626 PARM `T' for example, when computing which of two templates
12627 is more specialized, for example. */
12628 && TREE_CODE (arg) != TEMPLATE_TYPE_PARM
12629 && !check_cv_quals_for_unify (strict_in, arg, parm))
12632 if (!(strict & UNIFY_ALLOW_OUTER_LEVEL)
12633 && TYPE_P (parm) && !CP_TYPE_CONST_P (parm))
12634 strict &= ~UNIFY_ALLOW_MORE_CV_QUAL;
12635 strict &= ~UNIFY_ALLOW_OUTER_LEVEL;
12636 strict &= ~UNIFY_ALLOW_DERIVED;
12637 strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
12638 strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL;
12640 switch (TREE_CODE (parm))
12642 case TYPENAME_TYPE:
12644 case UNBOUND_CLASS_TEMPLATE:
12645 /* In a type which contains a nested-name-specifier, template
12646 argument values cannot be deduced for template parameters used
12647 within the nested-name-specifier. */
12650 case TEMPLATE_TYPE_PARM:
12651 case TEMPLATE_TEMPLATE_PARM:
12652 case BOUND_TEMPLATE_TEMPLATE_PARM:
12653 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
12654 if (tparm == error_mark_node)
12657 if (TEMPLATE_TYPE_LEVEL (parm)
12658 != template_decl_level (tparm))
12659 /* The PARM is not one we're trying to unify. Just check
12660 to see if it matches ARG. */
12661 return (TREE_CODE (arg) == TREE_CODE (parm)
12662 && same_type_p (parm, arg)) ? 0 : 1;
12663 idx = TEMPLATE_TYPE_IDX (parm);
12664 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
12665 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx));
12667 /* Check for mixed types and values. */
12668 if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
12669 && TREE_CODE (tparm) != TYPE_DECL)
12670 || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
12671 && TREE_CODE (tparm) != TEMPLATE_DECL))
12674 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
12676 /* ARG must be constructed from a template class or a template
12677 template parameter. */
12678 if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM
12679 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg))
12683 tree parmvec = TYPE_TI_ARGS (parm);
12684 tree argvec = INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg));
12686 = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_TI_TEMPLATE (arg));
12689 /* The resolution to DR150 makes clear that default
12690 arguments for an N-argument may not be used to bind T
12691 to a template template parameter with fewer than N
12692 parameters. It is not safe to permit the binding of
12693 default arguments as an extension, as that may change
12694 the meaning of a conforming program. Consider:
12696 struct Dense { static const unsigned int dim = 1; };
12698 template <template <typename> class View,
12700 void operator+(float, View<Block> const&);
12702 template <typename Block,
12703 unsigned int Dim = Block::dim>
12704 struct Lvalue_proxy { operator float() const; };
12708 Lvalue_proxy<Dense> p;
12713 Here, if Lvalue_proxy is permitted to bind to View, then
12714 the global operator+ will be used; if they are not, the
12715 Lvalue_proxy will be converted to float. */
12716 if (coerce_template_parms (argtmplvec, parmvec,
12717 TYPE_TI_TEMPLATE (parm),
12719 /*require_all_args=*/true,
12720 /*use_default_args=*/false)
12721 == error_mark_node)
12724 /* Deduce arguments T, i from TT<T> or TT<i>.
12725 We check each element of PARMVEC and ARGVEC individually
12726 rather than the whole TREE_VEC since they can have
12727 different number of elements. */
12729 for (i = 0; i < TREE_VEC_LENGTH (parmvec); ++i)
12731 if (unify (tparms, targs,
12732 TREE_VEC_ELT (parmvec, i),
12733 TREE_VEC_ELT (argvec, i),
12738 arg = TYPE_TI_TEMPLATE (arg);
12740 /* Fall through to deduce template name. */
12743 if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
12744 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
12746 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
12748 /* Simple cases: Value already set, does match or doesn't. */
12749 if (targ != NULL_TREE && template_args_equal (targ, arg))
12756 /* If PARM is `const T' and ARG is only `int', we don't have
12757 a match unless we are allowing additional qualification.
12758 If ARG is `const int' and PARM is just `T' that's OK;
12759 that binds `const int' to `T'. */
12760 if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL,
12764 /* Consider the case where ARG is `const volatile int' and
12765 PARM is `const T'. Then, T should be `volatile int'. */
12766 arg = cp_build_qualified_type_real
12767 (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
12768 if (arg == error_mark_node)
12771 /* Simple cases: Value already set, does match or doesn't. */
12772 if (targ != NULL_TREE && same_type_p (targ, arg))
12777 /* Make sure that ARG is not a variable-sized array. (Note
12778 that were talking about variable-sized arrays (like
12779 `int[n]'), rather than arrays of unknown size (like
12780 `int[]').) We'll get very confused by such a type since
12781 the bound of the array will not be computable in an
12782 instantiation. Besides, such types are not allowed in
12783 ISO C++, so we can do as we please here. */
12784 if (variably_modified_type_p (arg, NULL_TREE))
12788 /* If ARG is a parameter pack or an expansion, we cannot unify
12789 against it unless PARM is also a parameter pack. */
12790 if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
12791 && !template_parameter_pack_p (parm))
12794 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
12797 case TEMPLATE_PARM_INDEX:
12798 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
12799 if (tparm == error_mark_node)
12802 if (TEMPLATE_PARM_LEVEL (parm)
12803 != template_decl_level (tparm))
12804 /* The PARM is not one we're trying to unify. Just check
12805 to see if it matches ARG. */
12806 return !(TREE_CODE (arg) == TREE_CODE (parm)
12807 && cp_tree_equal (parm, arg));
12809 idx = TEMPLATE_PARM_IDX (parm);
12810 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
12813 return !cp_tree_equal (targ, arg);
12815 /* [temp.deduct.type] If, in the declaration of a function template
12816 with a non-type template-parameter, the non-type
12817 template-parameter is used in an expression in the function
12818 parameter-list and, if the corresponding template-argument is
12819 deduced, the template-argument type shall match the type of the
12820 template-parameter exactly, except that a template-argument
12821 deduced from an array bound may be of any integral type.
12822 The non-type parameter might use already deduced type parameters. */
12823 tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE);
12824 if (!TREE_TYPE (arg))
12825 /* Template-parameter dependent expression. Just accept it for now.
12826 It will later be processed in convert_template_argument. */
12828 else if (same_type_p (TREE_TYPE (arg), tparm))
12830 else if ((strict & UNIFY_ALLOW_INTEGER)
12831 && (TREE_CODE (tparm) == INTEGER_TYPE
12832 || TREE_CODE (tparm) == BOOLEAN_TYPE))
12833 /* Convert the ARG to the type of PARM; the deduced non-type
12834 template argument must exactly match the types of the
12835 corresponding parameter. */
12836 arg = fold (build_nop (TREE_TYPE (parm), arg));
12837 else if (uses_template_parms (tparm))
12838 /* We haven't deduced the type of this parameter yet. Try again
12844 /* If ARG is a parameter pack or an expansion, we cannot unify
12845 against it unless PARM is also a parameter pack. */
12846 if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
12847 && !TEMPLATE_PARM_PARAMETER_PACK (parm))
12850 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
12855 /* A pointer-to-member constant can be unified only with
12856 another constant. */
12857 if (TREE_CODE (arg) != PTRMEM_CST)
12860 /* Just unify the class member. It would be useless (and possibly
12861 wrong, depending on the strict flags) to unify also
12862 PTRMEM_CST_CLASS, because we want to be sure that both parm and
12863 arg refer to the same variable, even if through different
12864 classes. For instance:
12866 struct A { int x; };
12869 Unification of &A::x and &B::x must succeed. */
12870 return unify (tparms, targs, PTRMEM_CST_MEMBER (parm),
12871 PTRMEM_CST_MEMBER (arg), strict);
12876 if (TREE_CODE (arg) != POINTER_TYPE)
12879 /* [temp.deduct.call]
12881 A can be another pointer or pointer to member type that can
12882 be converted to the deduced A via a qualification
12883 conversion (_conv.qual_).
12885 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
12886 This will allow for additional cv-qualification of the
12887 pointed-to types if appropriate. */
12889 if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
12890 /* The derived-to-base conversion only persists through one
12891 level of pointers. */
12892 strict |= (strict_in & UNIFY_ALLOW_DERIVED);
12894 return unify (tparms, targs, TREE_TYPE (parm),
12895 TREE_TYPE (arg), strict);
12898 case REFERENCE_TYPE:
12899 if (TREE_CODE (arg) != REFERENCE_TYPE)
12901 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
12902 strict & UNIFY_ALLOW_MORE_CV_QUAL);
12905 if (TREE_CODE (arg) != ARRAY_TYPE)
12907 if ((TYPE_DOMAIN (parm) == NULL_TREE)
12908 != (TYPE_DOMAIN (arg) == NULL_TREE))
12910 if (TYPE_DOMAIN (parm) != NULL_TREE)
12917 /* Our representation of array types uses "N - 1" as the
12918 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
12919 not an integer constant. We cannot unify arbitrarily
12920 complex expressions, so we eliminate the MINUS_EXPRs
12922 parm_max = TYPE_MAX_VALUE (TYPE_DOMAIN (parm));
12923 parm_cst = TREE_CODE (parm_max) == INTEGER_CST;
12926 gcc_assert (TREE_CODE (parm_max) == MINUS_EXPR);
12927 parm_max = TREE_OPERAND (parm_max, 0);
12929 arg_max = TYPE_MAX_VALUE (TYPE_DOMAIN (arg));
12930 arg_cst = TREE_CODE (arg_max) == INTEGER_CST;
12933 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
12934 trying to unify the type of a variable with the type
12935 of a template parameter. For example:
12937 template <unsigned int N>
12938 void f (char (&) [N]);
12945 Here, the type of the ARG will be "int [g(i)]", and
12946 may be a SAVE_EXPR, etc. */
12947 if (TREE_CODE (arg_max) != MINUS_EXPR)
12949 arg_max = TREE_OPERAND (arg_max, 0);
12952 /* If only one of the bounds used a MINUS_EXPR, compensate
12953 by adding one to the other bound. */
12954 if (parm_cst && !arg_cst)
12955 parm_max = fold_build2 (PLUS_EXPR,
12959 else if (arg_cst && !parm_cst)
12960 arg_max = fold_build2 (PLUS_EXPR,
12965 if (unify (tparms, targs, parm_max, arg_max, UNIFY_ALLOW_INTEGER))
12968 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
12969 strict & UNIFY_ALLOW_MORE_CV_QUAL);
12976 case ENUMERAL_TYPE:
12978 if (TREE_CODE (arg) != TREE_CODE (parm))
12981 /* We have already checked cv-qualification at the top of the
12983 if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
12986 /* As far as unification is concerned, this wins. Later checks
12987 will invalidate it if necessary. */
12990 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
12991 /* Type INTEGER_CST can come from ordinary constant template args. */
12993 while (TREE_CODE (arg) == NOP_EXPR)
12994 arg = TREE_OPERAND (arg, 0);
12996 if (TREE_CODE (arg) != INTEGER_CST)
12998 return !tree_int_cst_equal (parm, arg);
13003 if (TREE_CODE (arg) != TREE_VEC)
13005 if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
13007 for (i = 0; i < TREE_VEC_LENGTH (parm); ++i)
13008 if (unify (tparms, targs,
13009 TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
13017 if (TREE_CODE (arg) != TREE_CODE (parm))
13020 if (TYPE_PTRMEMFUNC_P (parm))
13022 if (!TYPE_PTRMEMFUNC_P (arg))
13025 return unify (tparms, targs,
13026 TYPE_PTRMEMFUNC_FN_TYPE (parm),
13027 TYPE_PTRMEMFUNC_FN_TYPE (arg),
13031 if (CLASSTYPE_TEMPLATE_INFO (parm))
13033 tree t = NULL_TREE;
13035 if (strict_in & UNIFY_ALLOW_DERIVED)
13037 /* First, we try to unify the PARM and ARG directly. */
13038 t = try_class_unification (tparms, targs,
13043 /* Fallback to the special case allowed in
13044 [temp.deduct.call]:
13046 If P is a class, and P has the form
13047 template-id, then A can be a derived class of
13048 the deduced A. Likewise, if P is a pointer to
13049 a class of the form template-id, A can be a
13050 pointer to a derived class pointed to by the
13052 t = get_template_base (tparms, targs, parm, arg);
13058 else if (CLASSTYPE_TEMPLATE_INFO (arg)
13059 && (CLASSTYPE_TI_TEMPLATE (parm)
13060 == CLASSTYPE_TI_TEMPLATE (arg)))
13061 /* Perhaps PARM is something like S<U> and ARG is S<int>.
13062 Then, we should unify `int' and `U'. */
13065 /* There's no chance of unification succeeding. */
13068 return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
13069 CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE);
13071 else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
13076 case FUNCTION_TYPE:
13077 if (TREE_CODE (arg) != TREE_CODE (parm))
13080 /* CV qualifications for methods can never be deduced, they must
13081 match exactly. We need to check them explicitly here,
13082 because type_unification_real treats them as any other
13083 cvqualified parameter. */
13084 if (TREE_CODE (parm) == METHOD_TYPE
13085 && (!check_cv_quals_for_unify
13087 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (arg))),
13088 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (parm))))))
13091 if (unify (tparms, targs, TREE_TYPE (parm),
13092 TREE_TYPE (arg), UNIFY_ALLOW_NONE))
13094 return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
13095 TYPE_ARG_TYPES (arg), 1, DEDUCE_EXACT,
13099 /* Unify a pointer to member with a pointer to member function, which
13100 deduces the type of the member as a function type. */
13101 if (TYPE_PTRMEMFUNC_P (arg))
13105 cp_cv_quals cv_quals;
13107 /* Check top-level cv qualifiers */
13108 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE, arg, parm))
13111 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
13112 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg), UNIFY_ALLOW_NONE))
13115 /* Determine the type of the function we are unifying against. */
13116 method_type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (arg));
13118 build_function_type (TREE_TYPE (method_type),
13119 TREE_CHAIN (TYPE_ARG_TYPES (method_type)));
13121 /* Extract the cv-qualifiers of the member function from the
13122 implicit object parameter and place them on the function
13123 type to be restored later. */
13125 cp_type_quals(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (method_type))));
13126 fntype = build_qualified_type (fntype, cv_quals);
13127 return unify (tparms, targs, TREE_TYPE (parm), fntype, strict);
13130 if (TREE_CODE (arg) != OFFSET_TYPE)
13132 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
13133 TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE))
13135 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
13139 if (DECL_TEMPLATE_PARM_P (parm))
13140 return unify (tparms, targs, DECL_INITIAL (parm), arg, strict);
13141 if (arg != integral_constant_value (parm))
13146 case TEMPLATE_DECL:
13147 /* Matched cases are handled by the ARG == PARM test above. */
13150 case TYPE_ARGUMENT_PACK:
13151 case NONTYPE_ARGUMENT_PACK:
13153 tree packed_parms = ARGUMENT_PACK_ARGS (parm);
13154 tree packed_args = ARGUMENT_PACK_ARGS (arg);
13155 int i, len = TREE_VEC_LENGTH (packed_parms);
13156 int argslen = TREE_VEC_LENGTH (packed_args);
13157 int parm_variadic_p = 0;
13159 /* Check if the parameters end in a pack, making them variadic. */
13161 && PACK_EXPANSION_P (TREE_VEC_ELT (packed_parms, len - 1)))
13162 parm_variadic_p = 1;
13164 /* If we don't have enough arguments to satisfy the parameters
13165 (not counting the pack expression at the end), or we have
13166 too many arguments for a parameter list that doesn't end in
13167 a pack expression, we can't unify. */
13168 if (argslen < (len - parm_variadic_p)
13169 || (argslen > len && !parm_variadic_p))
13172 /* Unify all of the parameters that precede the (optional)
13173 pack expression. */
13174 for (i = 0; i < len - parm_variadic_p; ++i)
13176 if (unify (tparms, targs, TREE_VEC_ELT (packed_parms, i),
13177 TREE_VEC_ELT (packed_args, i), strict))
13181 if (parm_variadic_p)
13182 return unify_pack_expansion (tparms, targs,
13183 packed_parms, packed_args,
13184 strict, /*call_args_p=*/false,
13192 case DECLTYPE_TYPE:
13193 /* Cannot deduce anything from TYPEOF_TYPE or DECLTYPE_TYPE
13198 /* Unification fails if we hit an error node. */
13202 gcc_assert (EXPR_P (parm));
13204 /* We must be looking at an expression. This can happen with
13208 void foo(S<I>, S<I + 2>);
13210 This is a "nondeduced context":
13214 The nondeduced contexts are:
13216 --A type that is a template-id in which one or more of
13217 the template-arguments is an expression that references
13218 a template-parameter.
13220 In these cases, we assume deduction succeeded, but don't
13221 actually infer any unifications. */
13223 if (!uses_template_parms (parm)
13224 && !template_args_equal (parm, arg))
13231 /* Note that DECL can be defined in this translation unit, if
13235 mark_definable (tree decl)
13238 DECL_NOT_REALLY_EXTERN (decl) = 1;
13239 FOR_EACH_CLONE (clone, decl)
13240 DECL_NOT_REALLY_EXTERN (clone) = 1;
13243 /* Called if RESULT is explicitly instantiated, or is a member of an
13244 explicitly instantiated class. */
13247 mark_decl_instantiated (tree result, int extern_p)
13249 SET_DECL_EXPLICIT_INSTANTIATION (result);
13251 /* If this entity has already been written out, it's too late to
13252 make any modifications. */
13253 if (TREE_ASM_WRITTEN (result))
13256 if (TREE_CODE (result) != FUNCTION_DECL)
13257 /* The TREE_PUBLIC flag for function declarations will have been
13258 set correctly by tsubst. */
13259 TREE_PUBLIC (result) = 1;
13261 /* This might have been set by an earlier implicit instantiation. */
13262 DECL_COMDAT (result) = 0;
13265 DECL_NOT_REALLY_EXTERN (result) = 0;
13268 mark_definable (result);
13269 /* Always make artificials weak. */
13270 if (DECL_ARTIFICIAL (result) && flag_weak)
13271 comdat_linkage (result);
13272 /* For WIN32 we also want to put explicit instantiations in
13273 linkonce sections. */
13274 else if (TREE_PUBLIC (result))
13275 maybe_make_one_only (result);
13278 /* If EXTERN_P, then this function will not be emitted -- unless
13279 followed by an explicit instantiation, at which point its linkage
13280 will be adjusted. If !EXTERN_P, then this function will be
13281 emitted here. In neither circumstance do we want
13282 import_export_decl to adjust the linkage. */
13283 DECL_INTERFACE_KNOWN (result) = 1;
13286 /* Given two function templates PAT1 and PAT2, return:
13288 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
13289 -1 if PAT2 is more specialized than PAT1.
13290 0 if neither is more specialized.
13292 LEN indicates the number of parameters we should consider
13293 (defaulted parameters should not be considered).
13295 The 1998 std underspecified function template partial ordering, and
13296 DR214 addresses the issue. We take pairs of arguments, one from
13297 each of the templates, and deduce them against each other. One of
13298 the templates will be more specialized if all the *other*
13299 template's arguments deduce against its arguments and at least one
13300 of its arguments *does* *not* deduce against the other template's
13301 corresponding argument. Deduction is done as for class templates.
13302 The arguments used in deduction have reference and top level cv
13303 qualifiers removed. Iff both arguments were originally reference
13304 types *and* deduction succeeds in both directions, the template
13305 with the more cv-qualified argument wins for that pairing (if
13306 neither is more cv-qualified, they both are equal). Unlike regular
13307 deduction, after all the arguments have been deduced in this way,
13308 we do *not* verify the deduced template argument values can be
13309 substituted into non-deduced contexts, nor do we have to verify
13310 that all template arguments have been deduced. */
13313 more_specialized_fn (tree pat1, tree pat2, int len)
13315 tree decl1 = DECL_TEMPLATE_RESULT (pat1);
13316 tree decl2 = DECL_TEMPLATE_RESULT (pat2);
13317 tree targs1 = make_tree_vec (DECL_NTPARMS (pat1));
13318 tree targs2 = make_tree_vec (DECL_NTPARMS (pat2));
13319 tree tparms1 = DECL_INNERMOST_TEMPLATE_PARMS (pat1);
13320 tree tparms2 = DECL_INNERMOST_TEMPLATE_PARMS (pat2);
13321 tree args1 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
13322 tree args2 = TYPE_ARG_TYPES (TREE_TYPE (decl2));
13326 /* Remove the this parameter from non-static member functions. If
13327 one is a non-static member function and the other is not a static
13328 member function, remove the first parameter from that function
13329 also. This situation occurs for operator functions where we
13330 locate both a member function (with this pointer) and non-member
13331 operator (with explicit first operand). */
13332 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1))
13334 len--; /* LEN is the number of significant arguments for DECL1 */
13335 args1 = TREE_CHAIN (args1);
13336 if (!DECL_STATIC_FUNCTION_P (decl2))
13337 args2 = TREE_CHAIN (args2);
13339 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2))
13341 args2 = TREE_CHAIN (args2);
13342 if (!DECL_STATIC_FUNCTION_P (decl1))
13345 args1 = TREE_CHAIN (args1);
13349 /* If only one is a conversion operator, they are unordered. */
13350 if (DECL_CONV_FN_P (decl1) != DECL_CONV_FN_P (decl2))
13353 /* Consider the return type for a conversion function */
13354 if (DECL_CONV_FN_P (decl1))
13356 args1 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl1)), args1);
13357 args2 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl2)), args2);
13361 processing_template_decl++;
13365 tree arg1 = TREE_VALUE (args1);
13366 tree arg2 = TREE_VALUE (args2);
13367 int deduce1, deduce2;
13371 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
13372 && TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
13374 /* When both arguments are pack expansions, we need only
13375 unify the patterns themselves. */
13376 arg1 = PACK_EXPANSION_PATTERN (arg1);
13377 arg2 = PACK_EXPANSION_PATTERN (arg2);
13379 /* This is the last comparison we need to do. */
13383 if (TREE_CODE (arg1) == REFERENCE_TYPE)
13385 arg1 = TREE_TYPE (arg1);
13386 quals1 = cp_type_quals (arg1);
13389 if (TREE_CODE (arg2) == REFERENCE_TYPE)
13391 arg2 = TREE_TYPE (arg2);
13392 quals2 = cp_type_quals (arg2);
13395 if ((quals1 < 0) != (quals2 < 0))
13397 /* Only of the args is a reference, see if we should apply
13398 array/function pointer decay to it. This is not part of
13399 DR214, but is, IMHO, consistent with the deduction rules
13400 for the function call itself, and with our earlier
13401 implementation of the underspecified partial ordering
13402 rules. (nathan). */
13405 switch (TREE_CODE (arg1))
13408 arg1 = TREE_TYPE (arg1);
13410 case FUNCTION_TYPE:
13411 arg1 = build_pointer_type (arg1);
13420 switch (TREE_CODE (arg2))
13423 arg2 = TREE_TYPE (arg2);
13425 case FUNCTION_TYPE:
13426 arg2 = build_pointer_type (arg2);
13435 arg1 = TYPE_MAIN_VARIANT (arg1);
13436 arg2 = TYPE_MAIN_VARIANT (arg2);
13438 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION)
13440 int i, len2 = list_length (args2);
13441 tree parmvec = make_tree_vec (1);
13442 tree argvec = make_tree_vec (len2);
13445 /* Setup the parameter vector, which contains only ARG1. */
13446 TREE_VEC_ELT (parmvec, 0) = arg1;
13448 /* Setup the argument vector, which contains the remaining
13450 for (i = 0; i < len2; i++, ta = TREE_CHAIN (ta))
13451 TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
13453 deduce1 = !unify_pack_expansion (tparms1, targs1, parmvec,
13454 argvec, UNIFY_ALLOW_NONE,
13455 /*call_args_p=*/false,
13458 /* We cannot deduce in the other direction, because ARG1 is
13459 a pack expansion but ARG2 is not. */
13462 else if (TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
13464 int i, len1 = list_length (args1);
13465 tree parmvec = make_tree_vec (1);
13466 tree argvec = make_tree_vec (len1);
13469 /* Setup the parameter vector, which contains only ARG1. */
13470 TREE_VEC_ELT (parmvec, 0) = arg2;
13472 /* Setup the argument vector, which contains the remaining
13474 for (i = 0; i < len1; i++, ta = TREE_CHAIN (ta))
13475 TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
13477 deduce2 = !unify_pack_expansion (tparms2, targs2, parmvec,
13478 argvec, UNIFY_ALLOW_NONE,
13479 /*call_args_p=*/false,
13482 /* We cannot deduce in the other direction, because ARG2 is
13483 a pack expansion but ARG1 is not.*/
13489 /* The normal case, where neither argument is a pack
13491 deduce1 = !unify (tparms1, targs1, arg1, arg2, UNIFY_ALLOW_NONE);
13492 deduce2 = !unify (tparms2, targs2, arg2, arg1, UNIFY_ALLOW_NONE);
13499 if (better1 < 0 && better2 < 0)
13500 /* We've failed to deduce something in either direction.
13501 These must be unordered. */
13504 if (deduce1 && deduce2 && quals1 >= 0 && quals2 >= 0)
13506 /* Deduces in both directions, see if quals can
13507 disambiguate. Pretend the worse one failed to deduce. */
13508 if ((quals1 & quals2) == quals2)
13510 if ((quals1 & quals2) == quals1)
13513 if (deduce1 && !deduce2 && !better2)
13515 if (deduce2 && !deduce1 && !better1)
13518 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
13519 || TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
13520 /* We have already processed all of the arguments in our
13521 handing of the pack expansion type. */
13524 args1 = TREE_CHAIN (args1);
13525 args2 = TREE_CHAIN (args2);
13527 /* Stop when an ellipsis is seen. */
13528 if (args1 == NULL_TREE || args2 == NULL_TREE)
13532 processing_template_decl--;
13534 /* All things being equal, if the next argument is a pack expansion
13535 for one function but not for the other, prefer the
13536 non-variadic function. */
13537 if ((better1 > 0) - (better2 > 0) == 0
13538 && args1 && TREE_VALUE (args1)
13539 && args2 && TREE_VALUE (args2))
13541 if (TREE_CODE (TREE_VALUE (args1)) == TYPE_PACK_EXPANSION)
13542 return TREE_CODE (TREE_VALUE (args2)) == TYPE_PACK_EXPANSION ? 0 : -1;
13543 else if (TREE_CODE (TREE_VALUE (args2)) == TYPE_PACK_EXPANSION)
13547 return (better1 > 0) - (better2 > 0);
13550 /* Determine which of two partial specializations is more specialized.
13552 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
13553 to the first partial specialization. The TREE_VALUE is the
13554 innermost set of template parameters for the partial
13555 specialization. PAT2 is similar, but for the second template.
13557 Return 1 if the first partial specialization is more specialized;
13558 -1 if the second is more specialized; 0 if neither is more
13561 See [temp.class.order] for information about determining which of
13562 two templates is more specialized. */
13565 more_specialized_class (tree pat1, tree pat2)
13570 bool any_deductions = false;
13572 tmpl1 = TREE_TYPE (pat1);
13573 tmpl2 = TREE_TYPE (pat2);
13575 /* Just like what happens for functions, if we are ordering between
13576 different class template specializations, we may encounter dependent
13577 types in the arguments, and we need our dependency check functions
13578 to behave correctly. */
13579 ++processing_template_decl;
13580 targs = get_class_bindings (TREE_VALUE (pat1),
13581 CLASSTYPE_TI_ARGS (tmpl1),
13582 CLASSTYPE_TI_ARGS (tmpl2));
13586 any_deductions = true;
13589 targs = get_class_bindings (TREE_VALUE (pat2),
13590 CLASSTYPE_TI_ARGS (tmpl2),
13591 CLASSTYPE_TI_ARGS (tmpl1));
13595 any_deductions = true;
13597 --processing_template_decl;
13599 /* In the case of a tie where at least one of the class templates
13600 has a parameter pack at the end, the template with the most
13601 non-packed parameters wins. */
13604 && (template_args_variadic_p (TREE_PURPOSE (pat1))
13605 || template_args_variadic_p (TREE_PURPOSE (pat2))))
13607 tree args1 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1));
13608 tree args2 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2));
13609 int len1 = TREE_VEC_LENGTH (args1);
13610 int len2 = TREE_VEC_LENGTH (args2);
13612 /* We don't count the pack expansion at the end. */
13613 if (template_args_variadic_p (TREE_PURPOSE (pat1)))
13615 if (template_args_variadic_p (TREE_PURPOSE (pat2)))
13620 else if (len1 < len2)
13627 /* Return the template arguments that will produce the function signature
13628 DECL from the function template FN, with the explicit template
13629 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
13630 also match. Return NULL_TREE if no satisfactory arguments could be
13634 get_bindings (tree fn, tree decl, tree explicit_args, bool check_rettype)
13636 int ntparms = DECL_NTPARMS (fn);
13637 tree targs = make_tree_vec (ntparms);
13639 tree decl_arg_types;
13641 /* Substitute the explicit template arguments into the type of DECL.
13642 The call to fn_type_unification will handle substitution into the
13644 decl_type = TREE_TYPE (decl);
13645 if (explicit_args && uses_template_parms (decl_type))
13648 tree converted_args;
13650 if (DECL_TEMPLATE_INFO (decl))
13651 tmpl = DECL_TI_TEMPLATE (decl);
13653 /* We can get here for some invalid specializations. */
13657 = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
13658 explicit_args, NULL_TREE,
13660 /*require_all_args=*/false,
13661 /*use_default_args=*/false);
13662 if (converted_args == error_mark_node)
13665 decl_type = tsubst (decl_type, converted_args, tf_none, NULL_TREE);
13666 if (decl_type == error_mark_node)
13670 /* Never do unification on the 'this' parameter. */
13671 decl_arg_types = skip_artificial_parms_for (decl,
13672 TYPE_ARG_TYPES (decl_type));
13674 if (fn_type_unification (fn, explicit_args, targs,
13676 (check_rettype || DECL_CONV_FN_P (fn)
13677 ? TREE_TYPE (decl_type) : NULL_TREE),
13678 DEDUCE_EXACT, LOOKUP_NORMAL))
13684 /* Return the innermost template arguments that, when applied to a
13685 template specialization whose innermost template parameters are
13686 TPARMS, and whose specialization arguments are PARMS, yield the
13689 For example, suppose we have:
13691 template <class T, class U> struct S {};
13692 template <class T> struct S<T*, int> {};
13694 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
13695 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
13696 int}. The resulting vector will be {double}, indicating that `T'
13697 is bound to `double'. */
13700 get_class_bindings (tree tparms, tree spec_args, tree args)
13702 int i, ntparms = TREE_VEC_LENGTH (tparms);
13704 tree innermost_deduced_args;
13706 innermost_deduced_args = make_tree_vec (ntparms);
13707 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
13709 deduced_args = copy_node (args);
13710 SET_TMPL_ARGS_LEVEL (deduced_args,
13711 TMPL_ARGS_DEPTH (deduced_args),
13712 innermost_deduced_args);
13715 deduced_args = innermost_deduced_args;
13717 if (unify (tparms, deduced_args,
13718 INNERMOST_TEMPLATE_ARGS (spec_args),
13719 INNERMOST_TEMPLATE_ARGS (args),
13723 for (i = 0; i < ntparms; ++i)
13724 if (! TREE_VEC_ELT (innermost_deduced_args, i))
13727 /* Verify that nondeduced template arguments agree with the type
13728 obtained from argument deduction.
13732 struct A { typedef int X; };
13733 template <class T, class U> struct C {};
13734 template <class T> struct C<T, typename T::X> {};
13736 Then with the instantiation `C<A, int>', we can deduce that
13737 `T' is `A' but unify () does not check whether `typename T::X'
13739 spec_args = tsubst (spec_args, deduced_args, tf_none, NULL_TREE);
13740 if (spec_args == error_mark_node
13741 /* We only need to check the innermost arguments; the other
13742 arguments will always agree. */
13743 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args),
13744 INNERMOST_TEMPLATE_ARGS (args)))
13747 return deduced_args;
13750 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
13751 Return the TREE_LIST node with the most specialized template, if
13752 any. If there is no most specialized template, the error_mark_node
13755 Note that this function does not look at, or modify, the
13756 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
13757 returned is one of the elements of INSTANTIATIONS, callers may
13758 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
13759 and retrieve it from the value returned. */
13762 most_specialized_instantiation (tree templates)
13766 ++processing_template_decl;
13769 for (fn = TREE_CHAIN (templates); fn; fn = TREE_CHAIN (fn))
13773 if (get_bindings (TREE_VALUE (champ),
13774 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
13775 NULL_TREE, /*check_ret=*/false))
13778 if (get_bindings (TREE_VALUE (fn),
13779 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
13780 NULL_TREE, /*check_ret=*/false))
13787 /* Equally specialized, move to next function. If there
13788 is no next function, nothing's most specialized. */
13789 fn = TREE_CHAIN (fn);
13797 /* Now verify that champ is better than everything earlier in the
13798 instantiation list. */
13799 for (fn = templates; fn != champ; fn = TREE_CHAIN (fn))
13800 if (get_bindings (TREE_VALUE (champ),
13801 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
13802 NULL_TREE, /*check_ret=*/false)
13803 || !get_bindings (TREE_VALUE (fn),
13804 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
13805 NULL_TREE, /*check_ret=*/false))
13811 processing_template_decl--;
13814 return error_mark_node;
13819 /* If DECL is a specialization of some template, return the most
13820 general such template. Otherwise, returns NULL_TREE.
13822 For example, given:
13824 template <class T> struct S { template <class U> void f(U); };
13826 if TMPL is `template <class U> void S<int>::f(U)' this will return
13827 the full template. This function will not trace past partial
13828 specializations, however. For example, given in addition:
13830 template <class T> struct S<T*> { template <class U> void f(U); };
13832 if TMPL is `template <class U> void S<int*>::f(U)' this will return
13833 `template <class T> template <class U> S<T*>::f(U)'. */
13836 most_general_template (tree decl)
13838 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
13839 an immediate specialization. */
13840 if (TREE_CODE (decl) == FUNCTION_DECL)
13842 if (DECL_TEMPLATE_INFO (decl)) {
13843 decl = DECL_TI_TEMPLATE (decl);
13845 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
13846 template friend. */
13847 if (TREE_CODE (decl) != TEMPLATE_DECL)
13853 /* Look for more and more general templates. */
13854 while (DECL_TEMPLATE_INFO (decl))
13856 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
13857 (See cp-tree.h for details.) */
13858 if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
13861 if (CLASS_TYPE_P (TREE_TYPE (decl))
13862 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
13865 /* Stop if we run into an explicitly specialized class template. */
13866 if (!DECL_NAMESPACE_SCOPE_P (decl)
13867 && DECL_CONTEXT (decl)
13868 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl)))
13871 decl = DECL_TI_TEMPLATE (decl);
13877 /* Return the most specialized of the class template partial
13878 specializations of TMPL which can produce TYPE, a specialization of
13879 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
13880 a _TYPE node corresponding to the partial specialization, while the
13881 TREE_PURPOSE is the set of template arguments that must be
13882 substituted into the TREE_TYPE in order to generate TYPE.
13884 If the choice of partial specialization is ambiguous, a diagnostic
13885 is issued, and the error_mark_node is returned. If there are no
13886 partial specializations of TMPL matching TYPE, then NULL_TREE is
13890 most_specialized_class (tree type, tree tmpl)
13892 tree list = NULL_TREE;
13898 tree outer_args = NULL_TREE;
13900 tmpl = most_general_template (tmpl);
13901 args = CLASSTYPE_TI_ARGS (type);
13903 /* For determining which partial specialization to use, only the
13904 innermost args are interesting. */
13905 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
13907 outer_args = strip_innermost_template_args (args, 1);
13908 args = INNERMOST_TEMPLATE_ARGS (args);
13911 for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t))
13913 tree partial_spec_args;
13915 tree parms = TREE_VALUE (t);
13917 partial_spec_args = CLASSTYPE_TI_ARGS (TREE_TYPE (t));
13922 ++processing_template_decl;
13924 /* Discard the outer levels of args, and then substitute in the
13925 template args from the enclosing class. */
13926 partial_spec_args = INNERMOST_TEMPLATE_ARGS (partial_spec_args);
13927 partial_spec_args = tsubst_template_args
13928 (partial_spec_args, outer_args, tf_none, NULL_TREE);
13930 /* PARMS already refers to just the innermost parms, but the
13931 template parms in partial_spec_args had their levels lowered
13932 by tsubst, so we need to do the same for the parm list. We
13933 can't just tsubst the TREE_VEC itself, as tsubst wants to
13934 treat a TREE_VEC as an argument vector. */
13935 parms = copy_node (parms);
13936 for (i = TREE_VEC_LENGTH (parms) - 1; i >= 0; --i)
13937 TREE_VEC_ELT (parms, i) =
13938 tsubst (TREE_VEC_ELT (parms, i), outer_args, tf_none, NULL_TREE);
13940 --processing_template_decl;
13942 spec_args = get_class_bindings (parms,
13948 spec_args = add_to_template_args (outer_args, spec_args);
13949 list = tree_cons (spec_args, TREE_VALUE (t), list);
13950 TREE_TYPE (list) = TREE_TYPE (t);
13957 ambiguous_p = false;
13960 t = TREE_CHAIN (t);
13961 for (; t; t = TREE_CHAIN (t))
13963 fate = more_specialized_class (champ, t);
13970 t = TREE_CHAIN (t);
13973 ambiguous_p = true;
13982 for (t = list; t && t != champ; t = TREE_CHAIN (t))
13984 fate = more_specialized_class (champ, t);
13987 ambiguous_p = true;
13994 const char *str = "candidates are:";
13995 error ("ambiguous class template instantiation for %q#T", type);
13996 for (t = list; t; t = TREE_CHAIN (t))
13998 error ("%s %+#T", str, TREE_TYPE (t));
14001 return error_mark_node;
14007 /* Explicitly instantiate DECL. */
14010 do_decl_instantiation (tree decl, tree storage)
14012 tree result = NULL_TREE;
14015 if (!decl || decl == error_mark_node)
14016 /* An error occurred, for which grokdeclarator has already issued
14017 an appropriate message. */
14019 else if (! DECL_LANG_SPECIFIC (decl))
14021 error ("explicit instantiation of non-template %q#D", decl);
14024 else if (TREE_CODE (decl) == VAR_DECL)
14026 /* There is an asymmetry here in the way VAR_DECLs and
14027 FUNCTION_DECLs are handled by grokdeclarator. In the case of
14028 the latter, the DECL we get back will be marked as a
14029 template instantiation, and the appropriate
14030 DECL_TEMPLATE_INFO will be set up. This does not happen for
14031 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
14032 should handle VAR_DECLs as it currently handles
14034 if (!DECL_CLASS_SCOPE_P (decl))
14036 error ("%qD is not a static data member of a class template", decl);
14039 result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false);
14040 if (!result || TREE_CODE (result) != VAR_DECL)
14042 error ("no matching template for %qD found", decl);
14045 if (!same_type_p (TREE_TYPE (result), TREE_TYPE (decl)))
14047 error ("type %qT for explicit instantiation %qD does not match "
14048 "declared type %qT", TREE_TYPE (result), decl,
14053 else if (TREE_CODE (decl) != FUNCTION_DECL)
14055 error ("explicit instantiation of %q#D", decl);
14061 /* Check for various error cases. Note that if the explicit
14062 instantiation is valid the RESULT will currently be marked as an
14063 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
14064 until we get here. */
14066 if (DECL_TEMPLATE_SPECIALIZATION (result))
14068 /* DR 259 [temp.spec].
14070 Both an explicit instantiation and a declaration of an explicit
14071 specialization shall not appear in a program unless the explicit
14072 instantiation follows a declaration of the explicit specialization.
14074 For a given set of template parameters, if an explicit
14075 instantiation of a template appears after a declaration of an
14076 explicit specialization for that template, the explicit
14077 instantiation has no effect. */
14080 else if (DECL_EXPLICIT_INSTANTIATION (result))
14084 No program shall explicitly instantiate any template more
14087 We check DECL_NOT_REALLY_EXTERN so as not to complain when
14088 the first instantiation was `extern' and the second is not,
14089 and EXTERN_P for the opposite case. */
14090 if (DECL_NOT_REALLY_EXTERN (result) && !extern_p)
14091 pedwarn ("duplicate explicit instantiation of %q#D", result);
14092 /* If an "extern" explicit instantiation follows an ordinary
14093 explicit instantiation, the template is instantiated. */
14097 else if (!DECL_IMPLICIT_INSTANTIATION (result))
14099 error ("no matching template for %qD found", result);
14102 else if (!DECL_TEMPLATE_INFO (result))
14104 pedwarn ("explicit instantiation of non-template %q#D", result);
14108 if (storage == NULL_TREE)
14110 else if (storage == ridpointers[(int) RID_EXTERN])
14112 if (pedantic && !in_system_header)
14113 pedwarn ("ISO C++ forbids the use of %<extern%> on explicit "
14118 error ("storage class %qD applied to template instantiation", storage);
14120 check_explicit_instantiation_namespace (result);
14121 mark_decl_instantiated (result, extern_p);
14123 instantiate_decl (result, /*defer_ok=*/1,
14124 /*expl_inst_class_mem_p=*/false);
14128 mark_class_instantiated (tree t, int extern_p)
14130 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
14131 SET_CLASSTYPE_INTERFACE_KNOWN (t);
14132 CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
14133 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
14136 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
14137 rest_of_type_compilation (t, 1);
14141 /* Called from do_type_instantiation through binding_table_foreach to
14142 do recursive instantiation for the type bound in ENTRY. */
14144 bt_instantiate_type_proc (binding_entry entry, void *data)
14146 tree storage = *(tree *) data;
14148 if (IS_AGGR_TYPE (entry->type)
14149 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type)))
14150 do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0);
14153 /* Called from do_type_instantiation to instantiate a member
14154 (a member function or a static member variable) of an
14155 explicitly instantiated class template. */
14157 instantiate_class_member (tree decl, int extern_p)
14159 mark_decl_instantiated (decl, extern_p);
14161 instantiate_decl (decl, /*defer_ok=*/1,
14162 /*expl_inst_class_mem_p=*/true);
14165 /* Perform an explicit instantiation of template class T. STORAGE, if
14166 non-null, is the RID for extern, inline or static. COMPLAIN is
14167 nonzero if this is called from the parser, zero if called recursively,
14168 since the standard is unclear (as detailed below). */
14171 do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
14176 int previous_instantiation_extern_p = 0;
14178 if (TREE_CODE (t) == TYPE_DECL)
14181 if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t))
14183 error ("explicit instantiation of non-template type %qT", t);
14189 if (!COMPLETE_TYPE_P (t))
14191 if (complain & tf_error)
14192 error ("explicit instantiation of %q#T before definition of template",
14197 if (storage != NULL_TREE)
14199 if (pedantic && !in_system_header)
14200 pedwarn("ISO C++ forbids the use of %qE on explicit instantiations",
14203 if (storage == ridpointers[(int) RID_INLINE])
14205 else if (storage == ridpointers[(int) RID_EXTERN])
14207 else if (storage == ridpointers[(int) RID_STATIC])
14211 error ("storage class %qD applied to template instantiation",
14217 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
14219 /* DR 259 [temp.spec].
14221 Both an explicit instantiation and a declaration of an explicit
14222 specialization shall not appear in a program unless the explicit
14223 instantiation follows a declaration of the explicit specialization.
14225 For a given set of template parameters, if an explicit
14226 instantiation of a template appears after a declaration of an
14227 explicit specialization for that template, the explicit
14228 instantiation has no effect. */
14231 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t))
14235 No program shall explicitly instantiate any template more
14238 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
14239 instantiation was `extern'. If EXTERN_P then the second is.
14240 These cases are OK. */
14241 previous_instantiation_extern_p = CLASSTYPE_INTERFACE_ONLY (t);
14243 if (!previous_instantiation_extern_p && !extern_p
14244 && (complain & tf_error))
14245 pedwarn ("duplicate explicit instantiation of %q#T", t);
14247 /* If we've already instantiated the template, just return now. */
14248 if (!CLASSTYPE_INTERFACE_ONLY (t))
14252 check_explicit_instantiation_namespace (TYPE_NAME (t));
14253 mark_class_instantiated (t, extern_p);
14261 /* In contrast to implicit instantiation, where only the
14262 declarations, and not the definitions, of members are
14263 instantiated, we have here:
14267 The explicit instantiation of a class template specialization
14268 implies the instantiation of all of its members not
14269 previously explicitly specialized in the translation unit
14270 containing the explicit instantiation.
14272 Of course, we can't instantiate member template classes, since
14273 we don't have any arguments for them. Note that the standard
14274 is unclear on whether the instantiation of the members are
14275 *explicit* instantiations or not. However, the most natural
14276 interpretation is that it should be an explicit instantiation. */
14279 for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp))
14280 if (TREE_CODE (tmp) == FUNCTION_DECL
14281 && DECL_TEMPLATE_INSTANTIATION (tmp))
14282 instantiate_class_member (tmp, extern_p);
14284 for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp))
14285 if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp))
14286 instantiate_class_member (tmp, extern_p);
14288 if (CLASSTYPE_NESTED_UTDS (t))
14289 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t),
14290 bt_instantiate_type_proc, &storage);
14294 /* Given a function DECL, which is a specialization of TMPL, modify
14295 DECL to be a re-instantiation of TMPL with the same template
14296 arguments. TMPL should be the template into which tsubst'ing
14297 should occur for DECL, not the most general template.
14299 One reason for doing this is a scenario like this:
14302 void f(const T&, int i);
14304 void g() { f(3, 7); }
14307 void f(const T& t, const int i) { }
14309 Note that when the template is first instantiated, with
14310 instantiate_template, the resulting DECL will have no name for the
14311 first parameter, and the wrong type for the second. So, when we go
14312 to instantiate the DECL, we regenerate it. */
14315 regenerate_decl_from_template (tree decl, tree tmpl)
14317 /* The arguments used to instantiate DECL, from the most general
14322 args = DECL_TI_ARGS (decl);
14323 code_pattern = DECL_TEMPLATE_RESULT (tmpl);
14325 /* Make sure that we can see identifiers, and compute access
14327 push_access_scope (decl);
14329 if (TREE_CODE (decl) == FUNCTION_DECL)
14337 args_depth = TMPL_ARGS_DEPTH (args);
14338 parms_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
14339 if (args_depth > parms_depth)
14340 args = get_innermost_template_args (args, parms_depth);
14342 specs = tsubst_exception_specification (TREE_TYPE (code_pattern),
14343 args, tf_error, NULL_TREE);
14345 TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl),
14348 /* Merge parameter declarations. */
14349 decl_parm = skip_artificial_parms_for (decl,
14350 DECL_ARGUMENTS (decl));
14352 = skip_artificial_parms_for (code_pattern,
14353 DECL_ARGUMENTS (code_pattern));
14354 while (decl_parm && !FUNCTION_PARAMETER_PACK_P (pattern_parm))
14359 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
14360 DECL_NAME (decl_parm) = DECL_NAME (pattern_parm);
14361 parm_type = tsubst (TREE_TYPE (pattern_parm), args, tf_error,
14363 parm_type = type_decays_to (parm_type);
14364 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
14365 TREE_TYPE (decl_parm) = parm_type;
14366 attributes = DECL_ATTRIBUTES (pattern_parm);
14367 if (DECL_ATTRIBUTES (decl_parm) != attributes)
14369 DECL_ATTRIBUTES (decl_parm) = attributes;
14370 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
14372 decl_parm = TREE_CHAIN (decl_parm);
14373 pattern_parm = TREE_CHAIN (pattern_parm);
14375 /* Merge any parameters that match with the function parameter
14377 if (pattern_parm && FUNCTION_PARAMETER_PACK_P (pattern_parm))
14380 tree expanded_types;
14381 /* Expand the TYPE_PACK_EXPANSION that provides the types for
14382 the parameters in this function parameter pack. */
14383 expanded_types = tsubst_pack_expansion (TREE_TYPE (pattern_parm),
14384 args, tf_error, NULL_TREE);
14385 len = TREE_VEC_LENGTH (expanded_types);
14386 for (i = 0; i < len; i++)
14391 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
14392 /* Rename the parameter to include the index. */
14393 DECL_NAME (decl_parm) =
14394 make_ith_pack_parameter_name (DECL_NAME (pattern_parm), i);
14395 parm_type = TREE_VEC_ELT (expanded_types, i);
14396 parm_type = type_decays_to (parm_type);
14397 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
14398 TREE_TYPE (decl_parm) = parm_type;
14399 attributes = DECL_ATTRIBUTES (pattern_parm);
14400 if (DECL_ATTRIBUTES (decl_parm) != attributes)
14402 DECL_ATTRIBUTES (decl_parm) = attributes;
14403 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
14405 decl_parm = TREE_CHAIN (decl_parm);
14408 /* Merge additional specifiers from the CODE_PATTERN. */
14409 if (DECL_DECLARED_INLINE_P (code_pattern)
14410 && !DECL_DECLARED_INLINE_P (decl))
14411 DECL_DECLARED_INLINE_P (decl) = 1;
14412 if (DECL_INLINE (code_pattern) && !DECL_INLINE (decl))
14413 DECL_INLINE (decl) = 1;
14415 else if (TREE_CODE (decl) == VAR_DECL)
14416 DECL_INITIAL (decl) =
14417 tsubst_expr (DECL_INITIAL (code_pattern), args,
14418 tf_error, DECL_TI_TEMPLATE (decl),
14419 /*integral_constant_expression_p=*/false);
14421 gcc_unreachable ();
14423 pop_access_scope (decl);
14426 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
14427 substituted to get DECL. */
14430 template_for_substitution (tree decl)
14432 tree tmpl = DECL_TI_TEMPLATE (decl);
14434 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
14435 for the instantiation. This is not always the most general
14436 template. Consider, for example:
14439 struct S { template <class U> void f();
14440 template <> void f<int>(); };
14442 and an instantiation of S<double>::f<int>. We want TD to be the
14443 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
14444 while (/* An instantiation cannot have a definition, so we need a
14445 more general template. */
14446 DECL_TEMPLATE_INSTANTIATION (tmpl)
14447 /* We must also deal with friend templates. Given:
14449 template <class T> struct S {
14450 template <class U> friend void f() {};
14453 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
14454 so far as the language is concerned, but that's still
14455 where we get the pattern for the instantiation from. On
14456 other hand, if the definition comes outside the class, say:
14458 template <class T> struct S {
14459 template <class U> friend void f();
14461 template <class U> friend void f() {}
14463 we don't need to look any further. That's what the check for
14464 DECL_INITIAL is for. */
14465 || (TREE_CODE (decl) == FUNCTION_DECL
14466 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl)
14467 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl))))
14469 /* The present template, TD, should not be a definition. If it
14470 were a definition, we should be using it! Note that we
14471 cannot restructure the loop to just keep going until we find
14472 a template with a definition, since that might go too far if
14473 a specialization was declared, but not defined. */
14474 gcc_assert (TREE_CODE (decl) != VAR_DECL
14475 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl)));
14477 /* Fetch the more general template. */
14478 tmpl = DECL_TI_TEMPLATE (tmpl);
14484 /* Produce the definition of D, a _DECL generated from a template. If
14485 DEFER_OK is nonzero, then we don't have to actually do the
14486 instantiation now; we just have to do it sometime. Normally it is
14487 an error if this is an explicit instantiation but D is undefined.
14488 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
14489 explicitly instantiated class template. */
14492 instantiate_decl (tree d, int defer_ok,
14493 bool expl_inst_class_mem_p)
14495 tree tmpl = DECL_TI_TEMPLATE (d);
14502 bool pattern_defined;
14504 location_t saved_loc = input_location;
14505 int saved_in_system_header = in_system_header;
14508 /* This function should only be used to instantiate templates for
14509 functions and static member variables. */
14510 gcc_assert (TREE_CODE (d) == FUNCTION_DECL
14511 || TREE_CODE (d) == VAR_DECL);
14513 /* Variables are never deferred; if instantiation is required, they
14514 are instantiated right away. That allows for better code in the
14515 case that an expression refers to the value of the variable --
14516 if the variable has a constant value the referring expression can
14517 take advantage of that fact. */
14518 if (TREE_CODE (d) == VAR_DECL)
14521 /* Don't instantiate cloned functions. Instead, instantiate the
14522 functions they cloned. */
14523 if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d))
14524 d = DECL_CLONED_FUNCTION (d);
14526 if (DECL_TEMPLATE_INSTANTIATED (d))
14527 /* D has already been instantiated. It might seem reasonable to
14528 check whether or not D is an explicit instantiation, and, if so,
14529 stop here. But when an explicit instantiation is deferred
14530 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
14531 is set, even though we still need to do the instantiation. */
14534 /* If we already have a specialization of this declaration, then
14535 there's no reason to instantiate it. Note that
14536 retrieve_specialization gives us both instantiations and
14537 specializations, so we must explicitly check
14538 DECL_TEMPLATE_SPECIALIZATION. */
14539 gen_tmpl = most_general_template (tmpl);
14540 gen_args = DECL_TI_ARGS (d);
14541 spec = retrieve_specialization (gen_tmpl, gen_args,
14542 /*class_specializations_p=*/false);
14543 if (spec != NULL_TREE && DECL_TEMPLATE_SPECIALIZATION (spec))
14546 /* This needs to happen before any tsubsting. */
14547 if (! push_tinst_level (d))
14550 timevar_push (TV_PARSE);
14552 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
14553 for the instantiation. */
14554 td = template_for_substitution (d);
14555 code_pattern = DECL_TEMPLATE_RESULT (td);
14557 /* We should never be trying to instantiate a member of a class
14558 template or partial specialization. */
14559 gcc_assert (d != code_pattern);
14561 if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d))
14562 || DECL_TEMPLATE_SPECIALIZATION (td))
14563 /* In the case of a friend template whose definition is provided
14564 outside the class, we may have too many arguments. Drop the
14565 ones we don't need. The same is true for specializations. */
14566 args = get_innermost_template_args
14567 (gen_args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td)));
14571 if (TREE_CODE (d) == FUNCTION_DECL)
14572 pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE);
14574 pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
14576 /* We may be in the middle of deferred access check. Disable it now. */
14577 push_deferring_access_checks (dk_no_deferred);
14579 /* Unless an explicit instantiation directive has already determined
14580 the linkage of D, remember that a definition is available for
14582 if (pattern_defined
14583 && !DECL_INTERFACE_KNOWN (d)
14584 && !DECL_NOT_REALLY_EXTERN (d))
14585 mark_definable (d);
14587 input_location = DECL_SOURCE_LOCATION (d);
14588 in_system_header = DECL_IN_SYSTEM_HEADER (d);
14590 /* If D is a member of an explicitly instantiated class template,
14591 and no definition is available, treat it like an implicit
14593 if (!pattern_defined && expl_inst_class_mem_p
14594 && DECL_EXPLICIT_INSTANTIATION (d))
14596 DECL_NOT_REALLY_EXTERN (d) = 0;
14597 DECL_INTERFACE_KNOWN (d) = 0;
14598 SET_DECL_IMPLICIT_INSTANTIATION (d);
14603 /* Recheck the substitutions to obtain any warning messages
14604 about ignoring cv qualifiers. */
14605 tree gen = DECL_TEMPLATE_RESULT (gen_tmpl);
14606 tree type = TREE_TYPE (gen);
14608 /* Make sure that we can see identifiers, and compute access
14609 correctly. D is already the target FUNCTION_DECL with the
14611 push_access_scope (d);
14613 if (TREE_CODE (gen) == FUNCTION_DECL)
14615 tsubst (DECL_ARGUMENTS (gen), gen_args, tf_warning_or_error, d);
14616 tsubst_exception_specification (type, gen_args, tf_warning_or_error,
14618 /* Don't simply tsubst the function type, as that will give
14619 duplicate warnings about poor parameter qualifications.
14620 The function arguments are the same as the decl_arguments
14621 without the top level cv qualifiers. */
14622 type = TREE_TYPE (type);
14624 tsubst (type, gen_args, tf_warning_or_error, d);
14626 pop_access_scope (d);
14629 /* Check to see whether we know that this template will be
14630 instantiated in some other file, as with "extern template"
14632 external_p = (DECL_INTERFACE_KNOWN (d) && DECL_REALLY_EXTERN (d));
14633 /* In general, we do not instantiate such templates... */
14635 /* ... but we instantiate inline functions so that we can inline
14637 && ! (TREE_CODE (d) == FUNCTION_DECL && DECL_INLINE (d))
14638 /* ... we instantiate static data members whose values are
14639 needed in integral constant expressions. */
14640 && ! (TREE_CODE (d) == VAR_DECL
14641 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (d)))
14643 /* Defer all other templates, unless we have been explicitly
14644 forbidden from doing so. */
14645 if (/* If there is no definition, we cannot instantiate the
14648 /* If it's OK to postpone instantiation, do so. */
14650 /* If this is a static data member that will be defined
14651 elsewhere, we don't want to instantiate the entire data
14652 member, but we do want to instantiate the initializer so that
14653 we can substitute that elsewhere. */
14654 || (external_p && TREE_CODE (d) == VAR_DECL))
14656 /* The definition of the static data member is now required so
14657 we must substitute the initializer. */
14658 if (TREE_CODE (d) == VAR_DECL
14659 && !DECL_INITIAL (d)
14660 && DECL_INITIAL (code_pattern))
14665 ns = decl_namespace_context (d);
14666 push_nested_namespace (ns);
14667 push_nested_class (DECL_CONTEXT (d));
14668 init = tsubst_expr (DECL_INITIAL (code_pattern),
14670 tf_warning_or_error, NULL_TREE,
14671 /*integral_constant_expression_p=*/false);
14672 cp_finish_decl (d, init, /*init_const_expr_p=*/false,
14673 /*asmspec_tree=*/NULL_TREE,
14674 LOOKUP_ONLYCONVERTING);
14675 pop_nested_class ();
14676 pop_nested_namespace (ns);
14679 /* We restore the source position here because it's used by
14680 add_pending_template. */
14681 input_location = saved_loc;
14683 if (at_eof && !pattern_defined
14684 && DECL_EXPLICIT_INSTANTIATION (d))
14687 The definition of a non-exported function template, a
14688 non-exported member function template, or a non-exported
14689 member function or static data member of a class template
14690 shall be present in every translation unit in which it is
14691 explicitly instantiated. */
14693 ("explicit instantiation of %qD but no definition available", d);
14695 /* ??? Historically, we have instantiated inline functions, even
14696 when marked as "extern template". */
14697 if (!(external_p && TREE_CODE (d) == VAR_DECL))
14698 add_pending_template (d);
14701 /* Tell the repository that D is available in this translation unit
14702 -- and see if it is supposed to be instantiated here. */
14703 if (TREE_PUBLIC (d) && !DECL_REALLY_EXTERN (d) && !repo_emit_p (d))
14705 /* In a PCH file, despite the fact that the repository hasn't
14706 requested instantiation in the PCH it is still possible that
14707 an instantiation will be required in a file that includes the
14710 add_pending_template (d);
14711 /* Instantiate inline functions so that the inliner can do its
14712 job, even though we'll not be emitting a copy of this
14714 if (!(TREE_CODE (d) == FUNCTION_DECL
14715 && flag_inline_trees
14716 && DECL_DECLARED_INLINE_P (d)))
14720 need_push = !cfun || !global_bindings_p ();
14722 push_to_top_level ();
14724 /* Mark D as instantiated so that recursive calls to
14725 instantiate_decl do not try to instantiate it again. */
14726 DECL_TEMPLATE_INSTANTIATED (d) = 1;
14728 /* Regenerate the declaration in case the template has been modified
14729 by a subsequent redeclaration. */
14730 regenerate_decl_from_template (d, td);
14732 /* We already set the file and line above. Reset them now in case
14733 they changed as a result of calling regenerate_decl_from_template. */
14734 input_location = DECL_SOURCE_LOCATION (d);
14736 if (TREE_CODE (d) == VAR_DECL)
14740 /* Clear out DECL_RTL; whatever was there before may not be right
14741 since we've reset the type of the declaration. */
14742 SET_DECL_RTL (d, NULL_RTX);
14743 DECL_IN_AGGR_P (d) = 0;
14745 /* The initializer is placed in DECL_INITIAL by
14746 regenerate_decl_from_template. Pull it out so that
14747 finish_decl can process it. */
14748 init = DECL_INITIAL (d);
14749 DECL_INITIAL (d) = NULL_TREE;
14750 DECL_INITIALIZED_P (d) = 0;
14752 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
14753 initializer. That function will defer actual emission until
14754 we have a chance to determine linkage. */
14755 DECL_EXTERNAL (d) = 0;
14757 /* Enter the scope of D so that access-checking works correctly. */
14758 push_nested_class (DECL_CONTEXT (d));
14759 finish_decl (d, init, NULL_TREE);
14760 pop_nested_class ();
14762 else if (TREE_CODE (d) == FUNCTION_DECL)
14764 htab_t saved_local_specializations;
14769 /* Save away the current list, in case we are instantiating one
14770 template from within the body of another. */
14771 saved_local_specializations = local_specializations;
14773 /* Set up the list of local specializations. */
14774 local_specializations = htab_create (37,
14775 hash_local_specialization,
14776 eq_local_specializations,
14779 /* Set up context. */
14780 start_preparsed_function (d, NULL_TREE, SF_PRE_PARSED);
14782 /* Create substitution entries for the parameters. */
14783 subst_decl = DECL_TEMPLATE_RESULT (template_for_substitution (d));
14784 tmpl_parm = DECL_ARGUMENTS (subst_decl);
14785 spec_parm = DECL_ARGUMENTS (d);
14786 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d))
14788 register_local_specialization (spec_parm, tmpl_parm);
14789 spec_parm = skip_artificial_parms_for (d, spec_parm);
14790 tmpl_parm = skip_artificial_parms_for (subst_decl, tmpl_parm);
14792 while (tmpl_parm && !FUNCTION_PARAMETER_PACK_P (tmpl_parm))
14794 register_local_specialization (spec_parm, tmpl_parm);
14795 tmpl_parm = TREE_CHAIN (tmpl_parm);
14796 spec_parm = TREE_CHAIN (spec_parm);
14798 if (tmpl_parm && FUNCTION_PARAMETER_PACK_P (tmpl_parm))
14800 /* Collect all of the extra "packed" parameters into an
14804 tree argpack = make_node (NONTYPE_ARGUMENT_PACK);
14805 tree argtypepack = make_node (TYPE_ARGUMENT_PACK);
14809 /* Count how many parameters remain. */
14810 for (t = spec_parm; t; t = TREE_CHAIN (t))
14813 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
14814 parmvec = make_tree_vec (len);
14815 parmtypevec = make_tree_vec (len);
14816 for(i = 0; i < len; i++, spec_parm = TREE_CHAIN (spec_parm))
14818 TREE_VEC_ELT (parmvec, i) = spec_parm;
14819 TREE_VEC_ELT (parmtypevec, i) = TREE_TYPE (spec_parm);
14822 /* Build the argument packs. */
14823 SET_ARGUMENT_PACK_ARGS (argpack, parmvec);
14824 SET_ARGUMENT_PACK_ARGS (argtypepack, parmtypevec);
14825 TREE_TYPE (argpack) = argtypepack;
14827 /* Register the (value) argument pack as a specialization of
14828 TMPL_PARM, then move on. */
14829 register_local_specialization (argpack, tmpl_parm);
14830 tmpl_parm = TREE_CHAIN (tmpl_parm);
14832 gcc_assert (!spec_parm);
14834 /* Substitute into the body of the function. */
14835 tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
14836 tf_warning_or_error, tmpl,
14837 /*integral_constant_expression_p=*/false);
14839 /* Set the current input_location to the end of the function
14840 so that finish_function knows where we are. */
14841 input_location = DECL_STRUCT_FUNCTION (code_pattern)->function_end_locus;
14843 /* We don't need the local specializations any more. */
14844 htab_delete (local_specializations);
14845 local_specializations = saved_local_specializations;
14847 /* Finish the function. */
14848 d = finish_function (0);
14849 expand_or_defer_fn (d);
14852 /* We're not deferring instantiation any more. */
14853 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
14856 pop_from_top_level ();
14859 input_location = saved_loc;
14860 in_system_header = saved_in_system_header;
14861 pop_deferring_access_checks ();
14862 pop_tinst_level ();
14864 timevar_pop (TV_PARSE);
14869 /* Run through the list of templates that we wish we could
14870 instantiate, and instantiate any we can. RETRIES is the
14871 number of times we retry pending template instantiation. */
14874 instantiate_pending_templates (int retries)
14877 location_t saved_loc = input_location;
14878 int saved_in_system_header = in_system_header;
14880 /* Instantiating templates may trigger vtable generation. This in turn
14881 may require further template instantiations. We place a limit here
14882 to avoid infinite loop. */
14883 if (pending_templates && retries >= max_tinst_depth)
14885 tree decl = pending_templates->tinst->decl;
14887 error ("template instantiation depth exceeds maximum of %d"
14888 " instantiating %q+D, possibly from virtual table generation"
14889 " (use -ftemplate-depth-NN to increase the maximum)",
14890 max_tinst_depth, decl);
14891 if (TREE_CODE (decl) == FUNCTION_DECL)
14892 /* Pretend that we defined it. */
14893 DECL_INITIAL (decl) = error_mark_node;
14899 struct pending_template **t = &pending_templates;
14900 struct pending_template *last = NULL;
14904 tree instantiation = reopen_tinst_level ((*t)->tinst);
14905 bool complete = false;
14907 if (TYPE_P (instantiation))
14911 if (!COMPLETE_TYPE_P (instantiation))
14913 instantiate_class_template (instantiation);
14914 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
14915 for (fn = TYPE_METHODS (instantiation);
14917 fn = TREE_CHAIN (fn))
14918 if (! DECL_ARTIFICIAL (fn))
14919 instantiate_decl (fn,
14921 /*expl_inst_class_mem_p=*/false);
14922 if (COMPLETE_TYPE_P (instantiation))
14926 complete = COMPLETE_TYPE_P (instantiation);
14930 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation)
14931 && !DECL_TEMPLATE_INSTANTIATED (instantiation))
14934 = instantiate_decl (instantiation,
14936 /*expl_inst_class_mem_p=*/false);
14937 if (DECL_TEMPLATE_INSTANTIATED (instantiation))
14941 complete = (DECL_TEMPLATE_SPECIALIZATION (instantiation)
14942 || DECL_TEMPLATE_INSTANTIATED (instantiation));
14946 /* If INSTANTIATION has been instantiated, then we don't
14947 need to consider it again in the future. */
14955 current_tinst_level = NULL;
14957 last_pending_template = last;
14959 while (reconsider);
14961 input_location = saved_loc;
14962 in_system_header = saved_in_system_header;
14965 /* Substitute ARGVEC into T, which is a list of initializers for
14966 either base class or a non-static data member. The TREE_PURPOSEs
14967 are DECLs, and the TREE_VALUEs are the initializer values. Used by
14968 instantiate_decl. */
14971 tsubst_initializer_list (tree t, tree argvec)
14973 tree inits = NULL_TREE;
14975 for (; t; t = TREE_CHAIN (t))
14979 tree expanded_bases = NULL_TREE;
14980 tree expanded_arguments = NULL_TREE;
14983 if (TREE_CODE (TREE_PURPOSE (t)) == TYPE_PACK_EXPANSION)
14988 /* Expand the base class expansion type into separate base
14990 expanded_bases = tsubst_pack_expansion (TREE_PURPOSE (t), argvec,
14991 tf_warning_or_error,
14993 if (expanded_bases == error_mark_node)
14996 /* We'll be building separate TREE_LISTs of arguments for
14998 len = TREE_VEC_LENGTH (expanded_bases);
14999 expanded_arguments = make_tree_vec (len);
15000 for (i = 0; i < len; i++)
15001 TREE_VEC_ELT (expanded_arguments, i) = NULL_TREE;
15003 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
15004 expand each argument in the TREE_VALUE of t. */
15005 expr = make_node (EXPR_PACK_EXPANSION);
15006 PACK_EXPANSION_PARAMETER_PACKS (expr) =
15007 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t));
15009 /* Substitute parameter packs into each argument in the
15011 in_base_initializer = 1;
15012 for (arg = TREE_VALUE (t); arg; arg = TREE_CHAIN (arg))
15014 tree expanded_exprs;
15016 /* Expand the argument. */
15017 SET_PACK_EXPANSION_PATTERN (expr, TREE_VALUE (arg));
15018 expanded_exprs = tsubst_pack_expansion (expr, argvec,
15019 tf_warning_or_error,
15022 /* Prepend each of the expanded expressions to the
15023 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
15024 for (i = 0; i < len; i++)
15026 TREE_VEC_ELT (expanded_arguments, i) =
15027 tree_cons (NULL_TREE, TREE_VEC_ELT (expanded_exprs, i),
15028 TREE_VEC_ELT (expanded_arguments, i));
15031 in_base_initializer = 0;
15033 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
15034 since we built them backwards. */
15035 for (i = 0; i < len; i++)
15037 TREE_VEC_ELT (expanded_arguments, i) =
15038 nreverse (TREE_VEC_ELT (expanded_arguments, i));
15042 for (i = 0; i < len; ++i)
15044 if (expanded_bases)
15046 decl = TREE_VEC_ELT (expanded_bases, i);
15047 decl = expand_member_init (decl);
15048 init = TREE_VEC_ELT (expanded_arguments, i);
15052 decl = tsubst_copy (TREE_PURPOSE (t), argvec,
15053 tf_warning_or_error, NULL_TREE);
15055 decl = expand_member_init (decl);
15056 if (decl && !DECL_P (decl))
15057 in_base_initializer = 1;
15059 init = tsubst_expr (TREE_VALUE (t), argvec,
15060 tf_warning_or_error, NULL_TREE,
15061 /*integral_constant_expression_p=*/false);
15062 in_base_initializer = 0;
15067 init = build_tree_list (decl, init);
15068 TREE_CHAIN (init) = inits;
15076 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
15079 set_current_access_from_decl (tree decl)
15081 if (TREE_PRIVATE (decl))
15082 current_access_specifier = access_private_node;
15083 else if (TREE_PROTECTED (decl))
15084 current_access_specifier = access_protected_node;
15086 current_access_specifier = access_public_node;
15089 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
15090 is the instantiation (which should have been created with
15091 start_enum) and ARGS are the template arguments to use. */
15094 tsubst_enum (tree tag, tree newtag, tree args)
15098 for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
15103 decl = TREE_VALUE (e);
15104 /* Note that in a template enum, the TREE_VALUE is the
15105 CONST_DECL, not the corresponding INTEGER_CST. */
15106 value = tsubst_expr (DECL_INITIAL (decl),
15107 args, tf_warning_or_error, NULL_TREE,
15108 /*integral_constant_expression_p=*/true);
15110 /* Give this enumeration constant the correct access. */
15111 set_current_access_from_decl (decl);
15113 /* Actually build the enumerator itself. */
15114 build_enumerator (DECL_NAME (decl), value, newtag);
15117 finish_enum (newtag);
15118 DECL_SOURCE_LOCATION (TYPE_NAME (newtag))
15119 = DECL_SOURCE_LOCATION (TYPE_NAME (tag));
15122 /* DECL is a FUNCTION_DECL that is a template specialization. Return
15123 its type -- but without substituting the innermost set of template
15124 arguments. So, innermost set of template parameters will appear in
15128 get_mostly_instantiated_function_type (tree decl)
15136 tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
15137 targs = DECL_TI_ARGS (decl);
15138 tparms = DECL_TEMPLATE_PARMS (tmpl);
15139 parm_depth = TMPL_PARMS_DEPTH (tparms);
15141 /* There should be as many levels of arguments as there are levels
15143 gcc_assert (parm_depth == TMPL_ARGS_DEPTH (targs));
15145 fn_type = TREE_TYPE (tmpl);
15147 if (parm_depth == 1)
15148 /* No substitution is necessary. */
15152 int i, save_access_control;
15155 /* Replace the innermost level of the TARGS with NULL_TREEs to
15156 let tsubst know not to substitute for those parameters. */
15157 partial_args = make_tree_vec (TREE_VEC_LENGTH (targs));
15158 for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i)
15159 SET_TMPL_ARGS_LEVEL (partial_args, i,
15160 TMPL_ARGS_LEVEL (targs, i));
15161 SET_TMPL_ARGS_LEVEL (partial_args,
15162 TMPL_ARGS_DEPTH (targs),
15163 make_tree_vec (DECL_NTPARMS (tmpl)));
15165 /* Disable access control as this function is used only during
15167 save_access_control = flag_access_control;
15168 flag_access_control = 0;
15170 ++processing_template_decl;
15171 /* Now, do the (partial) substitution to figure out the
15172 appropriate function type. */
15173 fn_type = tsubst (fn_type, partial_args, tf_error, NULL_TREE);
15174 --processing_template_decl;
15176 /* Substitute into the template parameters to obtain the real
15177 innermost set of parameters. This step is important if the
15178 innermost set of template parameters contains value
15179 parameters whose types depend on outer template parameters. */
15180 TREE_VEC_LENGTH (partial_args)--;
15181 tparms = tsubst_template_parms (tparms, partial_args, tf_error);
15183 flag_access_control = save_access_control;
15189 /* Return truthvalue if we're processing a template different from
15190 the last one involved in diagnostics. */
15192 problematic_instantiation_changed (void)
15194 return last_template_error_tick != tinst_level_tick;
15197 /* Remember current template involved in diagnostics. */
15199 record_last_problematic_instantiation (void)
15201 last_template_error_tick = tinst_level_tick;
15204 struct tinst_level *
15205 current_instantiation (void)
15207 return current_tinst_level;
15210 /* [temp.param] Check that template non-type parm TYPE is of an allowable
15211 type. Return zero for ok, nonzero for disallowed. Issue error and
15212 warning messages under control of COMPLAIN. */
15215 invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain)
15217 if (INTEGRAL_TYPE_P (type))
15219 else if (POINTER_TYPE_P (type))
15221 else if (TYPE_PTR_TO_MEMBER_P (type))
15223 else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
15225 else if (TREE_CODE (type) == TYPENAME_TYPE)
15228 if (complain & tf_error)
15229 error ("%q#T is not a valid type for a template constant parameter", type);
15233 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
15234 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
15237 dependent_type_p_r (tree type)
15243 A type is dependent if it is:
15245 -- a template parameter. Template template parameters are types
15246 for us (since TYPE_P holds true for them) so we handle
15248 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
15249 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
15251 /* -- a qualified-id with a nested-name-specifier which contains a
15252 class-name that names a dependent type or whose unqualified-id
15253 names a dependent type. */
15254 if (TREE_CODE (type) == TYPENAME_TYPE)
15256 /* -- a cv-qualified type where the cv-unqualified type is
15258 type = TYPE_MAIN_VARIANT (type);
15259 /* -- a compound type constructed from any dependent type. */
15260 if (TYPE_PTR_TO_MEMBER_P (type))
15261 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type))
15262 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
15264 else if (TREE_CODE (type) == POINTER_TYPE
15265 || TREE_CODE (type) == REFERENCE_TYPE)
15266 return dependent_type_p (TREE_TYPE (type));
15267 else if (TREE_CODE (type) == FUNCTION_TYPE
15268 || TREE_CODE (type) == METHOD_TYPE)
15272 if (dependent_type_p (TREE_TYPE (type)))
15274 for (arg_type = TYPE_ARG_TYPES (type);
15276 arg_type = TREE_CHAIN (arg_type))
15277 if (dependent_type_p (TREE_VALUE (arg_type)))
15281 /* -- an array type constructed from any dependent type or whose
15282 size is specified by a constant expression that is
15283 value-dependent. */
15284 if (TREE_CODE (type) == ARRAY_TYPE)
15286 if (TYPE_DOMAIN (type)
15287 && ((value_dependent_expression_p
15288 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
15289 || (type_dependent_expression_p
15290 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))))
15292 return dependent_type_p (TREE_TYPE (type));
15295 /* -- a template-id in which either the template name is a template
15297 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
15299 /* ... or any of the template arguments is a dependent type or
15300 an expression that is type-dependent or value-dependent. */
15301 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
15302 && (any_dependent_template_arguments_p
15303 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
15306 /* All TYPEOF_TYPEs and DECLTYPE_TYPEs are dependent; if the
15307 argument of the `typeof' expression is not type-dependent, then
15308 it should already been have resolved. */
15309 if (TREE_CODE (type) == TYPEOF_TYPE
15310 || TREE_CODE (type) == DECLTYPE_TYPE)
15313 /* A template argument pack is dependent if any of its packed
15315 if (TREE_CODE (type) == TYPE_ARGUMENT_PACK)
15317 tree args = ARGUMENT_PACK_ARGS (type);
15318 int i, len = TREE_VEC_LENGTH (args);
15319 for (i = 0; i < len; ++i)
15320 if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
15324 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
15325 be template parameters. */
15326 if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
15329 /* The standard does not specifically mention types that are local
15330 to template functions or local classes, but they should be
15331 considered dependent too. For example:
15333 template <int I> void f() {
15338 The size of `E' cannot be known until the value of `I' has been
15339 determined. Therefore, `E' must be considered dependent. */
15340 scope = TYPE_CONTEXT (type);
15341 if (scope && TYPE_P (scope))
15342 return dependent_type_p (scope);
15343 else if (scope && TREE_CODE (scope) == FUNCTION_DECL)
15344 return type_dependent_expression_p (scope);
15346 /* Other types are non-dependent. */
15350 /* Returns TRUE if TYPE is dependent, in the sense of
15351 [temp.dep.type]. */
15354 dependent_type_p (tree type)
15356 /* If there are no template parameters in scope, then there can't be
15357 any dependent types. */
15358 if (!processing_template_decl)
15360 /* If we are not processing a template, then nobody should be
15361 providing us with a dependent type. */
15363 gcc_assert (TREE_CODE (type) != TEMPLATE_TYPE_PARM);
15367 /* If the type is NULL, we have not computed a type for the entity
15368 in question; in that case, the type is dependent. */
15372 /* Erroneous types can be considered non-dependent. */
15373 if (type == error_mark_node)
15376 /* If we have not already computed the appropriate value for TYPE,
15378 if (!TYPE_DEPENDENT_P_VALID (type))
15380 TYPE_DEPENDENT_P (type) = dependent_type_p_r (type);
15381 TYPE_DEPENDENT_P_VALID (type) = 1;
15384 return TYPE_DEPENDENT_P (type);
15387 /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
15390 dependent_scope_ref_p (tree expression, bool criterion (tree))
15395 gcc_assert (TREE_CODE (expression) == SCOPE_REF);
15397 if (!TYPE_P (TREE_OPERAND (expression, 0)))
15400 scope = TREE_OPERAND (expression, 0);
15401 name = TREE_OPERAND (expression, 1);
15405 An id-expression is type-dependent if it contains a
15406 nested-name-specifier that contains a class-name that names a
15408 /* The suggested resolution to Core Issue 2 implies that if the
15409 qualifying type is the current class, then we must peek
15412 && currently_open_class (scope)
15413 && !criterion (name))
15415 if (dependent_type_p (scope))
15421 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
15422 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
15426 value_dependent_expression_p (tree expression)
15428 if (!processing_template_decl)
15431 /* A name declared with a dependent type. */
15432 if (DECL_P (expression) && type_dependent_expression_p (expression))
15435 switch (TREE_CODE (expression))
15437 case IDENTIFIER_NODE:
15438 /* A name that has not been looked up -- must be dependent. */
15441 case TEMPLATE_PARM_INDEX:
15442 /* A non-type template parm. */
15446 /* A non-type template parm. */
15447 if (DECL_TEMPLATE_PARM_P (expression))
15452 /* A constant with integral or enumeration type and is initialized
15453 with an expression that is value-dependent. */
15454 if (DECL_INITIAL (expression)
15455 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression))
15456 && value_dependent_expression_p (DECL_INITIAL (expression)))
15460 case DYNAMIC_CAST_EXPR:
15461 case STATIC_CAST_EXPR:
15462 case CONST_CAST_EXPR:
15463 case REINTERPRET_CAST_EXPR:
15465 /* These expressions are value-dependent if the type to which
15466 the cast occurs is dependent or the expression being casted
15467 is value-dependent. */
15469 tree type = TREE_TYPE (expression);
15471 if (dependent_type_p (type))
15474 /* A functional cast has a list of operands. */
15475 expression = TREE_OPERAND (expression, 0);
15478 /* If there are no operands, it must be an expression such
15479 as "int()". This should not happen for aggregate types
15480 because it would form non-constant expressions. */
15481 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
15486 if (TREE_CODE (expression) == TREE_LIST)
15487 return any_value_dependent_elements_p (expression);
15489 return value_dependent_expression_p (expression);
15494 /* A `sizeof' expression is value-dependent if the operand is
15495 type-dependent or is a pack expansion. */
15496 expression = TREE_OPERAND (expression, 0);
15497 if (PACK_EXPANSION_P (expression))
15499 else if (TYPE_P (expression))
15500 return dependent_type_p (expression);
15501 return type_dependent_expression_p (expression);
15504 return dependent_scope_ref_p (expression, value_dependent_expression_p);
15506 case COMPONENT_REF:
15507 return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
15508 || value_dependent_expression_p (TREE_OPERAND (expression, 1)));
15511 /* A CALL_EXPR may appear in a constant expression if it is a
15512 call to a builtin function, e.g., __builtin_constant_p. All
15513 such calls are value-dependent. */
15516 case NONTYPE_ARGUMENT_PACK:
15517 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
15518 is value-dependent. */
15520 tree values = ARGUMENT_PACK_ARGS (expression);
15521 int i, len = TREE_VEC_LENGTH (values);
15523 for (i = 0; i < len; ++i)
15524 if (value_dependent_expression_p (TREE_VEC_ELT (values, i)))
15532 tree type2 = TRAIT_EXPR_TYPE2 (expression);
15533 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression))
15534 || (type2 ? dependent_type_p (type2) : false));
15538 return ((value_dependent_expression_p (TREE_OPERAND (expression, 0)))
15539 || (value_dependent_expression_p (TREE_OPERAND (expression, 2))));
15542 /* A constant expression is value-dependent if any subexpression is
15543 value-dependent. */
15544 switch (TREE_CODE_CLASS (TREE_CODE (expression)))
15546 case tcc_reference:
15548 return (value_dependent_expression_p
15549 (TREE_OPERAND (expression, 0)));
15551 case tcc_comparison:
15553 return ((value_dependent_expression_p
15554 (TREE_OPERAND (expression, 0)))
15555 || (value_dependent_expression_p
15556 (TREE_OPERAND (expression, 1))));
15558 case tcc_expression:
15562 for (i = 0; i < TREE_OPERAND_LENGTH (expression); ++i)
15563 /* In some cases, some of the operands may be missing.
15564 (For example, in the case of PREDECREMENT_EXPR, the
15565 amount to increment by may be missing.) That doesn't
15566 make the expression dependent. */
15567 if (TREE_OPERAND (expression, i)
15568 && (value_dependent_expression_p
15569 (TREE_OPERAND (expression, i))))
15579 /* The expression is not value-dependent. */
15583 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
15584 [temp.dep.expr]. */
15587 type_dependent_expression_p (tree expression)
15589 if (!processing_template_decl)
15592 if (expression == error_mark_node)
15595 /* An unresolved name is always dependent. */
15596 if (TREE_CODE (expression) == IDENTIFIER_NODE
15597 || TREE_CODE (expression) == USING_DECL)
15600 /* Some expression forms are never type-dependent. */
15601 if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR
15602 || TREE_CODE (expression) == SIZEOF_EXPR
15603 || TREE_CODE (expression) == ALIGNOF_EXPR
15604 || TREE_CODE (expression) == TRAIT_EXPR
15605 || TREE_CODE (expression) == TYPEID_EXPR
15606 || TREE_CODE (expression) == DELETE_EXPR
15607 || TREE_CODE (expression) == VEC_DELETE_EXPR
15608 || TREE_CODE (expression) == THROW_EXPR)
15611 /* The types of these expressions depends only on the type to which
15612 the cast occurs. */
15613 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
15614 || TREE_CODE (expression) == STATIC_CAST_EXPR
15615 || TREE_CODE (expression) == CONST_CAST_EXPR
15616 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
15617 || TREE_CODE (expression) == CAST_EXPR)
15618 return dependent_type_p (TREE_TYPE (expression));
15620 /* The types of these expressions depends only on the type created
15621 by the expression. */
15622 if (TREE_CODE (expression) == NEW_EXPR
15623 || TREE_CODE (expression) == VEC_NEW_EXPR)
15625 /* For NEW_EXPR tree nodes created inside a template, either
15626 the object type itself or a TREE_LIST may appear as the
15628 tree type = TREE_OPERAND (expression, 1);
15629 if (TREE_CODE (type) == TREE_LIST)
15630 /* This is an array type. We need to check array dimensions
15632 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type)))
15633 || value_dependent_expression_p
15634 (TREE_OPERAND (TREE_VALUE (type), 1));
15636 return dependent_type_p (type);
15639 if (TREE_CODE (expression) == SCOPE_REF
15640 && dependent_scope_ref_p (expression,
15641 type_dependent_expression_p))
15644 if (TREE_CODE (expression) == FUNCTION_DECL
15645 && DECL_LANG_SPECIFIC (expression)
15646 && DECL_TEMPLATE_INFO (expression)
15647 && (any_dependent_template_arguments_p
15648 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
15651 if (TREE_CODE (expression) == TEMPLATE_DECL
15652 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression))
15655 if (TREE_CODE (expression) == STMT_EXPR)
15656 expression = stmt_expr_value_expr (expression);
15658 if (TREE_TYPE (expression) == unknown_type_node)
15660 if (TREE_CODE (expression) == ADDR_EXPR)
15661 return type_dependent_expression_p (TREE_OPERAND (expression, 0));
15662 if (TREE_CODE (expression) == COMPONENT_REF
15663 || TREE_CODE (expression) == OFFSET_REF)
15665 if (type_dependent_expression_p (TREE_OPERAND (expression, 0)))
15667 expression = TREE_OPERAND (expression, 1);
15668 if (TREE_CODE (expression) == IDENTIFIER_NODE)
15671 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
15672 if (TREE_CODE (expression) == SCOPE_REF)
15675 if (TREE_CODE (expression) == BASELINK)
15676 expression = BASELINK_FUNCTIONS (expression);
15678 if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
15680 if (any_dependent_template_arguments_p
15681 (TREE_OPERAND (expression, 1)))
15683 expression = TREE_OPERAND (expression, 0);
15685 gcc_assert (TREE_CODE (expression) == OVERLOAD
15686 || TREE_CODE (expression) == FUNCTION_DECL);
15690 if (type_dependent_expression_p (OVL_CURRENT (expression)))
15692 expression = OVL_NEXT (expression);
15697 gcc_assert (TREE_CODE (expression) != TYPE_DECL);
15699 return (dependent_type_p (TREE_TYPE (expression)));
15702 /* Returns TRUE if ARGS (a TREE_LIST of arguments to a function call)
15703 contains a type-dependent expression. */
15706 any_type_dependent_arguments_p (const_tree args)
15710 tree arg = TREE_VALUE (args);
15712 if (type_dependent_expression_p (arg))
15714 args = TREE_CHAIN (args);
15719 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
15720 expressions) contains any value-dependent expressions. */
15723 any_value_dependent_elements_p (const_tree list)
15725 for (; list; list = TREE_CHAIN (list))
15726 if (value_dependent_expression_p (TREE_VALUE (list)))
15732 /* Returns TRUE if the ARG (a template argument) is dependent. */
15735 dependent_template_arg_p (tree arg)
15737 if (!processing_template_decl)
15740 if (TREE_CODE (arg) == TEMPLATE_DECL
15741 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
15742 return dependent_template_p (arg);
15743 else if (ARGUMENT_PACK_P (arg))
15745 tree args = ARGUMENT_PACK_ARGS (arg);
15746 int i, len = TREE_VEC_LENGTH (args);
15747 for (i = 0; i < len; ++i)
15749 if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
15755 else if (TYPE_P (arg))
15756 return dependent_type_p (arg);
15758 return (type_dependent_expression_p (arg)
15759 || value_dependent_expression_p (arg));
15762 /* Returns true if ARGS (a collection of template arguments) contains
15763 any types that require structural equality testing. */
15766 any_template_arguments_need_structural_equality_p (tree args)
15773 if (args == error_mark_node)
15776 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
15778 tree level = TMPL_ARGS_LEVEL (args, i + 1);
15779 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
15781 tree arg = TREE_VEC_ELT (level, j);
15782 tree packed_args = NULL_TREE;
15785 if (ARGUMENT_PACK_P (arg))
15787 /* Look inside the argument pack. */
15788 packed_args = ARGUMENT_PACK_ARGS (arg);
15789 len = TREE_VEC_LENGTH (packed_args);
15792 for (k = 0; k < len; ++k)
15795 arg = TREE_VEC_ELT (packed_args, k);
15797 if (error_operand_p (arg))
15799 else if (TREE_CODE (arg) == TEMPLATE_DECL
15800 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
15802 else if (TYPE_P (arg) && TYPE_STRUCTURAL_EQUALITY_P (arg))
15804 else if (!TYPE_P (arg) && TREE_TYPE (arg)
15805 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg)))
15814 /* Returns true if ARGS (a collection of template arguments) contains
15815 any dependent arguments. */
15818 any_dependent_template_arguments_p (const_tree args)
15825 if (args == error_mark_node)
15828 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
15830 const_tree level = TMPL_ARGS_LEVEL (args, i + 1);
15831 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
15832 if (dependent_template_arg_p (TREE_VEC_ELT (level, j)))
15839 /* Returns TRUE if the template TMPL is dependent. */
15842 dependent_template_p (tree tmpl)
15844 if (TREE_CODE (tmpl) == OVERLOAD)
15848 if (dependent_template_p (OVL_FUNCTION (tmpl)))
15850 tmpl = OVL_CHAIN (tmpl);
15855 /* Template template parameters are dependent. */
15856 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
15857 || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
15859 /* So are names that have not been looked up. */
15860 if (TREE_CODE (tmpl) == SCOPE_REF
15861 || TREE_CODE (tmpl) == IDENTIFIER_NODE)
15863 /* So are member templates of dependent classes. */
15864 if (TYPE_P (CP_DECL_CONTEXT (tmpl)))
15865 return dependent_type_p (DECL_CONTEXT (tmpl));
15869 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
15872 dependent_template_id_p (tree tmpl, tree args)
15874 return (dependent_template_p (tmpl)
15875 || any_dependent_template_arguments_p (args));
15878 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
15879 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
15880 no such TYPE can be found. Note that this function peers inside
15881 uninstantiated templates and therefore should be used only in
15882 extremely limited situations. ONLY_CURRENT_P restricts this
15883 peering to the currently open classes hierarchy (which is required
15884 when comparing types). */
15887 resolve_typename_type (tree type, bool only_current_p)
15896 gcc_assert (TREE_CODE (type) == TYPENAME_TYPE);
15898 scope = TYPE_CONTEXT (type);
15899 name = TYPE_IDENTIFIER (type);
15901 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
15902 it first before we can figure out what NAME refers to. */
15903 if (TREE_CODE (scope) == TYPENAME_TYPE)
15904 scope = resolve_typename_type (scope, only_current_p);
15905 /* If we don't know what SCOPE refers to, then we cannot resolve the
15907 if (TREE_CODE (scope) == TYPENAME_TYPE)
15909 /* If the SCOPE is a template type parameter, we have no way of
15910 resolving the name. */
15911 if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
15913 /* If the SCOPE is not the current instantiation, there's no reason
15914 to look inside it. */
15915 if (only_current_p && !currently_open_class (scope))
15917 /* If SCOPE isn't the template itself, it will not have a valid
15918 TYPE_FIELDS list. */
15919 if (same_type_p (scope, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope)))
15920 /* scope is either the template itself or a compatible instantiation
15921 like X<T>, so look up the name in the original template. */
15922 scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope);
15924 /* scope is a partial instantiation, so we can't do the lookup or we
15925 will lose the template arguments. */
15927 /* Enter the SCOPE so that name lookup will be resolved as if we
15928 were in the class definition. In particular, SCOPE will no
15929 longer be considered a dependent type. */
15930 pushed_scope = push_scope (scope);
15931 /* Look up the declaration. */
15932 decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true);
15934 result = NULL_TREE;
15936 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
15937 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
15940 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE
15941 && TREE_CODE (decl) == TYPE_DECL)
15943 result = TREE_TYPE (decl);
15944 if (result == error_mark_node)
15945 result = NULL_TREE;
15947 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR
15948 && DECL_CLASS_TEMPLATE_P (decl))
15952 /* Obtain the template and the arguments. */
15953 tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0);
15954 args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1);
15955 /* Instantiate the template. */
15956 result = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE,
15957 /*entering_scope=*/0,
15958 tf_error | tf_user);
15959 if (result == error_mark_node)
15960 result = NULL_TREE;
15963 /* Leave the SCOPE. */
15965 pop_scope (pushed_scope);
15967 /* If we failed to resolve it, return the original typename. */
15971 /* If lookup found a typename type, resolve that too. */
15972 if (TREE_CODE (result) == TYPENAME_TYPE && !TYPENAME_IS_RESOLVING_P (result))
15974 /* Ill-formed programs can cause infinite recursion here, so we
15975 must catch that. */
15976 TYPENAME_IS_RESOLVING_P (type) = 1;
15977 result = resolve_typename_type (result, only_current_p);
15978 TYPENAME_IS_RESOLVING_P (type) = 0;
15981 /* Qualify the resulting type. */
15982 quals = cp_type_quals (type);
15984 result = cp_build_qualified_type (result, cp_type_quals (result) | quals);
15989 /* EXPR is an expression which is not type-dependent. Return a proxy
15990 for EXPR that can be used to compute the types of larger
15991 expressions containing EXPR. */
15994 build_non_dependent_expr (tree expr)
15998 /* Preserve null pointer constants so that the type of things like
15999 "p == 0" where "p" is a pointer can be determined. */
16000 if (null_ptr_cst_p (expr))
16002 /* Preserve OVERLOADs; the functions must be available to resolve
16005 if (TREE_CODE (inner_expr) == STMT_EXPR)
16006 inner_expr = stmt_expr_value_expr (inner_expr);
16007 if (TREE_CODE (inner_expr) == ADDR_EXPR)
16008 inner_expr = TREE_OPERAND (inner_expr, 0);
16009 if (TREE_CODE (inner_expr) == COMPONENT_REF)
16010 inner_expr = TREE_OPERAND (inner_expr, 1);
16011 if (is_overloaded_fn (inner_expr)
16012 || TREE_CODE (inner_expr) == OFFSET_REF)
16014 /* There is no need to return a proxy for a variable. */
16015 if (TREE_CODE (expr) == VAR_DECL)
16017 /* Preserve string constants; conversions from string constants to
16018 "char *" are allowed, even though normally a "const char *"
16019 cannot be used to initialize a "char *". */
16020 if (TREE_CODE (expr) == STRING_CST)
16022 /* Preserve arithmetic constants, as an optimization -- there is no
16023 reason to create a new node. */
16024 if (TREE_CODE (expr) == INTEGER_CST || TREE_CODE (expr) == REAL_CST)
16026 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
16027 There is at least one place where we want to know that a
16028 particular expression is a throw-expression: when checking a ?:
16029 expression, there are special rules if the second or third
16030 argument is a throw-expression. */
16031 if (TREE_CODE (expr) == THROW_EXPR)
16034 if (TREE_CODE (expr) == COND_EXPR)
16035 return build3 (COND_EXPR,
16037 TREE_OPERAND (expr, 0),
16038 (TREE_OPERAND (expr, 1)
16039 ? build_non_dependent_expr (TREE_OPERAND (expr, 1))
16040 : build_non_dependent_expr (TREE_OPERAND (expr, 0))),
16041 build_non_dependent_expr (TREE_OPERAND (expr, 2)));
16042 if (TREE_CODE (expr) == COMPOUND_EXPR
16043 && !COMPOUND_EXPR_OVERLOADED (expr))
16044 return build2 (COMPOUND_EXPR,
16046 TREE_OPERAND (expr, 0),
16047 build_non_dependent_expr (TREE_OPERAND (expr, 1)));
16049 /* If the type is unknown, it can't really be non-dependent */
16050 gcc_assert (TREE_TYPE (expr) != unknown_type_node);
16052 /* Otherwise, build a NON_DEPENDENT_EXPR.
16054 REFERENCE_TYPEs are not stripped for expressions in templates
16055 because doing so would play havoc with mangling. Consider, for
16058 template <typename T> void f<T& g>() { g(); }
16060 In the body of "f", the expression for "g" will have
16061 REFERENCE_TYPE, even though the standard says that it should
16062 not. The reason is that we must preserve the syntactic form of
16063 the expression so that mangling (say) "f<g>" inside the body of
16064 "f" works out correctly. Therefore, the REFERENCE_TYPE is
16066 return build1 (NON_DEPENDENT_EXPR, non_reference (TREE_TYPE (expr)), expr);
16069 /* ARGS is a TREE_LIST of expressions as arguments to a function call.
16070 Return a new TREE_LIST with the various arguments replaced with
16071 equivalent non-dependent expressions. */
16074 build_non_dependent_args (tree args)
16079 new_args = NULL_TREE;
16080 for (a = args; a; a = TREE_CHAIN (a))
16081 new_args = tree_cons (NULL_TREE,
16082 build_non_dependent_expr (TREE_VALUE (a)),
16084 return nreverse (new_args);
16087 #include "gt-cp-pt.h"