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);
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_pack_r. */
2423 struct find_parameter_pack_data
2425 tree* parameter_packs;
2426 struct pointer_set_t *visited;
2429 /* Identifies all of the argument packs that occur in a template
2430 argument and appends them to the TREE_LIST inside DATA, which is a
2431 find_parameter_pack_data structure. This is a subroutine of
2432 make_pack_expansion and uses_parameter_packs. */
2434 find_parameter_packs_r (tree *tp, int *walk_subtrees, void* data)
2437 struct find_parameter_pack_data* ppd =
2438 (struct find_parameter_pack_data*)data;
2442 tree context = TYPE_CONTEXT (t);
2443 cp_walk_tree (&context, &find_parameter_packs_r, ppd, ppd->visited);
2446 /* This switch statement will return immediately if we don't find a
2448 switch (TREE_CODE (t))
2450 case TEMPLATE_PARM_INDEX:
2451 if (TEMPLATE_PARM_PARAMETER_PACK (t))
2455 case BOUND_TEMPLATE_TEMPLATE_PARM:
2456 /* Check the template arguments. */
2457 cp_walk_tree (&TYPE_TI_ARGS (t), &find_parameter_packs_r, ppd,
2460 /* Dig out the underlying TEMPLATE_TEMPLATE_PARM. */
2461 t = TYPE_TI_TEMPLATE (t);
2462 if (DECL_P (t) && TREE_TYPE (t))
2468 case TEMPLATE_TYPE_PARM:
2469 case TEMPLATE_TEMPLATE_PARM:
2470 if (TEMPLATE_TYPE_PARAMETER_PACK (t))
2475 if (FUNCTION_PARAMETER_PACK_P (t))
2477 /* We don't want to walk into the type of a PARM_DECL,
2478 because we don't want to see the type parameter pack.*/
2485 if (TYPE_PTRMEMFUNC_P (t))
2491 if (TYPE_TEMPLATE_INFO (t))
2493 tree args = TREE_VALUE (TYPE_TEMPLATE_INFO (t));
2494 cp_walk_tree (&args, &find_parameter_packs_r, ppd, ppd->visited);
2501 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)
2502 && TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
2509 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t), &find_parameter_packs_r,
2515 case TYPE_PACK_EXPANSION:
2516 case EXPR_PACK_EXPANSION:
2521 cp_walk_tree (&TYPE_MAX_VALUE (t), &find_parameter_packs_r,
2530 /* Add this parameter pack to the list. */
2531 *ppd->parameter_packs = tree_cons (NULL_TREE, t, *ppd->parameter_packs);
2536 /* Determines if the expression or type T uses any parameter packs. */
2538 uses_parameter_packs (tree t)
2540 tree parameter_packs = NULL_TREE;
2541 struct find_parameter_pack_data ppd;
2542 ppd.parameter_packs = ¶meter_packs;
2543 ppd.visited = pointer_set_create ();
2544 cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
2545 pointer_set_destroy (ppd.visited);
2546 return parameter_packs != NULL_TREE;
2549 /* Turn ARG, which may be an expression, type, or a TREE_LIST
2550 representation a base-class initializer into a parameter pack
2551 expansion. If all goes well, the resulting node will be an
2552 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
2555 make_pack_expansion (tree arg)
2558 tree parameter_packs = NULL_TREE;
2559 bool for_types = false;
2560 struct find_parameter_pack_data ppd;
2562 if (!arg || arg == error_mark_node)
2565 if (TREE_CODE (arg) == TREE_LIST)
2567 /* The only time we will see a TREE_LIST here is for a base
2568 class initializer. In this case, the TREE_PURPOSE will be a
2569 _TYPE node (representing the base class expansion we're
2570 initializing) and the TREE_VALUE will be a TREE_LIST
2571 containing the initialization arguments.
2573 The resulting expansion looks somewhat different from most
2574 expansions. Rather than returning just one _EXPANSION, we
2575 return a TREE_LIST whose TREE_PURPOSE is a
2576 TYPE_PACK_EXPANSION containing the bases that will be
2577 initialized. The TREE_VALUE will be identical to the
2578 original TREE_VALUE, which is a list of arguments that will
2579 be passed to each base. We do not introduce any new pack
2580 expansion nodes into the TREE_VALUE (although it is possible
2581 that some already exist), because the TREE_PURPOSE and
2582 TREE_VALUE all need to be expanded together with the same
2583 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
2584 resulting TREE_PURPOSE will mention the parameter packs in
2585 both the bases and the arguments to the bases. */
2588 tree parameter_packs = NULL_TREE;
2590 /* Determine which parameter packs will be used by the base
2592 ppd.visited = pointer_set_create ();
2593 ppd.parameter_packs = ¶meter_packs;
2594 cp_walk_tree (&TREE_PURPOSE (arg), &find_parameter_packs_r,
2597 if (parameter_packs == NULL_TREE)
2599 error ("base initializer expansion %<%T%> contains no parameter packs", arg);
2600 pointer_set_destroy (ppd.visited);
2601 return error_mark_node;
2604 if (TREE_VALUE (arg) != void_type_node)
2606 /* Collect the sets of parameter packs used in each of the
2607 initialization arguments. */
2608 for (value = TREE_VALUE (arg); value; value = TREE_CHAIN (value))
2610 /* Determine which parameter packs will be expanded in this
2612 cp_walk_tree (&TREE_VALUE (value), &find_parameter_packs_r,
2617 pointer_set_destroy (ppd.visited);
2619 /* Create the pack expansion type for the base type. */
2620 purpose = make_node (TYPE_PACK_EXPANSION);
2621 SET_PACK_EXPANSION_PATTERN (purpose, TREE_PURPOSE (arg));
2622 PACK_EXPANSION_PARAMETER_PACKS (purpose) = parameter_packs;
2624 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
2625 they will rarely be compared to anything. */
2626 SET_TYPE_STRUCTURAL_EQUALITY (purpose);
2628 return tree_cons (purpose, TREE_VALUE (arg), NULL_TREE);
2631 if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
2634 /* Build the PACK_EXPANSION_* node. */
2635 result = make_node (for_types ? TYPE_PACK_EXPANSION : EXPR_PACK_EXPANSION);
2636 SET_PACK_EXPANSION_PATTERN (result, arg);
2637 if (TREE_CODE (result) == EXPR_PACK_EXPANSION)
2639 /* Propagate type and const-expression information. */
2640 TREE_TYPE (result) = TREE_TYPE (arg);
2641 TREE_CONSTANT (result) = TREE_CONSTANT (arg);
2644 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
2645 they will rarely be compared to anything. */
2646 SET_TYPE_STRUCTURAL_EQUALITY (result);
2648 /* Determine which parameter packs will be expanded. */
2649 ppd.parameter_packs = ¶meter_packs;
2650 ppd.visited = pointer_set_create ();
2651 cp_walk_tree (&arg, &find_parameter_packs_r, &ppd, ppd.visited);
2652 pointer_set_destroy (ppd.visited);
2654 /* Make sure we found some parameter packs. */
2655 if (parameter_packs == NULL_TREE)
2658 error ("expansion pattern %<%T%> contains no argument packs", arg);
2660 error ("expansion pattern %<%E%> contains no argument packs", arg);
2661 return error_mark_node;
2663 PACK_EXPANSION_PARAMETER_PACKS (result) = parameter_packs;
2668 /* Checks T for any "bare" parameter packs, which have not yet been
2669 expanded, and issues an error if any are found. This operation can
2670 only be done on full expressions or types (e.g., an expression
2671 statement, "if" condition, etc.), because we could have expressions like:
2673 foo(f(g(h(args)))...)
2675 where "args" is a parameter pack. check_for_bare_parameter_packs
2676 should not be called for the subexpressions args, h(args),
2677 g(h(args)), or f(g(h(args))), because we would produce erroneous
2680 Returns TRUE if there were no bare parameter packs, returns FALSE
2681 (and emits an error) if there were bare parameter packs.*/
2683 check_for_bare_parameter_packs (tree t)
2685 tree parameter_packs = NULL_TREE;
2686 struct find_parameter_pack_data ppd;
2688 if (!processing_template_decl || !t || t == error_mark_node)
2691 if (TREE_CODE (t) == TYPE_DECL)
2694 ppd.parameter_packs = ¶meter_packs;
2695 ppd.visited = pointer_set_create ();
2696 cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
2697 pointer_set_destroy (ppd.visited);
2699 if (parameter_packs)
2701 error ("parameter packs not expanded with `...':");
2702 while (parameter_packs)
2704 tree pack = TREE_VALUE (parameter_packs);
2705 tree name = NULL_TREE;
2707 if (TREE_CODE (pack) == TEMPLATE_TYPE_PARM
2708 || TREE_CODE (pack) == TEMPLATE_TEMPLATE_PARM)
2709 name = TYPE_NAME (pack);
2710 else if (TREE_CODE (pack) == TEMPLATE_PARM_INDEX)
2711 name = DECL_NAME (TEMPLATE_PARM_DECL (pack));
2713 name = DECL_NAME (pack);
2714 inform (" %qD", name);
2716 parameter_packs = TREE_CHAIN (parameter_packs);
2725 /* Expand any parameter packs that occur in the template arguments in
2728 expand_template_argument_pack (tree args)
2730 tree result_args = NULL_TREE;
2731 int in_arg, out_arg = 0, nargs = args ? TREE_VEC_LENGTH (args) : 0;
2732 int num_result_args = -1;
2734 /* First, determine if we need to expand anything, and the number of
2735 slots we'll need. */
2736 for (in_arg = 0; in_arg < nargs; ++in_arg)
2738 tree arg = TREE_VEC_ELT (args, in_arg);
2739 if (ARGUMENT_PACK_P (arg))
2741 int num_packed = TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg));
2742 if (num_result_args < 0)
2743 num_result_args = in_arg + num_packed;
2745 num_result_args += num_packed;
2749 if (num_result_args >= 0)
2754 /* If no expansion is necessary, we're done. */
2755 if (num_result_args < 0)
2758 /* Expand arguments. */
2759 result_args = make_tree_vec (num_result_args);
2760 for (in_arg = 0; in_arg < nargs; ++in_arg)
2762 tree arg = TREE_VEC_ELT (args, in_arg);
2763 if (ARGUMENT_PACK_P (arg))
2765 tree packed = ARGUMENT_PACK_ARGS (arg);
2766 int i, num_packed = TREE_VEC_LENGTH (packed);
2767 for (i = 0; i < num_packed; ++i, ++out_arg)
2768 TREE_VEC_ELT (result_args, out_arg) = TREE_VEC_ELT(packed, i);
2772 TREE_VEC_ELT (result_args, out_arg) = arg;
2780 /* Complain if DECL shadows a template parameter.
2782 [temp.local]: A template-parameter shall not be redeclared within its
2783 scope (including nested scopes). */
2786 check_template_shadow (tree decl)
2790 /* If we're not in a template, we can't possibly shadow a template
2792 if (!current_template_parms)
2795 /* Figure out what we're shadowing. */
2796 if (TREE_CODE (decl) == OVERLOAD)
2797 decl = OVL_CURRENT (decl);
2798 olddecl = innermost_non_namespace_value (DECL_NAME (decl));
2800 /* If there's no previous binding for this name, we're not shadowing
2801 anything, let alone a template parameter. */
2805 /* If we're not shadowing a template parameter, we're done. Note
2806 that OLDDECL might be an OVERLOAD (or perhaps even an
2807 ERROR_MARK), so we can't just blithely assume it to be a _DECL
2809 if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
2812 /* We check for decl != olddecl to avoid bogus errors for using a
2813 name inside a class. We check TPFI to avoid duplicate errors for
2814 inline member templates. */
2816 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms))
2819 error ("declaration of %q+#D", decl);
2820 error (" shadows template parm %q+#D", olddecl);
2823 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
2824 ORIG_LEVEL, DECL, and TYPE. */
2827 build_template_parm_index (int index,
2833 tree t = make_node (TEMPLATE_PARM_INDEX);
2834 TEMPLATE_PARM_IDX (t) = index;
2835 TEMPLATE_PARM_LEVEL (t) = level;
2836 TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
2837 TEMPLATE_PARM_DECL (t) = decl;
2838 TREE_TYPE (t) = type;
2839 TREE_CONSTANT (t) = TREE_CONSTANT (decl);
2840 TREE_INVARIANT (t) = TREE_INVARIANT (decl);
2841 TREE_READONLY (t) = TREE_READONLY (decl);
2846 /* Find the canonical type parameter for the given template type
2847 parameter. Returns the canonical type parameter, which may be TYPE
2848 if no such parameter existed. */
2850 canonical_type_parameter (tree type)
2853 int idx = TEMPLATE_TYPE_IDX (type);
2854 if (!canonical_template_parms)
2855 canonical_template_parms = VEC_alloc (tree, gc, idx+1);
2857 while (VEC_length (tree, canonical_template_parms) <= (unsigned)idx)
2858 VEC_safe_push (tree, gc, canonical_template_parms, NULL_TREE);
2860 list = VEC_index (tree, canonical_template_parms, idx);
2861 while (list && !comptypes (type, TREE_VALUE (list), COMPARE_STRUCTURAL))
2862 list = TREE_CHAIN (list);
2865 return TREE_VALUE (list);
2868 VEC_replace(tree, canonical_template_parms, idx,
2869 tree_cons (NULL_TREE, type,
2870 VEC_index (tree, canonical_template_parms, idx)));
2875 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
2876 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
2877 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
2878 new one is created. */
2881 reduce_template_parm_level (tree index, tree type, int levels)
2883 if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
2884 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
2885 != TEMPLATE_PARM_LEVEL (index) - levels))
2887 tree orig_decl = TEMPLATE_PARM_DECL (index);
2890 decl = build_decl (TREE_CODE (orig_decl), DECL_NAME (orig_decl), type);
2891 TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl);
2892 TREE_INVARIANT (decl) = TREE_INVARIANT (orig_decl);
2893 TREE_READONLY (decl) = TREE_READONLY (orig_decl);
2894 DECL_ARTIFICIAL (decl) = 1;
2895 SET_DECL_TEMPLATE_PARM_P (decl);
2897 t = build_template_parm_index (TEMPLATE_PARM_IDX (index),
2898 TEMPLATE_PARM_LEVEL (index) - levels,
2899 TEMPLATE_PARM_ORIG_LEVEL (index),
2901 TEMPLATE_PARM_DESCENDANTS (index) = t;
2902 TEMPLATE_PARM_PARAMETER_PACK (t)
2903 = TEMPLATE_PARM_PARAMETER_PACK (index);
2905 /* Template template parameters need this. */
2906 if (TREE_CODE (decl) != CONST_DECL)
2907 DECL_TEMPLATE_PARMS (decl)
2908 = DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index));
2911 return TEMPLATE_PARM_DESCENDANTS (index);
2914 /* Process information from new template parameter PARM and append it to the
2915 LIST being built. This new parameter is a non-type parameter iff
2916 IS_NON_TYPE is true. This new parameter is a parameter
2917 pack iff IS_PARAMETER_PACK is true. */
2920 process_template_parm (tree list, tree parm, bool is_non_type,
2921 bool is_parameter_pack)
2928 gcc_assert (TREE_CODE (parm) == TREE_LIST);
2929 defval = TREE_PURPOSE (parm);
2933 tree p = tree_last (list);
2935 if (p && TREE_VALUE (p) != error_mark_node)
2938 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
2939 idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
2941 idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
2951 parm = TREE_VALUE (parm);
2953 SET_DECL_TEMPLATE_PARM_P (parm);
2955 if (TREE_TYPE (parm) == error_mark_node)
2957 err_parm_list = build_tree_list (defval, parm);
2958 TREE_VALUE (err_parm_list) = error_mark_node;
2959 return chainon (list, err_parm_list);
2965 The top-level cv-qualifiers on the template-parameter are
2966 ignored when determining its type. */
2967 TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
2968 if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
2970 err_parm_list = build_tree_list (defval, parm);
2971 TREE_VALUE (err_parm_list) = error_mark_node;
2972 return chainon (list, err_parm_list);
2975 if (uses_parameter_packs (TREE_TYPE (parm)) && !is_parameter_pack)
2977 /* This template parameter is not a parameter pack, but it
2978 should be. Complain about "bare" parameter packs. */
2979 check_for_bare_parameter_packs (TREE_TYPE (parm));
2981 /* Recover by calling this a parameter pack. */
2982 is_parameter_pack = true;
2986 /* A template parameter is not modifiable. */
2987 TREE_CONSTANT (parm) = 1;
2988 TREE_INVARIANT (parm) = 1;
2989 TREE_READONLY (parm) = 1;
2990 decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
2991 TREE_CONSTANT (decl) = 1;
2992 TREE_INVARIANT (decl) = 1;
2993 TREE_READONLY (decl) = 1;
2994 DECL_INITIAL (parm) = DECL_INITIAL (decl)
2995 = build_template_parm_index (idx, processing_template_decl,
2996 processing_template_decl,
2997 decl, TREE_TYPE (parm));
2999 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm))
3000 = is_parameter_pack;
3005 parm = TREE_VALUE (TREE_VALUE (parm));
3007 if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
3009 t = make_aggr_type (TEMPLATE_TEMPLATE_PARM);
3010 /* This is for distinguishing between real templates and template
3011 template parameters */
3012 TREE_TYPE (parm) = t;
3013 TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t;
3018 t = make_aggr_type (TEMPLATE_TYPE_PARM);
3019 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3020 decl = build_decl (TYPE_DECL, parm, t);
3023 TYPE_NAME (t) = decl;
3024 TYPE_STUB_DECL (t) = decl;
3026 TEMPLATE_TYPE_PARM_INDEX (t)
3027 = build_template_parm_index (idx, processing_template_decl,
3028 processing_template_decl,
3029 decl, TREE_TYPE (parm));
3030 TEMPLATE_TYPE_PARAMETER_PACK (t) = is_parameter_pack;
3031 TYPE_CANONICAL (t) = canonical_type_parameter (t);
3033 DECL_ARTIFICIAL (decl) = 1;
3034 SET_DECL_TEMPLATE_PARM_P (decl);
3036 parm = build_tree_list (defval, parm);
3037 return chainon (list, parm);
3040 /* The end of a template parameter list has been reached. Process the
3041 tree list into a parameter vector, converting each parameter into a more
3042 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3046 end_template_parm_list (tree parms)
3050 tree saved_parmlist = make_tree_vec (list_length (parms));
3052 current_template_parms
3053 = tree_cons (size_int (processing_template_decl),
3054 saved_parmlist, current_template_parms);
3056 for (parm = parms, nparms = 0; parm; parm = next, nparms++)
3058 next = TREE_CHAIN (parm);
3059 TREE_VEC_ELT (saved_parmlist, nparms) = parm;
3060 TREE_CHAIN (parm) = NULL_TREE;
3063 --processing_template_parmlist;
3065 return saved_parmlist;
3068 /* end_template_decl is called after a template declaration is seen. */
3071 end_template_decl (void)
3073 reset_specialization ();
3075 if (! processing_template_decl)
3078 /* This matches the pushlevel in begin_template_parm_list. */
3081 --processing_template_decl;
3082 current_template_parms = TREE_CHAIN (current_template_parms);
3085 /* Within the declaration of a template, return all levels of template
3086 parameters that apply. The template parameters are represented as
3087 a TREE_VEC, in the form documented in cp-tree.h for template
3091 current_template_args (void)
3094 tree args = NULL_TREE;
3095 int length = TMPL_PARMS_DEPTH (current_template_parms);
3098 /* If there is only one level of template parameters, we do not
3099 create a TREE_VEC of TREE_VECs. Instead, we return a single
3100 TREE_VEC containing the arguments. */
3102 args = make_tree_vec (length);
3104 for (header = current_template_parms; header; header = TREE_CHAIN (header))
3106 tree a = copy_node (TREE_VALUE (header));
3109 TREE_TYPE (a) = NULL_TREE;
3110 for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
3112 tree t = TREE_VEC_ELT (a, i);
3114 /* T will be a list if we are called from within a
3115 begin/end_template_parm_list pair, but a vector directly
3116 if within a begin/end_member_template_processing pair. */
3117 if (TREE_CODE (t) == TREE_LIST)
3121 if (t != error_mark_node)
3123 if (TREE_CODE (t) == TYPE_DECL
3124 || TREE_CODE (t) == TEMPLATE_DECL)
3128 if (TEMPLATE_TYPE_PARAMETER_PACK (t))
3130 /* Turn this argument into a TYPE_ARGUMENT_PACK
3131 with a single element, which expands T. */
3132 tree vec = make_tree_vec (1);
3133 TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
3135 t = make_node (TYPE_ARGUMENT_PACK);
3136 SET_ARGUMENT_PACK_ARGS (t, vec);
3141 t = DECL_INITIAL (t);
3143 if (TEMPLATE_PARM_PARAMETER_PACK (t))
3145 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3146 with a single element, which expands T. */
3147 tree vec = make_tree_vec (1);
3148 tree type = TREE_TYPE (TEMPLATE_PARM_DECL (t));
3149 TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
3151 t = make_node (NONTYPE_ARGUMENT_PACK);
3152 SET_ARGUMENT_PACK_ARGS (t, vec);
3153 TREE_TYPE (t) = type;
3156 TREE_VEC_ELT (a, i) = t;
3162 TREE_VEC_ELT (args, --l) = a;
3170 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
3171 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
3172 a member template. Used by push_template_decl below. */
3175 build_template_decl (tree decl, tree parms, bool member_template_p)
3177 tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
3178 DECL_TEMPLATE_PARMS (tmpl) = parms;
3179 DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
3180 DECL_MEMBER_TEMPLATE_P (tmpl) = member_template_p;
3181 if (DECL_LANG_SPECIFIC (decl))
3183 DECL_STATIC_FUNCTION_P (tmpl) = DECL_STATIC_FUNCTION_P (decl);
3184 DECL_CONSTRUCTOR_P (tmpl) = DECL_CONSTRUCTOR_P (decl);
3185 DECL_DESTRUCTOR_P (tmpl) = DECL_DESTRUCTOR_P (decl);
3186 DECL_NONCONVERTING_P (tmpl) = DECL_NONCONVERTING_P (decl);
3187 DECL_ASSIGNMENT_OPERATOR_P (tmpl) = DECL_ASSIGNMENT_OPERATOR_P (decl);
3188 if (DECL_OVERLOADED_OPERATOR_P (decl))
3189 SET_OVERLOADED_OPERATOR_CODE (tmpl,
3190 DECL_OVERLOADED_OPERATOR_P (decl));
3196 struct template_parm_data
3198 /* The level of the template parameters we are currently
3202 /* The index of the specialization argument we are currently
3206 /* An array whose size is the number of template parameters. The
3207 elements are nonzero if the parameter has been used in any one
3208 of the arguments processed so far. */
3211 /* An array whose size is the number of template arguments. The
3212 elements are nonzero if the argument makes use of template
3213 parameters of this level. */
3214 int* arg_uses_template_parms;
3217 /* Subroutine of push_template_decl used to see if each template
3218 parameter in a partial specialization is used in the explicit
3219 argument list. If T is of the LEVEL given in DATA (which is
3220 treated as a template_parm_data*), then DATA->PARMS is marked
3224 mark_template_parm (tree t, void* data)
3228 struct template_parm_data* tpd = (struct template_parm_data*) data;
3230 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
3232 level = TEMPLATE_PARM_LEVEL (t);
3233 idx = TEMPLATE_PARM_IDX (t);
3237 level = TEMPLATE_TYPE_LEVEL (t);
3238 idx = TEMPLATE_TYPE_IDX (t);
3241 if (level == tpd->level)
3243 tpd->parms[idx] = 1;
3244 tpd->arg_uses_template_parms[tpd->current_arg] = 1;
3247 /* Return zero so that for_each_template_parm will continue the
3248 traversal of the tree; we want to mark *every* template parm. */
3252 /* Process the partial specialization DECL. */
3255 process_partial_specialization (tree decl)
3257 tree type = TREE_TYPE (decl);
3258 tree maintmpl = CLASSTYPE_TI_TEMPLATE (type);
3259 tree specargs = CLASSTYPE_TI_ARGS (type);
3260 tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
3261 tree inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
3262 tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
3263 int nargs = TREE_VEC_LENGTH (inner_args);
3264 int ntparms = TREE_VEC_LENGTH (inner_parms);
3266 int did_error_intro = 0;
3267 struct template_parm_data tpd;
3268 struct template_parm_data tpd2;
3270 /* We check that each of the template parameters given in the
3271 partial specialization is used in the argument list to the
3272 specialization. For example:
3274 template <class T> struct S;
3275 template <class T> struct S<T*>;
3277 The second declaration is OK because `T*' uses the template
3278 parameter T, whereas
3280 template <class T> struct S<int>;
3282 is no good. Even trickier is:
3293 The S2<T> declaration is actually invalid; it is a
3294 full-specialization. Of course,
3297 struct S2<T (*)(U)>;
3299 or some such would have been OK. */
3300 tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
3301 tpd.parms = (int *) alloca (sizeof (int) * ntparms);
3302 memset (tpd.parms, 0, sizeof (int) * ntparms);
3304 tpd.arg_uses_template_parms = (int *) alloca (sizeof (int) * nargs);
3305 memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
3306 for (i = 0; i < nargs; ++i)
3308 tpd.current_arg = i;
3309 for_each_template_parm (TREE_VEC_ELT (inner_args, i),
3310 &mark_template_parm,
3314 for (i = 0; i < ntparms; ++i)
3315 if (tpd.parms[i] == 0)
3317 /* One of the template parms was not used in the
3319 if (!did_error_intro)
3321 error ("template parameters not used in partial specialization:");
3322 did_error_intro = 1;
3325 error (" %qD", TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
3328 /* [temp.class.spec]
3330 The argument list of the specialization shall not be identical to
3331 the implicit argument list of the primary template. */
3332 if (comp_template_args
3334 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
3336 error ("partial specialization %qT does not specialize any template arguments", type);
3338 /* [temp.class.spec]
3340 A partially specialized non-type argument expression shall not
3341 involve template parameters of the partial specialization except
3342 when the argument expression is a simple identifier.
3344 The type of a template parameter corresponding to a specialized
3345 non-type argument shall not be dependent on a parameter of the
3348 Also, we verify that pack expansions only occur at the
3349 end of the argument list. */
3350 gcc_assert (nargs == DECL_NTPARMS (maintmpl));
3352 for (i = 0; i < nargs; ++i)
3354 tree parm = TREE_VALUE (TREE_VEC_ELT (main_inner_parms, i));
3355 tree arg = TREE_VEC_ELT (inner_args, i);
3356 tree packed_args = NULL_TREE;
3359 if (ARGUMENT_PACK_P (arg))
3361 /* Extract the arguments from the argument pack. We'll be
3362 iterating over these in the following loop. */
3363 packed_args = ARGUMENT_PACK_ARGS (arg);
3364 len = TREE_VEC_LENGTH (packed_args);
3367 for (j = 0; j < len; j++)
3370 /* Get the Jth argument in the parameter pack. */
3371 arg = TREE_VEC_ELT (packed_args, j);
3373 if (PACK_EXPANSION_P (arg))
3375 /* Pack expansions must come at the end of the
3377 if ((packed_args && j < len - 1)
3378 || (!packed_args && i < nargs - 1))
3380 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
3381 error ("parameter pack argument %qE must be at the end of the template argument list", arg);
3383 error ("parameter pack argument %qT must be at the end of the template argument list", arg);
3387 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
3388 /* We only care about the pattern. */
3389 arg = PACK_EXPANSION_PATTERN (arg);
3391 if (/* These first two lines are the `non-type' bit. */
3393 && TREE_CODE (arg) != TEMPLATE_DECL
3394 /* This next line is the `argument expression is not just a
3395 simple identifier' condition and also the `specialized
3396 non-type argument' bit. */
3397 && TREE_CODE (arg) != TEMPLATE_PARM_INDEX)
3399 if ((!packed_args && tpd.arg_uses_template_parms[i])
3400 || (packed_args && uses_template_parms (arg)))
3401 error ("template argument %qE involves template parameter(s)",
3405 /* Look at the corresponding template parameter,
3406 marking which template parameters its type depends
3408 tree type = TREE_TYPE (parm);
3412 /* We haven't yet initialized TPD2. Do so now. */
3413 tpd2.arg_uses_template_parms
3414 = (int *) alloca (sizeof (int) * nargs);
3415 /* The number of parameters here is the number in the
3416 main template, which, as checked in the assertion
3418 tpd2.parms = (int *) alloca (sizeof (int) * nargs);
3420 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
3423 /* Mark the template parameters. But this time, we're
3424 looking for the template parameters of the main
3425 template, not in the specialization. */
3426 tpd2.current_arg = i;
3427 tpd2.arg_uses_template_parms[i] = 0;
3428 memset (tpd2.parms, 0, sizeof (int) * nargs);
3429 for_each_template_parm (type,
3430 &mark_template_parm,
3434 if (tpd2.arg_uses_template_parms [i])
3436 /* The type depended on some template parameters.
3437 If they are fully specialized in the
3438 specialization, that's OK. */
3440 for (j = 0; j < nargs; ++j)
3441 if (tpd2.parms[j] != 0
3442 && tpd.arg_uses_template_parms [j])
3444 error ("type %qT of template argument %qE depends "
3445 "on template parameter(s)",
3456 if (retrieve_specialization (maintmpl, specargs,
3457 /*class_specializations_p=*/true))
3458 /* We've already got this specialization. */
3461 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
3462 = tree_cons (specargs, inner_parms,
3463 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
3464 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
3468 /* Check that a template declaration's use of default arguments is not
3469 invalid. Here, PARMS are the template parameters. IS_PRIMARY is
3470 nonzero if DECL is the thing declared by a primary template.
3471 IS_PARTIAL is nonzero if DECL is a partial specialization.
3474 IS_FRIEND_DECL is nonzero if DECL is a friend function template
3475 declaration (but not a definition); 1 indicates a declaration, 2
3476 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
3477 emitted for extraneous default arguments.
3479 Returns TRUE if there were no errors found, FALSE otherwise. */
3482 check_default_tmpl_args (tree decl, tree parms, int is_primary,
3483 int is_partial, int is_friend_decl)
3486 int last_level_to_check;
3488 bool no_errors = true;
3492 A default template-argument shall not be specified in a
3493 function template declaration or a function template definition, nor
3494 in the template-parameter-list of the definition of a member of a
3497 if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
3498 /* You can't have a function template declaration in a local
3499 scope, nor you can you define a member of a class template in a
3503 if (current_class_type
3504 && !TYPE_BEING_DEFINED (current_class_type)
3505 && DECL_LANG_SPECIFIC (decl)
3506 /* If this is either a friend defined in the scope of the class
3507 or a member function. */
3508 && (DECL_FUNCTION_MEMBER_P (decl)
3509 ? same_type_p (DECL_CONTEXT (decl), current_class_type)
3510 : DECL_FRIEND_CONTEXT (decl)
3511 ? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type)
3513 /* And, if it was a member function, it really was defined in
3514 the scope of the class. */
3515 && (!DECL_FUNCTION_MEMBER_P (decl)
3516 || DECL_INITIALIZED_IN_CLASS_P (decl)))
3517 /* We already checked these parameters when the template was
3518 declared, so there's no need to do it again now. This function
3519 was defined in class scope, but we're processing it's body now
3520 that the class is complete. */
3523 /* Core issue 226 (C++0x only): the following only applies to class
3525 if ((cxx_dialect == cxx98) || TREE_CODE (decl) != FUNCTION_DECL)
3529 If a template-parameter has a default template-argument, all
3530 subsequent template-parameters shall have a default
3531 template-argument supplied. */
3532 for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
3534 tree inner_parms = TREE_VALUE (parm_level);
3535 int ntparms = TREE_VEC_LENGTH (inner_parms);
3536 int seen_def_arg_p = 0;
3539 for (i = 0; i < ntparms; ++i)
3541 tree parm = TREE_VEC_ELT (inner_parms, i);
3543 if (parm == error_mark_node)
3546 if (TREE_PURPOSE (parm))
3548 else if (seen_def_arg_p)
3550 error ("no default argument for %qD", TREE_VALUE (parm));
3551 /* For better subsequent error-recovery, we indicate that
3552 there should have been a default argument. */
3553 TREE_PURPOSE (parm) = error_mark_node;
3560 if (((cxx_dialect == cxx98) && TREE_CODE (decl) != TYPE_DECL)
3564 /* For an ordinary class template, default template arguments are
3565 allowed at the innermost level, e.g.:
3566 template <class T = int>
3568 but, in a partial specialization, they're not allowed even
3569 there, as we have in [temp.class.spec]:
3571 The template parameter list of a specialization shall not
3572 contain default template argument values.
3574 So, for a partial specialization, or for a function template
3575 (in C++98/C++03), we look at all of them. */
3578 /* But, for a primary class template that is not a partial
3579 specialization we look at all template parameters except the
3581 parms = TREE_CHAIN (parms);
3583 /* Figure out what error message to issue. */
3584 if (is_friend_decl == 2)
3585 msg = "default template arguments may not be used in function template friend re-declaration";
3586 else if (is_friend_decl)
3587 msg = "default template arguments may not be used in function template friend declarations";
3588 else if (TREE_CODE (decl) == FUNCTION_DECL && (cxx_dialect == cxx98))
3589 msg = "default template arguments may not be used in function templates";
3590 else if (is_partial)
3591 msg = "default template arguments may not be used in partial specializations";
3593 msg = "default argument for template parameter for class enclosing %qD";
3595 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
3596 /* If we're inside a class definition, there's no need to
3597 examine the parameters to the class itself. On the one
3598 hand, they will be checked when the class is defined, and,
3599 on the other, default arguments are valid in things like:
3600 template <class T = double>
3601 struct S { template <class U> void f(U); };
3602 Here the default argument for `S' has no bearing on the
3603 declaration of `f'. */
3604 last_level_to_check = template_class_depth (current_class_type) + 1;
3606 /* Check everything. */
3607 last_level_to_check = 0;
3609 for (parm_level = parms;
3610 parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
3611 parm_level = TREE_CHAIN (parm_level))
3613 tree inner_parms = TREE_VALUE (parm_level);
3617 ntparms = TREE_VEC_LENGTH (inner_parms);
3618 for (i = 0; i < ntparms; ++i)
3620 if (TREE_VEC_ELT (inner_parms, i) == error_mark_node)
3623 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
3628 if (is_friend_decl == 2)
3635 /* Clear out the default argument so that we are not
3637 TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
3641 /* At this point, if we're still interested in issuing messages,
3642 they must apply to classes surrounding the object declared. */
3644 msg = "default argument for template parameter for class enclosing %qD";
3650 /* Worker for push_template_decl_real, called via
3651 for_each_template_parm. DATA is really an int, indicating the
3652 level of the parameters we are interested in. If T is a template
3653 parameter of that level, return nonzero. */
3656 template_parm_this_level_p (tree t, void* data)
3658 int this_level = *(int *)data;
3661 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
3662 level = TEMPLATE_PARM_LEVEL (t);
3664 level = TEMPLATE_TYPE_LEVEL (t);
3665 return level == this_level;
3668 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
3669 parameters given by current_template_args, or reuses a
3670 previously existing one, if appropriate. Returns the DECL, or an
3671 equivalent one, if it is replaced via a call to duplicate_decls.
3673 If IS_FRIEND is true, DECL is a friend declaration. */
3676 push_template_decl_real (tree decl, bool is_friend)
3684 int new_template_p = 0;
3685 /* True if the template is a member template, in the sense of
3687 bool member_template_p = false;
3689 if (decl == error_mark_node)
3692 /* See if this is a partial specialization. */
3693 is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl)
3694 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
3695 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)));
3697 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl))
3701 /* For a friend, we want the context of the friend function, not
3702 the type of which it is a friend. */
3703 ctx = DECL_CONTEXT (decl);
3704 else if (CP_DECL_CONTEXT (decl)
3705 && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
3706 /* In the case of a virtual function, we want the class in which
3708 ctx = CP_DECL_CONTEXT (decl);
3710 /* Otherwise, if we're currently defining some class, the DECL
3711 is assumed to be a member of the class. */
3712 ctx = current_scope ();
3714 if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
3717 if (!DECL_CONTEXT (decl))
3718 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
3720 /* See if this is a primary template. */
3721 if (is_friend && ctx)
3722 /* A friend template that specifies a class context, i.e.
3723 template <typename T> friend void A<T>::f();
3727 primary = template_parm_scope_p ();
3731 if (DECL_CLASS_SCOPE_P (decl))
3732 member_template_p = true;
3733 if (TREE_CODE (decl) == TYPE_DECL
3734 && ANON_AGGRNAME_P (DECL_NAME (decl)))
3735 error ("template class without a name");
3736 else if (TREE_CODE (decl) == FUNCTION_DECL)
3738 if (DECL_DESTRUCTOR_P (decl))
3742 A destructor shall not be a member template. */
3743 error ("destructor %qD declared as member template", decl);
3744 return error_mark_node;
3746 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl))
3747 && (!TYPE_ARG_TYPES (TREE_TYPE (decl))
3748 || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
3749 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
3750 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl))))
3751 == void_list_node)))
3753 /* [basic.stc.dynamic.allocation]
3755 An allocation function can be a function
3756 template. ... Template allocation functions shall
3757 have two or more parameters. */
3758 error ("invalid template declaration of %qD", decl);
3759 return error_mark_node;
3762 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
3763 && CLASS_TYPE_P (TREE_TYPE (decl)))
3767 error ("template declaration of %q#D", decl);
3768 return error_mark_node;
3772 /* Check to see that the rules regarding the use of default
3773 arguments are not being violated. */
3774 check_default_tmpl_args (decl, current_template_parms,
3775 primary, is_partial, /*is_friend_decl=*/0);
3777 /* Ensure that there are no parameter packs in the type of this
3778 declaration that have not been expanded. */
3779 if (TREE_CODE (decl) == FUNCTION_DECL)
3781 /* Check each of the arguments individually to see if there are
3782 any bare parameter packs. */
3783 tree type = TREE_TYPE (decl);
3784 tree arg = DECL_ARGUMENTS (decl);
3785 tree argtype = TYPE_ARG_TYPES (type);
3787 while (arg && argtype)
3789 if (!FUNCTION_PARAMETER_PACK_P (arg)
3790 && !check_for_bare_parameter_packs (TREE_TYPE (arg)))
3792 /* This is a PARM_DECL that contains unexpanded parameter
3793 packs. We have already complained about this in the
3794 check_for_bare_parameter_packs call, so just replace
3795 these types with ERROR_MARK_NODE. */
3796 TREE_TYPE (arg) = error_mark_node;
3797 TREE_VALUE (argtype) = error_mark_node;
3800 arg = TREE_CHAIN (arg);
3801 argtype = TREE_CHAIN (argtype);
3804 /* Check for bare parameter packs in the return type and the
3805 exception specifiers. */
3806 check_for_bare_parameter_packs (TREE_TYPE (type));
3807 check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type));
3810 check_for_bare_parameter_packs (TREE_TYPE (decl));
3813 return process_partial_specialization (decl);
3815 /* A primary class template can only have one parameter pack, at the
3816 end of the template parameter list. */
3817 if (primary && TREE_CODE (decl) == TYPE_DECL)
3820 = INNERMOST_TEMPLATE_PARMS (current_template_parms);
3821 int i, len = TREE_VEC_LENGTH (inner_parms);
3822 for (i = 0; i < len - 1; i++)
3824 tree parm = TREE_VALUE (TREE_VEC_ELT (inner_parms, i));
3826 if (template_parameter_pack_p (parm))
3828 if (TREE_CODE (parm) == PARM_DECL)
3829 error ("parameter pack %qE must be at the end of the"
3830 " template parameter list", parm);
3832 error ("parameter pack %qT must be at the end of the"
3833 " template parameter list", TREE_TYPE (parm));
3838 args = current_template_args ();
3841 || TREE_CODE (ctx) == FUNCTION_DECL
3842 || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
3843 || (is_friend && !DECL_TEMPLATE_INFO (decl)))
3845 if (DECL_LANG_SPECIFIC (decl)
3846 && DECL_TEMPLATE_INFO (decl)
3847 && DECL_TI_TEMPLATE (decl))
3848 tmpl = DECL_TI_TEMPLATE (decl);
3849 /* If DECL is a TYPE_DECL for a class-template, then there won't
3850 be DECL_LANG_SPECIFIC. The information equivalent to
3851 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
3852 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
3853 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
3854 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
3856 /* Since a template declaration already existed for this
3857 class-type, we must be redeclaring it here. Make sure
3858 that the redeclaration is valid. */
3859 redeclare_class_template (TREE_TYPE (decl),
3860 current_template_parms);
3861 /* We don't need to create a new TEMPLATE_DECL; just use the
3862 one we already had. */
3863 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
3867 tmpl = build_template_decl (decl, current_template_parms,
3871 if (DECL_LANG_SPECIFIC (decl)
3872 && DECL_TEMPLATE_SPECIALIZATION (decl))
3874 /* A specialization of a member template of a template
3876 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
3877 DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
3878 DECL_TEMPLATE_INFO (decl) = NULL_TREE;
3884 tree a, t, current, parms;
3886 tree tinfo = get_template_info (decl);
3890 error ("template definition of non-template %q#D", decl);
3894 tmpl = TI_TEMPLATE (tinfo);
3896 if (DECL_FUNCTION_TEMPLATE_P (tmpl)
3897 && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
3898 && DECL_TEMPLATE_SPECIALIZATION (decl)
3899 && DECL_MEMBER_TEMPLATE_P (tmpl))
3903 /* The declaration is a specialization of a member
3904 template, declared outside the class. Therefore, the
3905 innermost template arguments will be NULL, so we
3906 replace them with the arguments determined by the
3907 earlier call to check_explicit_specialization. */
3908 args = DECL_TI_ARGS (decl);
3911 = build_template_decl (decl, current_template_parms,
3913 DECL_TEMPLATE_RESULT (new_tmpl) = decl;
3914 TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
3915 DECL_TI_TEMPLATE (decl) = new_tmpl;
3916 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
3917 DECL_TEMPLATE_INFO (new_tmpl)
3918 = tree_cons (tmpl, args, NULL_TREE);
3920 register_specialization (new_tmpl,
3921 most_general_template (tmpl),
3927 /* Make sure the template headers we got make sense. */
3929 parms = DECL_TEMPLATE_PARMS (tmpl);
3930 i = TMPL_PARMS_DEPTH (parms);
3931 if (TMPL_ARGS_DEPTH (args) != i)
3933 error ("expected %d levels of template parms for %q#D, got %d",
3934 i, decl, TMPL_ARGS_DEPTH (args));
3937 for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
3939 a = TMPL_ARGS_LEVEL (args, i);
3940 t = INNERMOST_TEMPLATE_PARMS (parms);
3942 if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
3944 if (current == decl)
3945 error ("got %d template parameters for %q#D",
3946 TREE_VEC_LENGTH (a), decl);
3948 error ("got %d template parameters for %q#T",
3949 TREE_VEC_LENGTH (a), current);
3950 error (" but %d required", TREE_VEC_LENGTH (t));
3951 return error_mark_node;
3954 if (current == decl)
3957 current = (TYPE_P (current)
3958 ? TYPE_CONTEXT (current)
3959 : DECL_CONTEXT (current));
3962 /* Check that the parms are used in the appropriate qualifying scopes
3963 in the declarator. */
3964 if (!comp_template_args
3966 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl)))))
3969 template arguments to %qD do not match original template %qD",
3970 decl, DECL_TEMPLATE_RESULT (tmpl));
3971 if (!uses_template_parms (TI_ARGS (tinfo)))
3972 inform ("use template<> for an explicit specialization");
3973 /* Avoid crash in import_export_decl. */
3974 DECL_INTERFACE_KNOWN (decl) = 1;
3975 return error_mark_node;
3979 DECL_TEMPLATE_RESULT (tmpl) = decl;
3980 TREE_TYPE (tmpl) = TREE_TYPE (decl);
3982 /* Push template declarations for global functions and types. Note
3983 that we do not try to push a global template friend declared in a
3984 template class; such a thing may well depend on the template
3985 parameters of the class. */
3986 if (new_template_p && !ctx
3987 && !(is_friend && template_class_depth (current_class_type) > 0))
3989 tmpl = pushdecl_namespace_level (tmpl, is_friend);
3990 if (tmpl == error_mark_node)
3991 return error_mark_node;
3993 /* Hide template friend classes that haven't been declared yet. */
3994 if (is_friend && TREE_CODE (decl) == TYPE_DECL)
3996 DECL_ANTICIPATED (tmpl) = 1;
3997 DECL_FRIEND_P (tmpl) = 1;
4003 DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
4004 if (DECL_CONV_FN_P (tmpl))
4006 int depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
4008 /* It is a conversion operator. See if the type converted to
4009 depends on innermost template operands. */
4011 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl)),
4013 DECL_TEMPLATE_CONV_FN_P (tmpl) = 1;
4017 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
4018 back to its most general template. If TMPL is a specialization,
4019 ARGS may only have the innermost set of arguments. Add the missing
4020 argument levels if necessary. */
4021 if (DECL_TEMPLATE_INFO (tmpl))
4022 args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);
4024 info = tree_cons (tmpl, args, NULL_TREE);
4026 if (DECL_IMPLICIT_TYPEDEF_P (decl))
4027 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
4028 else if (DECL_LANG_SPECIFIC (decl))
4029 DECL_TEMPLATE_INFO (decl) = info;
4031 return DECL_TEMPLATE_RESULT (tmpl);
4035 push_template_decl (tree decl)
4037 return push_template_decl_real (decl, false);
4040 /* Called when a class template TYPE is redeclared with the indicated
4041 template PARMS, e.g.:
4043 template <class T> struct S;
4044 template <class T> struct S {}; */
4047 redeclare_class_template (tree type, tree parms)
4053 if (!TYPE_TEMPLATE_INFO (type))
4055 error ("%qT is not a template type", type);
4059 tmpl = TYPE_TI_TEMPLATE (type);
4060 if (!PRIMARY_TEMPLATE_P (tmpl))
4061 /* The type is nested in some template class. Nothing to worry
4062 about here; there are no new template parameters for the nested
4068 error ("template specifiers not specified in declaration of %qD",
4073 parms = INNERMOST_TEMPLATE_PARMS (parms);
4074 tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
4076 if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
4078 error ("previous declaration %q+D", tmpl);
4079 error ("used %d template parameter(s) instead of %d",
4080 TREE_VEC_LENGTH (tmpl_parms),
4081 TREE_VEC_LENGTH (parms));
4085 for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
4092 if (TREE_VEC_ELT (tmpl_parms, i) == error_mark_node
4093 || TREE_VEC_ELT (parms, i) == error_mark_node)
4096 tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
4097 parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
4098 tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i));
4099 parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
4101 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
4103 if (tmpl_parm != error_mark_node
4104 && (TREE_CODE (tmpl_parm) != TREE_CODE (parm)
4105 || (TREE_CODE (tmpl_parm) != TYPE_DECL
4106 && !same_type_p (TREE_TYPE (tmpl_parm), TREE_TYPE (parm)))))
4108 error ("template parameter %q+#D", tmpl_parm);
4109 error ("redeclared here as %q#D", parm);
4113 if (tmpl_default != NULL_TREE && parm_default != NULL_TREE)
4115 /* We have in [temp.param]:
4117 A template-parameter may not be given default arguments
4118 by two different declarations in the same scope. */
4119 error ("redefinition of default argument for %q#D", parm);
4120 error ("%J original definition appeared here", tmpl_parm);
4124 if (parm_default != NULL_TREE)
4125 /* Update the previous template parameters (which are the ones
4126 that will really count) with the new default value. */
4127 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default;
4128 else if (tmpl_default != NULL_TREE)
4129 /* Update the new parameters, too; they'll be used as the
4130 parameters for any members. */
4131 TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default;
4137 /* Simplify EXPR if it is a non-dependent expression. Returns the
4138 (possibly simplified) expression. */
4141 fold_non_dependent_expr (tree expr)
4143 if (expr == NULL_TREE)
4146 /* If we're in a template, but EXPR isn't value dependent, simplify
4147 it. We're supposed to treat:
4149 template <typename T> void f(T[1 + 1]);
4150 template <typename T> void f(T[2]);
4152 as two declarations of the same function, for example. */
4153 if (processing_template_decl
4154 && !type_dependent_expression_p (expr)
4155 && !value_dependent_expression_p (expr))
4157 HOST_WIDE_INT saved_processing_template_decl;
4159 saved_processing_template_decl = processing_template_decl;
4160 processing_template_decl = 0;
4161 expr = tsubst_copy_and_build (expr,
4164 /*in_decl=*/NULL_TREE,
4165 /*function_p=*/false,
4166 /*integral_constant_expression_p=*/true);
4167 processing_template_decl = saved_processing_template_decl;
4172 /* EXPR is an expression which is used in a constant-expression context.
4173 For instance, it could be a VAR_DECL with a constant initializer.
4174 Extract the innest constant expression.
4176 This is basically a more powerful version of
4177 integral_constant_value, which can be used also in templates where
4178 initializers can maintain a syntactic rather than semantic form
4179 (even if they are non-dependent, for access-checking purposes). */
4182 fold_decl_constant_value (tree expr)
4184 tree const_expr = expr;
4187 expr = fold_non_dependent_expr (const_expr);
4188 const_expr = integral_constant_value (expr);
4190 while (expr != const_expr);
4195 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
4196 must be a function or a pointer-to-function type, as specified
4197 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
4198 and check that the resulting function has external linkage. */
4201 convert_nontype_argument_function (tree type, tree expr)
4206 fn = instantiate_type (type, fns, tf_none);
4207 if (fn == error_mark_node)
4208 return error_mark_node;
4211 if (TREE_CODE (fn_no_ptr) == ADDR_EXPR)
4212 fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0);
4213 if (TREE_CODE (fn_no_ptr) == BASELINK)
4214 fn_no_ptr = BASELINK_FUNCTIONS (fn_no_ptr);
4216 /* [temp.arg.nontype]/1
4218 A template-argument for a non-type, non-template template-parameter
4221 -- the address of an object or function with external linkage. */
4222 if (!DECL_EXTERNAL_LINKAGE_P (fn_no_ptr))
4224 error ("%qE is not a valid template argument for type %qT "
4225 "because function %qD has not external linkage",
4226 expr, type, fn_no_ptr);
4233 /* Attempt to convert the non-type template parameter EXPR to the
4234 indicated TYPE. If the conversion is successful, return the
4235 converted value. If the conversion is unsuccessful, return
4236 NULL_TREE if we issued an error message, or error_mark_node if we
4237 did not. We issue error messages for out-and-out bad template
4238 parameters, but not simply because the conversion failed, since we
4239 might be just trying to do argument deduction. Both TYPE and EXPR
4240 must be non-dependent.
4242 The conversion follows the special rules described in
4243 [temp.arg.nontype], and it is much more strict than an implicit
4246 This function is called twice for each template argument (see
4247 lookup_template_class for a more accurate description of this
4248 problem). This means that we need to handle expressions which
4249 are not valid in a C++ source, but can be created from the
4250 first call (for instance, casts to perform conversions). These
4251 hacks can go away after we fix the double coercion problem. */
4254 convert_nontype_argument (tree type, tree expr)
4258 /* Detect immediately string literals as invalid non-type argument.
4259 This special-case is not needed for correctness (we would easily
4260 catch this later), but only to provide better diagnostic for this
4261 common user mistake. As suggested by DR 100, we do not mention
4262 linkage issues in the diagnostic as this is not the point. */
4263 if (TREE_CODE (expr) == STRING_CST)
4265 error ("%qE is not a valid template argument for type %qT "
4266 "because string literals can never be used in this context",
4271 /* If we are in a template, EXPR may be non-dependent, but still
4272 have a syntactic, rather than semantic, form. For example, EXPR
4273 might be a SCOPE_REF, rather than the VAR_DECL to which the
4274 SCOPE_REF refers. Preserving the qualifying scope is necessary
4275 so that access checking can be performed when the template is
4276 instantiated -- but here we need the resolved form so that we can
4277 convert the argument. */
4278 expr = fold_non_dependent_expr (expr);
4279 if (error_operand_p (expr))
4280 return error_mark_node;
4281 expr_type = TREE_TYPE (expr);
4283 /* HACK: Due to double coercion, we can get a
4284 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
4285 which is the tree that we built on the first call (see
4286 below when coercing to reference to object or to reference to
4287 function). We just strip everything and get to the arg.
4288 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
4290 if (TREE_CODE (expr) == NOP_EXPR)
4292 if (TYPE_REF_OBJ_P (type) || TYPE_REFFN_P (type))
4294 /* ??? Maybe we could use convert_from_reference here, but we
4295 would need to relax its constraints because the NOP_EXPR
4296 could actually change the type to something more cv-qualified,
4297 and this is not folded by convert_from_reference. */
4298 tree addr = TREE_OPERAND (expr, 0);
4299 gcc_assert (TREE_CODE (expr_type) == REFERENCE_TYPE);
4300 gcc_assert (TREE_CODE (addr) == ADDR_EXPR);
4301 gcc_assert (TREE_CODE (TREE_TYPE (addr)) == POINTER_TYPE);
4302 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4303 (TREE_TYPE (expr_type),
4304 TREE_TYPE (TREE_TYPE (addr))));
4306 expr = TREE_OPERAND (addr, 0);
4307 expr_type = TREE_TYPE (expr);
4310 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
4311 parameter is a pointer to object, through decay and
4312 qualification conversion. Let's strip everything. */
4313 else if (TYPE_PTROBV_P (type))
4316 gcc_assert (TREE_CODE (expr) == ADDR_EXPR);
4317 gcc_assert (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE);
4318 /* Skip the ADDR_EXPR only if it is part of the decay for
4319 an array. Otherwise, it is part of the original argument
4320 in the source code. */
4321 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == ARRAY_TYPE)
4322 expr = TREE_OPERAND (expr, 0);
4323 expr_type = TREE_TYPE (expr);
4327 /* [temp.arg.nontype]/5, bullet 1
4329 For a non-type template-parameter of integral or enumeration type,
4330 integral promotions (_conv.prom_) and integral conversions
4331 (_conv.integral_) are applied. */
4332 if (INTEGRAL_TYPE_P (type))
4334 if (!INTEGRAL_TYPE_P (expr_type))
4335 return error_mark_node;
4337 expr = fold_decl_constant_value (expr);
4338 /* Notice that there are constant expressions like '4 % 0' which
4339 do not fold into integer constants. */
4340 if (TREE_CODE (expr) != INTEGER_CST)
4342 error ("%qE is not a valid template argument for type %qT "
4343 "because it is a non-constant expression", expr, type);
4347 /* At this point, an implicit conversion does what we want,
4348 because we already know that the expression is of integral
4350 expr = ocp_convert (type, expr, CONV_IMPLICIT, LOOKUP_PROTECT);
4351 if (expr == error_mark_node)
4352 return error_mark_node;
4354 /* Conversion was allowed: fold it to a bare integer constant. */
4357 /* [temp.arg.nontype]/5, bullet 2
4359 For a non-type template-parameter of type pointer to object,
4360 qualification conversions (_conv.qual_) and the array-to-pointer
4361 conversion (_conv.array_) are applied. */
4362 else if (TYPE_PTROBV_P (type))
4364 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
4366 A template-argument for a non-type, non-template template-parameter
4367 shall be one of: [...]
4369 -- the name of a non-type template-parameter;
4370 -- the address of an object or function with external linkage, [...]
4371 expressed as "& id-expression" where the & is optional if the name
4372 refers to a function or array, or if the corresponding
4373 template-parameter is a reference.
4375 Here, we do not care about functions, as they are invalid anyway
4376 for a parameter of type pointer-to-object. */
4378 if (DECL_P (expr) && DECL_TEMPLATE_PARM_P (expr))
4379 /* Non-type template parameters are OK. */
4381 else if (TREE_CODE (expr) != ADDR_EXPR
4382 && TREE_CODE (expr_type) != ARRAY_TYPE)
4384 if (TREE_CODE (expr) == VAR_DECL)
4386 error ("%qD is not a valid template argument "
4387 "because %qD is a variable, not the address of "
4392 /* Other values, like integer constants, might be valid
4393 non-type arguments of some other type. */
4394 return error_mark_node;
4400 decl = ((TREE_CODE (expr) == ADDR_EXPR)
4401 ? TREE_OPERAND (expr, 0) : expr);
4402 if (TREE_CODE (decl) != VAR_DECL)
4404 error ("%qE is not a valid template argument of type %qT "
4405 "because %qE is not a variable",
4409 else if (!DECL_EXTERNAL_LINKAGE_P (decl))
4411 error ("%qE is not a valid template argument of type %qT "
4412 "because %qD does not have external linkage",
4418 expr = decay_conversion (expr);
4419 if (expr == error_mark_node)
4420 return error_mark_node;
4422 expr = perform_qualification_conversions (type, expr);
4423 if (expr == error_mark_node)
4424 return error_mark_node;
4426 /* [temp.arg.nontype]/5, bullet 3
4428 For a non-type template-parameter of type reference to object, no
4429 conversions apply. The type referred to by the reference may be more
4430 cv-qualified than the (otherwise identical) type of the
4431 template-argument. The template-parameter is bound directly to the
4432 template-argument, which must be an lvalue. */
4433 else if (TYPE_REF_OBJ_P (type))
4435 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type),
4437 return error_mark_node;
4439 if (!at_least_as_qualified_p (TREE_TYPE (type), expr_type))
4441 error ("%qE is not a valid template argument for type %qT "
4442 "because of conflicts in cv-qualification", expr, type);
4446 if (!real_lvalue_p (expr))
4448 error ("%qE is not a valid template argument for type %qT "
4449 "because it is not an lvalue", expr, type);
4453 /* [temp.arg.nontype]/1
4455 A template-argument for a non-type, non-template template-parameter
4456 shall be one of: [...]
4458 -- the address of an object or function with external linkage. */
4459 if (!DECL_EXTERNAL_LINKAGE_P (expr))
4461 error ("%qE is not a valid template argument for type %qT "
4462 "because object %qD has not external linkage",
4467 expr = build_nop (type, build_address (expr));
4469 /* [temp.arg.nontype]/5, bullet 4
4471 For a non-type template-parameter of type pointer to function, only
4472 the function-to-pointer conversion (_conv.func_) is applied. If the
4473 template-argument represents a set of overloaded functions (or a
4474 pointer to such), the matching function is selected from the set
4476 else if (TYPE_PTRFN_P (type))
4478 /* If the argument is a template-id, we might not have enough
4479 context information to decay the pointer. */
4480 if (!type_unknown_p (expr_type))
4482 expr = decay_conversion (expr);
4483 if (expr == error_mark_node)
4484 return error_mark_node;
4487 expr = convert_nontype_argument_function (type, expr);
4488 if (!expr || expr == error_mark_node)
4491 /* [temp.arg.nontype]/5, bullet 5
4493 For a non-type template-parameter of type reference to function, no
4494 conversions apply. If the template-argument represents a set of
4495 overloaded functions, the matching function is selected from the set
4497 else if (TYPE_REFFN_P (type))
4499 if (TREE_CODE (expr) == ADDR_EXPR)
4501 error ("%qE is not a valid template argument for type %qT "
4502 "because it is a pointer", expr, type);
4503 inform ("try using %qE instead", TREE_OPERAND (expr, 0));
4507 expr = convert_nontype_argument_function (TREE_TYPE (type), expr);
4508 if (!expr || expr == error_mark_node)
4511 expr = build_nop (type, build_address (expr));
4513 /* [temp.arg.nontype]/5, bullet 6
4515 For a non-type template-parameter of type pointer to member function,
4516 no conversions apply. If the template-argument represents a set of
4517 overloaded member functions, the matching member function is selected
4518 from the set (_over.over_). */
4519 else if (TYPE_PTRMEMFUNC_P (type))
4521 expr = instantiate_type (type, expr, tf_none);
4522 if (expr == error_mark_node)
4523 return error_mark_node;
4525 /* There is no way to disable standard conversions in
4526 resolve_address_of_overloaded_function (called by
4527 instantiate_type). It is possible that the call succeeded by
4528 converting &B::I to &D::I (where B is a base of D), so we need
4529 to reject this conversion here.
4531 Actually, even if there was a way to disable standard conversions,
4532 it would still be better to reject them here so that we can
4533 provide a superior diagnostic. */
4534 if (!same_type_p (TREE_TYPE (expr), type))
4536 /* Make sure we are just one standard conversion off. */
4537 gcc_assert (can_convert (type, TREE_TYPE (expr)));
4538 error ("%qE is not a valid template argument for type %qT "
4539 "because it is of type %qT", expr, type,
4541 inform ("standard conversions are not allowed in this context");
4545 /* [temp.arg.nontype]/5, bullet 7
4547 For a non-type template-parameter of type pointer to data member,
4548 qualification conversions (_conv.qual_) are applied. */
4549 else if (TYPE_PTRMEM_P (type))
4551 expr = perform_qualification_conversions (type, expr);
4552 if (expr == error_mark_node)
4555 /* A template non-type parameter must be one of the above. */
4559 /* Sanity check: did we actually convert the argument to the
4561 gcc_assert (same_type_p (type, TREE_TYPE (expr)));
4566 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
4567 template template parameters. Both PARM_PARMS and ARG_PARMS are
4568 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
4571 Consider the example:
4572 template <class T> class A;
4573 template<template <class U> class TT> class B;
4575 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
4576 the parameters to A, and OUTER_ARGS contains A. */
4579 coerce_template_template_parms (tree parm_parms,
4581 tsubst_flags_t complain,
4585 int nparms, nargs, i;
4588 gcc_assert (TREE_CODE (parm_parms) == TREE_VEC);
4589 gcc_assert (TREE_CODE (arg_parms) == TREE_VEC);
4591 nparms = TREE_VEC_LENGTH (parm_parms);
4592 nargs = TREE_VEC_LENGTH (arg_parms);
4594 if (nargs != nparms)
4597 for (i = 0; i < nparms; ++i)
4599 if (TREE_VEC_ELT (parm_parms, i) == error_mark_node
4600 || TREE_VEC_ELT (arg_parms, i) == error_mark_node)
4603 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
4604 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
4606 if (arg == NULL_TREE || arg == error_mark_node
4607 || parm == NULL_TREE || parm == error_mark_node)
4610 if (TREE_CODE (arg) != TREE_CODE (parm))
4613 switch (TREE_CODE (parm))
4616 /* We encounter instantiations of templates like
4617 template <template <template <class> class> class TT>
4620 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
4621 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
4623 if (!coerce_template_template_parms
4624 (parmparm, argparm, complain, in_decl, outer_args))
4630 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm))
4631 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg)))
4632 /* One is a parameter pack, the other is not. */
4637 /* The tsubst call is used to handle cases such as
4639 template <int> class C {};
4640 template <class T, template <T> class TT> class D {};
4643 i.e. the parameter list of TT depends on earlier parameters. */
4644 if (!dependent_type_p (TREE_TYPE (arg))
4646 (tsubst (TREE_TYPE (parm), outer_args, complain, in_decl),
4650 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm))
4651 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg)))
4652 /* One is a parameter pack, the other is not. */
4663 /* Convert the indicated template ARG as necessary to match the
4664 indicated template PARM. Returns the converted ARG, or
4665 error_mark_node if the conversion was unsuccessful. Error and
4666 warning messages are issued under control of COMPLAIN. This
4667 conversion is for the Ith parameter in the parameter list. ARGS is
4668 the full set of template arguments deduced so far. */
4671 convert_template_argument (tree parm,
4674 tsubst_flags_t complain,
4680 int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
4682 if (TREE_CODE (arg) == TREE_LIST
4683 && TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF)
4685 /* The template argument was the name of some
4686 member function. That's usually
4687 invalid, but static members are OK. In any
4688 case, grab the underlying fields/functions
4689 and issue an error later if required. */
4690 orig_arg = TREE_VALUE (arg);
4691 TREE_TYPE (arg) = unknown_type_node;
4696 requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
4697 requires_type = (TREE_CODE (parm) == TYPE_DECL
4698 || requires_tmpl_type);
4700 /* When determining whether an argument pack expansion is a template,
4701 look at the pattern. */
4702 if (TREE_CODE (arg) == TYPE_PACK_EXPANSION)
4703 arg = PACK_EXPANSION_PATTERN (arg);
4706 ((TREE_CODE (arg) == TEMPLATE_DECL
4707 && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
4708 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4709 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
4712 && (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4713 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE))
4714 arg = TYPE_STUB_DECL (arg);
4716 is_type = TYPE_P (arg) || is_tmpl_type;
4718 if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
4719 && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
4721 pedwarn ("to refer to a type member of a template parameter, "
4722 "use %<typename %E%>", orig_arg);
4724 orig_arg = make_typename_type (TREE_OPERAND (arg, 0),
4725 TREE_OPERAND (arg, 1),
4727 complain & tf_error);
4731 if (is_type != requires_type)
4735 if (complain & tf_error)
4737 error ("type/value mismatch at argument %d in template "
4738 "parameter list for %qD",
4741 error (" expected a constant of type %qT, got %qT",
4743 (is_tmpl_type ? DECL_NAME (arg) : orig_arg));
4744 else if (requires_tmpl_type)
4745 error (" expected a class template, got %qE", orig_arg);
4747 error (" expected a type, got %qE", orig_arg);
4750 return error_mark_node;
4752 if (is_tmpl_type ^ requires_tmpl_type)
4754 if (in_decl && (complain & tf_error))
4756 error ("type/value mismatch at argument %d in template "
4757 "parameter list for %qD",
4760 error (" expected a type, got %qT", DECL_NAME (arg));
4762 error (" expected a class template, got %qT", orig_arg);
4764 return error_mark_node;
4769 if (requires_tmpl_type)
4771 if (TREE_CODE (TREE_TYPE (arg)) == UNBOUND_CLASS_TEMPLATE)
4772 /* The number of argument required is not known yet.
4773 Just accept it for now. */
4774 val = TREE_TYPE (arg);
4777 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
4780 argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
4782 if (coerce_template_template_parms (parmparm, argparm,
4788 /* TEMPLATE_TEMPLATE_PARM node is preferred over
4790 if (val != error_mark_node)
4792 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val))
4793 val = TREE_TYPE (val);
4794 else if (TREE_CODE (val) == TYPE_PACK_EXPANSION
4795 && DECL_TEMPLATE_TEMPLATE_PARM_P (arg))
4797 val = TREE_TYPE (arg);
4798 val = make_pack_expansion (val);
4804 if (in_decl && (complain & tf_error))
4806 error ("type/value mismatch at argument %d in "
4807 "template parameter list for %qD",
4809 error (" expected a template of type %qD, got %qD",
4813 val = error_mark_node;
4819 /* We only form one instance of each template specialization.
4820 Therefore, if we use a non-canonical variant (i.e., a
4821 typedef), any future messages referring to the type will use
4822 the typedef, which is confusing if those future uses do not
4823 themselves also use the typedef. */
4825 val = canonical_type_variant (val);
4829 tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl);
4831 if (invalid_nontype_parm_type_p (t, complain))
4832 return error_mark_node;
4834 if (!uses_template_parms (orig_arg) && !uses_template_parms (t))
4835 /* We used to call digest_init here. However, digest_init
4836 will report errors, which we don't want when complain
4837 is zero. More importantly, digest_init will try too
4838 hard to convert things: for example, `0' should not be
4839 converted to pointer type at this point according to
4840 the standard. Accepting this is not merely an
4841 extension, since deciding whether or not these
4842 conversions can occur is part of determining which
4843 function template to call, or whether a given explicit
4844 argument specification is valid. */
4845 val = convert_nontype_argument (t, orig_arg);
4849 if (val == NULL_TREE)
4850 val = error_mark_node;
4851 else if (val == error_mark_node && (complain & tf_error))
4852 error ("could not convert template argument %qE to %qT", orig_arg, t);
4858 /* Coerces the remaining template arguments in INNER_ARGS (from
4859 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
4860 Returns the coerced argument pack. PARM_IDX is the position of this
4861 parameter in the template parameter list. ARGS is the original
4862 template argument list. */
4864 coerce_template_parameter_pack (tree parms,
4872 tsubst_flags_t complain)
4874 tree parm = TREE_VEC_ELT (parms, parm_idx);
4875 int nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
4878 tree packed_types = NULL_TREE;
4880 if (arg_idx > nargs)
4883 packed_args = make_tree_vec (nargs - arg_idx);
4885 if (TREE_CODE (TREE_VALUE (parm)) == PARM_DECL
4886 && uses_parameter_packs (TREE_TYPE (TREE_VALUE (parm))))
4888 /* When the template parameter is a non-type template
4889 parameter pack whose type uses parameter packs, we need
4890 to look at each of the template arguments
4891 separately. Build a vector of the types for these
4892 non-type template parameters in PACKED_TYPES. */
4894 = make_pack_expansion (TREE_TYPE (TREE_VALUE (parm)));
4895 packed_types = tsubst_pack_expansion (expansion, args,
4898 if (packed_types == error_mark_node)
4899 return error_mark_node;
4901 /* Check that we have the right number of arguments. */
4903 && !PACK_EXPANSION_P (TREE_VEC_ELT (inner_args, arg_idx))
4904 && nargs - arg_idx != TREE_VEC_LENGTH (packed_types))
4907 = TREE_VEC_LENGTH (parms) - 1 + TREE_VEC_LENGTH (packed_types);
4908 error ("wrong number of template arguments (%d, should be %d)",
4909 nargs, needed_parms);
4910 return error_mark_node;
4913 /* If we aren't able to check the actual arguments now
4914 (because they haven't been expanded yet), we can at least
4915 verify that all of the types used for the non-type
4916 template parameter pack are, in fact, valid for non-type
4917 template parameters. */
4919 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args, arg_idx)))
4921 int j, len = TREE_VEC_LENGTH (packed_types);
4922 for (j = 0; j < len; ++j)
4924 tree t = TREE_VEC_ELT (packed_types, j);
4925 if (invalid_nontype_parm_type_p (t, complain))
4926 return error_mark_node;
4931 /* Convert the remaining arguments, which will be a part of the
4932 parameter pack "parm". */
4933 for (; arg_idx < nargs; ++arg_idx)
4935 tree arg = TREE_VEC_ELT (inner_args, arg_idx);
4936 tree actual_parm = TREE_VALUE (parm);
4938 if (packed_types && !PACK_EXPANSION_P (arg))
4940 /* When we have a vector of types (corresponding to the
4941 non-type template parameter pack that uses parameter
4942 packs in its type, as mention above), and the
4943 argument is not an expansion (which expands to a
4944 currently unknown number of arguments), clone the
4945 parm and give it the next type in PACKED_TYPES. */
4946 actual_parm = copy_node (actual_parm);
4947 TREE_TYPE (actual_parm) =
4948 TREE_VEC_ELT (packed_types, arg_idx - parm_idx);
4951 if (arg != error_mark_node)
4952 arg = convert_template_argument (actual_parm,
4953 arg, new_args, complain, parm_idx,
4955 if (arg == error_mark_node)
4957 TREE_VEC_ELT (packed_args, arg_idx - parm_idx) = arg;
4960 if (TREE_CODE (TREE_VALUE (parm)) == TYPE_DECL
4961 || TREE_CODE (TREE_VALUE (parm)) == TEMPLATE_DECL)
4962 argument_pack = make_node (TYPE_ARGUMENT_PACK);
4965 argument_pack = make_node (NONTYPE_ARGUMENT_PACK);
4966 TREE_TYPE (argument_pack)
4967 = tsubst (TREE_TYPE (TREE_VALUE (parm)), args, complain, in_decl);
4968 TREE_CONSTANT (argument_pack) = 1;
4971 SET_ARGUMENT_PACK_ARGS (argument_pack, packed_args);
4972 return argument_pack;
4975 /* Convert all template arguments to their appropriate types, and
4976 return a vector containing the innermost resulting template
4977 arguments. If any error occurs, return error_mark_node. Error and
4978 warning messages are issued under control of COMPLAIN.
4980 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
4981 for arguments not specified in ARGS. Otherwise, if
4982 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
4983 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
4984 USE_DEFAULT_ARGS is false, then all arguments must be specified in
4988 coerce_template_parms (tree parms,
4991 tsubst_flags_t complain,
4992 bool require_all_args,
4993 bool use_default_args)
4995 int nparms, nargs, parm_idx, arg_idx, lost = 0;
4998 tree new_inner_args;
4999 bool saved_skip_evaluation;
5001 /* When used as a boolean value, indicates whether this is a
5002 variadic template parameter list. Since it's an int, we can also
5003 subtract it from nparms to get the number of non-variadic
5008 = expand_template_argument_pack (INNERMOST_TEMPLATE_ARGS (args));
5010 nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
5011 nparms = TREE_VEC_LENGTH (parms);
5013 /* Determine if there are any parameter packs. */
5014 for (parm_idx = 0; parm_idx < nparms; ++parm_idx)
5016 tree tparm = TREE_VALUE (TREE_VEC_ELT (parms, parm_idx));
5017 if (template_parameter_pack_p (tparm))
5024 if ((nargs > nparms - variadic_p && !variadic_p)
5025 || (nargs < nparms - variadic_p
5027 && (!use_default_args
5028 || (TREE_VEC_ELT (parms, nargs) != error_mark_node
5029 && !TREE_PURPOSE (TREE_VEC_ELT (parms, nargs))))))
5031 if (complain & tf_error)
5033 const char *or_more = "";
5036 or_more = " or more";
5040 error ("wrong number of template arguments (%d, should be %d%s)",
5041 nargs, nparms, or_more);
5044 error ("provided for %q+D", in_decl);
5047 return error_mark_node;
5050 /* We need to evaluate the template arguments, even though this
5051 template-id may be nested within a "sizeof". */
5052 saved_skip_evaluation = skip_evaluation;
5053 skip_evaluation = false;
5054 new_inner_args = make_tree_vec (nparms);
5055 new_args = add_outermost_template_args (args, new_inner_args);
5056 for (parm_idx = 0, arg_idx = 0; parm_idx < nparms; parm_idx++, arg_idx++)
5061 /* Get the Ith template parameter. */
5062 parm = TREE_VEC_ELT (parms, parm_idx);
5064 if (parm == error_mark_node)
5066 TREE_VEC_ELT (new_inner_args, arg_idx) = error_mark_node;
5070 /* Calculate the next argument. */
5071 if (template_parameter_pack_p (TREE_VALUE (parm)))
5073 /* All remaining arguments will be placed in the
5074 template parameter pack PARM. */
5075 arg = coerce_template_parameter_pack (parms, parm_idx, args,
5076 inner_args, arg_idx,
5080 /* Store this argument. */
5081 if (arg == error_mark_node)
5083 TREE_VEC_ELT (new_inner_args, parm_idx) = arg;
5085 /* We are done with all of the arguments. */
5090 else if (arg_idx < nargs)
5092 arg = TREE_VEC_ELT (inner_args, arg_idx);
5094 if (arg && PACK_EXPANSION_P (arg))
5096 /* If ARG is a pack expansion, but PARM is not a
5097 template parameter pack (if it were, we would have
5098 handled it above), we're trying to expand into a
5099 fixed-length argument list. */
5100 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
5101 error ("cannot expand %<%E%> into a fixed-length "
5102 "argument list", arg);
5104 error ("cannot expand %<%T%> into a fixed-length "
5105 "argument list", arg);
5106 return error_mark_node;
5109 else if (require_all_args)
5110 /* There must be a default arg in this case. */
5111 arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
5116 if (arg == error_mark_node)
5118 if (complain & tf_error)
5119 error ("template argument %d is invalid", arg_idx + 1);
5122 /* This only occurs if there was an error in the template
5123 parameter list itself (which we would already have
5124 reported) that we are trying to recover from, e.g., a class
5125 template with a parameter list such as
5126 template<typename..., typename>. */
5127 return error_mark_node;
5129 arg = convert_template_argument (TREE_VALUE (parm),
5130 arg, new_args, complain,
5133 if (arg == error_mark_node)
5135 TREE_VEC_ELT (new_inner_args, arg_idx) = arg;
5137 skip_evaluation = saved_skip_evaluation;
5140 return error_mark_node;
5142 return new_inner_args;
5145 /* Returns 1 if template args OT and NT are equivalent. */
5148 template_args_equal (tree ot, tree nt)
5153 if (TREE_CODE (nt) == TREE_VEC)
5154 /* For member templates */
5155 return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt);
5156 else if (PACK_EXPANSION_P (ot))
5157 return PACK_EXPANSION_P (nt)
5158 && template_args_equal (PACK_EXPANSION_PATTERN (ot),
5159 PACK_EXPANSION_PATTERN (nt));
5160 else if (TYPE_P (nt))
5161 return TYPE_P (ot) && same_type_p (ot, nt);
5162 else if (TREE_CODE (ot) == TREE_VEC || TYPE_P (ot))
5165 return cp_tree_equal (ot, nt);
5168 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
5169 of template arguments. Returns 0 otherwise. */
5172 comp_template_args (tree oldargs, tree newargs)
5176 oldargs = expand_template_argument_pack (oldargs);
5177 newargs = expand_template_argument_pack (newargs);
5179 if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
5182 for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
5184 tree nt = TREE_VEC_ELT (newargs, i);
5185 tree ot = TREE_VEC_ELT (oldargs, i);
5187 if (! template_args_equal (ot, nt))
5194 add_pending_template (tree d)
5196 tree ti = (TYPE_P (d)
5197 ? CLASSTYPE_TEMPLATE_INFO (d)
5198 : DECL_TEMPLATE_INFO (d));
5199 struct pending_template *pt;
5202 if (TI_PENDING_TEMPLATE_FLAG (ti))
5205 /* We are called both from instantiate_decl, where we've already had a
5206 tinst_level pushed, and instantiate_template, where we haven't.
5208 level = !current_tinst_level || current_tinst_level->decl != d;
5211 push_tinst_level (d);
5213 pt = GGC_NEW (struct pending_template);
5215 pt->tinst = current_tinst_level;
5216 if (last_pending_template)
5217 last_pending_template->next = pt;
5219 pending_templates = pt;
5221 last_pending_template = pt;
5223 TI_PENDING_TEMPLATE_FLAG (ti) = 1;
5230 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
5231 ARGLIST. Valid choices for FNS are given in the cp-tree.def
5232 documentation for TEMPLATE_ID_EXPR. */
5235 lookup_template_function (tree fns, tree arglist)
5239 if (fns == error_mark_node || arglist == error_mark_node)
5240 return error_mark_node;
5242 gcc_assert (!arglist || TREE_CODE (arglist) == TREE_VEC);
5243 gcc_assert (fns && (is_overloaded_fn (fns)
5244 || TREE_CODE (fns) == IDENTIFIER_NODE));
5246 if (BASELINK_P (fns))
5248 BASELINK_FUNCTIONS (fns) = build2 (TEMPLATE_ID_EXPR,
5250 BASELINK_FUNCTIONS (fns),
5255 type = TREE_TYPE (fns);
5256 if (TREE_CODE (fns) == OVERLOAD || !type)
5257 type = unknown_type_node;
5259 return build2 (TEMPLATE_ID_EXPR, type, fns, arglist);
5262 /* Within the scope of a template class S<T>, the name S gets bound
5263 (in build_self_reference) to a TYPE_DECL for the class, not a
5264 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
5265 or one of its enclosing classes, and that type is a template,
5266 return the associated TEMPLATE_DECL. Otherwise, the original
5267 DECL is returned. */
5270 maybe_get_template_decl_from_type_decl (tree decl)
5272 return (decl != NULL_TREE
5273 && TREE_CODE (decl) == TYPE_DECL
5274 && DECL_ARTIFICIAL (decl)
5275 && CLASS_TYPE_P (TREE_TYPE (decl))
5276 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
5277 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl;
5280 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
5281 parameters, find the desired type.
5283 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
5285 IN_DECL, if non-NULL, is the template declaration we are trying to
5288 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
5289 the class we are looking up.
5291 Issue error and warning messages under control of COMPLAIN.
5293 If the template class is really a local class in a template
5294 function, then the FUNCTION_CONTEXT is the function in which it is
5297 ??? Note that this function is currently called *twice* for each
5298 template-id: the first time from the parser, while creating the
5299 incomplete type (finish_template_type), and the second type during the
5300 real instantiation (instantiate_template_class). This is surely something
5301 that we want to avoid. It also causes some problems with argument
5302 coercion (see convert_nontype_argument for more information on this). */
5305 lookup_template_class (tree d1,
5310 tsubst_flags_t complain)
5312 tree template = NULL_TREE, parmlist;
5315 timevar_push (TV_NAME_LOOKUP);
5317 if (TREE_CODE (d1) == IDENTIFIER_NODE)
5319 tree value = innermost_non_namespace_value (d1);
5320 if (value && DECL_TEMPLATE_TEMPLATE_PARM_P (value))
5325 push_decl_namespace (context);
5326 template = lookup_name (d1);
5327 template = maybe_get_template_decl_from_type_decl (template);
5329 pop_decl_namespace ();
5332 context = DECL_CONTEXT (template);
5334 else if (TREE_CODE (d1) == TYPE_DECL && IS_AGGR_TYPE (TREE_TYPE (d1)))
5336 tree type = TREE_TYPE (d1);
5338 /* If we are declaring a constructor, say A<T>::A<T>, we will get
5339 an implicit typename for the second A. Deal with it. */
5340 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5341 type = TREE_TYPE (type);
5343 if (CLASSTYPE_TEMPLATE_INFO (type))
5345 template = CLASSTYPE_TI_TEMPLATE (type);
5346 d1 = DECL_NAME (template);
5349 else if (TREE_CODE (d1) == ENUMERAL_TYPE
5350 || (TYPE_P (d1) && IS_AGGR_TYPE (d1)))
5352 template = TYPE_TI_TEMPLATE (d1);
5353 d1 = DECL_NAME (template);
5355 else if (TREE_CODE (d1) == TEMPLATE_DECL
5356 && TREE_CODE (DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL)
5359 d1 = DECL_NAME (template);
5360 context = DECL_CONTEXT (template);
5363 /* Issue an error message if we didn't find a template. */
5366 if (complain & tf_error)
5367 error ("%qT is not a template", d1);
5368 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5371 if (TREE_CODE (template) != TEMPLATE_DECL
5372 /* Make sure it's a user visible template, if it was named by
5374 || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (template)
5375 && !PRIMARY_TEMPLATE_P (template)))
5377 if (complain & tf_error)
5379 error ("non-template type %qT used as a template", d1);
5381 error ("for template declaration %q+D", in_decl);
5383 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5386 complain &= ~tf_user;
5388 if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
5390 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
5391 template arguments */
5396 parmlist = DECL_INNERMOST_TEMPLATE_PARMS (template);
5398 /* Consider an example where a template template parameter declared as
5400 template <class T, class U = std::allocator<T> > class TT
5402 The template parameter level of T and U are one level larger than
5403 of TT. To proper process the default argument of U, say when an
5404 instantiation `TT<int>' is seen, we need to build the full
5405 arguments containing {int} as the innermost level. Outer levels,
5406 available when not appearing as default template argument, can be
5407 obtained from `current_template_args ()'.
5409 Suppose that TT is later substituted with std::vector. The above
5410 instantiation is `TT<int, std::allocator<T> >' with TT at
5411 level 1, and T at level 2, while the template arguments at level 1
5412 becomes {std::vector} and the inner level 2 is {int}. */
5414 if (current_template_parms)
5415 arglist = add_to_template_args (current_template_args (), arglist);
5417 arglist2 = coerce_template_parms (parmlist, arglist, template,
5419 /*require_all_args=*/true,
5420 /*use_default_args=*/true);
5421 if (arglist2 == error_mark_node
5422 || (!uses_template_parms (arglist2)
5423 && check_instantiated_args (template, arglist2, complain)))
5424 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5426 parm = bind_template_template_parm (TREE_TYPE (template), arglist2);
5427 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, parm);
5431 tree template_type = TREE_TYPE (template);
5434 tree found = NULL_TREE;
5437 int is_partial_instantiation;
5439 gen_tmpl = most_general_template (template);
5440 parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
5441 parm_depth = TMPL_PARMS_DEPTH (parmlist);
5442 arg_depth = TMPL_ARGS_DEPTH (arglist);
5444 if (arg_depth == 1 && parm_depth > 1)
5446 /* We've been given an incomplete set of template arguments.
5449 template <class T> struct S1 {
5450 template <class U> struct S2 {};
5451 template <class U> struct S2<U*> {};
5454 we will be called with an ARGLIST of `U*', but the
5455 TEMPLATE will be `template <class T> template
5456 <class U> struct S1<T>::S2'. We must fill in the missing
5459 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)),
5461 arg_depth = TMPL_ARGS_DEPTH (arglist);
5464 /* Now we should have enough arguments. */
5465 gcc_assert (parm_depth == arg_depth);
5467 /* From here on, we're only interested in the most general
5469 template = gen_tmpl;
5471 /* Calculate the BOUND_ARGS. These will be the args that are
5472 actually tsubst'd into the definition to create the
5476 /* We have multiple levels of arguments to coerce, at once. */
5478 int saved_depth = TMPL_ARGS_DEPTH (arglist);
5480 tree bound_args = make_tree_vec (parm_depth);
5482 for (i = saved_depth,
5483 t = DECL_TEMPLATE_PARMS (template);
5484 i > 0 && t != NULL_TREE;
5485 --i, t = TREE_CHAIN (t))
5487 tree a = coerce_template_parms (TREE_VALUE (t),
5490 /*require_all_args=*/true,
5491 /*use_default_args=*/true);
5493 /* Don't process further if one of the levels fails. */
5494 if (a == error_mark_node)
5496 /* Restore the ARGLIST to its full size. */
5497 TREE_VEC_LENGTH (arglist) = saved_depth;
5498 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5501 SET_TMPL_ARGS_LEVEL (bound_args, i, a);
5503 /* We temporarily reduce the length of the ARGLIST so
5504 that coerce_template_parms will see only the arguments
5505 corresponding to the template parameters it is
5507 TREE_VEC_LENGTH (arglist)--;
5510 /* Restore the ARGLIST to its full size. */
5511 TREE_VEC_LENGTH (arglist) = saved_depth;
5513 arglist = bound_args;
5517 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist),
5518 INNERMOST_TEMPLATE_ARGS (arglist),
5521 /*require_all_args=*/true,
5522 /*use_default_args=*/true);
5524 if (arglist == error_mark_node)
5525 /* We were unable to bind the arguments. */
5526 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5528 /* In the scope of a template class, explicit references to the
5529 template class refer to the type of the template, not any
5530 instantiation of it. For example, in:
5532 template <class T> class C { void f(C<T>); }
5534 the `C<T>' is just the same as `C'. Outside of the
5535 class, however, such a reference is an instantiation. */
5536 if (comp_template_args (TYPE_TI_ARGS (template_type),
5539 found = template_type;
5541 if (!entering_scope && PRIMARY_TEMPLATE_P (template))
5545 for (ctx = current_class_type;
5546 ctx && TREE_CODE (ctx) != NAMESPACE_DECL;
5548 ? TYPE_CONTEXT (ctx)
5549 : DECL_CONTEXT (ctx)))
5550 if (TYPE_P (ctx) && same_type_p (ctx, template_type))
5553 /* We're not in the scope of the class, so the
5554 TEMPLATE_TYPE is not the type we want after all. */
5560 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
5562 /* If we already have this specialization, return it. */
5563 found = retrieve_specialization (template, arglist,
5564 /*class_specializations_p=*/false);
5566 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
5568 /* This type is a "partial instantiation" if any of the template
5569 arguments still involve template parameters. Note that we set
5570 IS_PARTIAL_INSTANTIATION for partial specializations as
5572 is_partial_instantiation = uses_template_parms (arglist);
5574 /* If the deduced arguments are invalid, then the binding
5576 if (!is_partial_instantiation
5577 && check_instantiated_args (template,
5578 INNERMOST_TEMPLATE_ARGS (arglist),
5580 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5582 if (!is_partial_instantiation
5583 && !PRIMARY_TEMPLATE_P (template)
5584 && TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL)
5586 found = xref_tag_from_type (TREE_TYPE (template),
5587 DECL_NAME (template),
5588 /*tag_scope=*/ts_global);
5589 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
5592 context = tsubst (DECL_CONTEXT (template), arglist,
5595 context = global_namespace;
5597 /* Create the type. */
5598 if (TREE_CODE (template_type) == ENUMERAL_TYPE)
5600 if (!is_partial_instantiation)
5602 set_current_access_from_decl (TYPE_NAME (template_type));
5603 t = start_enum (TYPE_IDENTIFIER (template_type));
5606 /* We don't want to call start_enum for this type, since
5607 the values for the enumeration constants may involve
5608 template parameters. And, no one should be interested
5609 in the enumeration constants for such a type. */
5610 t = make_node (ENUMERAL_TYPE);
5614 t = make_aggr_type (TREE_CODE (template_type));
5615 CLASSTYPE_DECLARED_CLASS (t)
5616 = CLASSTYPE_DECLARED_CLASS (template_type);
5617 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
5618 TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);
5620 /* A local class. Make sure the decl gets registered properly. */
5621 if (context == current_function_decl)
5622 pushtag (DECL_NAME (template), t, /*tag_scope=*/ts_current);
5624 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type), arglist))
5625 /* This instantiation is another name for the primary
5626 template type. Set the TYPE_CANONICAL field
5628 TYPE_CANONICAL (t) = template_type;
5629 else if (any_template_arguments_need_structural_equality_p (arglist))
5630 /* Some of the template arguments require structural
5631 equality testing, so this template class requires
5632 structural equality testing. */
5633 SET_TYPE_STRUCTURAL_EQUALITY (t);
5636 /* If we called start_enum or pushtag above, this information
5637 will already be set up. */
5640 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5642 type_decl = create_implicit_typedef (DECL_NAME (template), t);
5643 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
5644 TYPE_STUB_DECL (t) = type_decl;
5645 DECL_SOURCE_LOCATION (type_decl)
5646 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type));
5649 type_decl = TYPE_NAME (t);
5651 TREE_PRIVATE (type_decl)
5652 = TREE_PRIVATE (TYPE_STUB_DECL (template_type));
5653 TREE_PROTECTED (type_decl)
5654 = TREE_PROTECTED (TYPE_STUB_DECL (template_type));
5655 DECL_IN_SYSTEM_HEADER (type_decl)
5656 = DECL_IN_SYSTEM_HEADER (template);
5657 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type))
5659 DECL_VISIBILITY_SPECIFIED (type_decl) = 1;
5660 DECL_VISIBILITY (type_decl) = CLASSTYPE_VISIBILITY (template_type);
5663 /* Set up the template information. We have to figure out which
5664 template is the immediate parent if this is a full
5666 if (parm_depth == 1 || is_partial_instantiation
5667 || !PRIMARY_TEMPLATE_P (template))
5668 /* This case is easy; there are no member templates involved. */
5672 /* This is a full instantiation of a member template. Look
5673 for a partial instantiation of which this is an instance. */
5675 for (found = DECL_TEMPLATE_INSTANTIATIONS (template);
5676 found; found = TREE_CHAIN (found))
5679 tree tmpl = CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found));
5681 /* We only want partial instantiations, here, not
5682 specializations or full instantiations. */
5683 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found))
5684 || !uses_template_parms (TREE_VALUE (found)))
5687 /* Temporarily reduce by one the number of levels in the
5688 ARGLIST and in FOUND so as to avoid comparing the
5689 last set of arguments. */
5690 TREE_VEC_LENGTH (arglist)--;
5691 TREE_VEC_LENGTH (TREE_PURPOSE (found)) --;
5693 /* See if the arguments match. If they do, then TMPL is
5694 the partial instantiation we want. */
5695 success = comp_template_args (TREE_PURPOSE (found), arglist);
5697 /* Restore the argument vectors to their full size. */
5698 TREE_VEC_LENGTH (arglist)++;
5699 TREE_VEC_LENGTH (TREE_PURPOSE (found))++;
5710 /* There was no partial instantiation. This happens
5711 where C<T> is a member template of A<T> and it's used
5714 template <typename T> struct B { A<T>::C<int> m; };
5717 Create the partial instantiation.
5719 TREE_VEC_LENGTH (arglist)--;
5720 found = tsubst (template, arglist, complain, NULL_TREE);
5721 TREE_VEC_LENGTH (arglist)++;
5725 SET_TYPE_TEMPLATE_INFO (t, tree_cons (found, arglist, NULL_TREE));
5726 DECL_TEMPLATE_INSTANTIATIONS (template)
5727 = tree_cons (arglist, t,
5728 DECL_TEMPLATE_INSTANTIATIONS (template));
5730 if (TREE_CODE (t) == ENUMERAL_TYPE
5731 && !is_partial_instantiation)
5732 /* Now that the type has been registered on the instantiations
5733 list, we set up the enumerators. Because the enumeration
5734 constants may involve the enumeration type itself, we make
5735 sure to register the type first, and then create the
5736 constants. That way, doing tsubst_expr for the enumeration
5737 constants won't result in recursive calls here; we'll find
5738 the instantiation and exit above. */
5739 tsubst_enum (template_type, t, arglist);
5741 if (is_partial_instantiation)
5742 /* If the type makes use of template parameters, the
5743 code that generates debugging information will crash. */
5744 DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1;
5746 /* Possibly limit visibility based on template args. */
5747 TREE_PUBLIC (type_decl) = 1;
5748 determine_visibility (type_decl);
5750 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
5752 timevar_pop (TV_NAME_LOOKUP);
5759 struct pointer_set_t *visited;
5762 /* Called from for_each_template_parm via walk_tree. */
5765 for_each_template_parm_r (tree *tp, int *walk_subtrees, void *d)
5768 struct pair_fn_data *pfd = (struct pair_fn_data *) d;
5769 tree_fn_t fn = pfd->fn;
5770 void *data = pfd->data;
5773 && for_each_template_parm (TYPE_CONTEXT (t), fn, data, pfd->visited))
5774 return error_mark_node;
5776 switch (TREE_CODE (t))
5779 if (TYPE_PTRMEMFUNC_P (t))
5785 if (!TYPE_TEMPLATE_INFO (t))
5787 else if (for_each_template_parm (TREE_VALUE (TYPE_TEMPLATE_INFO (t)),
5788 fn, data, pfd->visited))
5789 return error_mark_node;
5793 if (for_each_template_parm (TYPE_MIN_VALUE (t),
5794 fn, data, pfd->visited)
5795 || for_each_template_parm (TYPE_MAX_VALUE (t),
5796 fn, data, pfd->visited))
5797 return error_mark_node;
5801 /* Since we're not going to walk subtrees, we have to do this
5803 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data,
5805 return error_mark_node;
5809 /* Check the return type. */
5810 if (for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
5811 return error_mark_node;
5813 /* Check the parameter types. Since default arguments are not
5814 instantiated until they are needed, the TYPE_ARG_TYPES may
5815 contain expressions that involve template parameters. But,
5816 no-one should be looking at them yet. And, once they're
5817 instantiated, they don't contain template parameters, so
5818 there's no point in looking at them then, either. */
5822 for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm))
5823 if (for_each_template_parm (TREE_VALUE (parm), fn, data,
5825 return error_mark_node;
5827 /* Since we've already handled the TYPE_ARG_TYPES, we don't
5828 want walk_tree walking into them itself. */
5834 if (for_each_template_parm (TYPE_FIELDS (t), fn, data,
5836 return error_mark_node;
5841 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
5842 && for_each_template_parm (DECL_TI_ARGS (t), fn, data,
5844 return error_mark_node;
5849 if (TREE_CODE (t) == CONST_DECL && DECL_TEMPLATE_PARM_P (t)
5850 && for_each_template_parm (DECL_INITIAL (t), fn, data,
5852 return error_mark_node;
5853 if (DECL_CONTEXT (t)
5854 && for_each_template_parm (DECL_CONTEXT (t), fn, data,
5856 return error_mark_node;
5859 case BOUND_TEMPLATE_TEMPLATE_PARM:
5860 /* Record template parameters such as `T' inside `TT<T>'. */
5861 if (for_each_template_parm (TYPE_TI_ARGS (t), fn, data, pfd->visited))
5862 return error_mark_node;
5865 case TEMPLATE_TEMPLATE_PARM:
5866 case TEMPLATE_TYPE_PARM:
5867 case TEMPLATE_PARM_INDEX:
5868 if (fn && (*fn)(t, data))
5869 return error_mark_node;
5871 return error_mark_node;
5875 /* A template template parameter is encountered. */
5876 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)
5877 && for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
5878 return error_mark_node;
5880 /* Already substituted template template parameter */
5886 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t), fn,
5887 data, pfd->visited))
5888 return error_mark_node;
5892 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))
5893 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
5894 (TREE_TYPE (t)), fn, data,
5896 return error_mark_node;
5901 /* If there's no type, then this thing must be some expression
5902 involving template parameters. */
5903 if (!fn && !TREE_TYPE (t))
5904 return error_mark_node;
5909 case REINTERPRET_CAST_EXPR:
5910 case CONST_CAST_EXPR:
5911 case STATIC_CAST_EXPR:
5912 case DYNAMIC_CAST_EXPR:
5916 case PSEUDO_DTOR_EXPR:
5918 return error_mark_node;
5925 /* We didn't find any template parameters we liked. */
5929 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
5930 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
5931 call FN with the parameter and the DATA.
5932 If FN returns nonzero, the iteration is terminated, and
5933 for_each_template_parm returns 1. Otherwise, the iteration
5934 continues. If FN never returns a nonzero value, the value
5935 returned by for_each_template_parm is 0. If FN is NULL, it is
5936 considered to be the function which always returns 1. */
5939 for_each_template_parm (tree t, tree_fn_t fn, void* data,
5940 struct pointer_set_t *visited)
5942 struct pair_fn_data pfd;
5949 /* Walk the tree. (Conceptually, we would like to walk without
5950 duplicates, but for_each_template_parm_r recursively calls
5951 for_each_template_parm, so we would need to reorganize a fair
5952 bit to use walk_tree_without_duplicates, so we keep our own
5955 pfd.visited = visited;
5957 pfd.visited = pointer_set_create ();
5958 result = cp_walk_tree (&t,
5959 for_each_template_parm_r,
5961 pfd.visited) != NULL_TREE;
5966 pointer_set_destroy (pfd.visited);
5973 /* Returns true if T depends on any template parameter. */
5976 uses_template_parms (tree t)
5979 int saved_processing_template_decl;
5981 saved_processing_template_decl = processing_template_decl;
5982 if (!saved_processing_template_decl)
5983 processing_template_decl = 1;
5985 dependent_p = dependent_type_p (t);
5986 else if (TREE_CODE (t) == TREE_VEC)
5987 dependent_p = any_dependent_template_arguments_p (t);
5988 else if (TREE_CODE (t) == TREE_LIST)
5989 dependent_p = (uses_template_parms (TREE_VALUE (t))
5990 || uses_template_parms (TREE_CHAIN (t)));
5991 else if (TREE_CODE (t) == TYPE_DECL)
5992 dependent_p = dependent_type_p (TREE_TYPE (t));
5995 || TREE_CODE (t) == TEMPLATE_PARM_INDEX
5996 || TREE_CODE (t) == OVERLOAD
5997 || TREE_CODE (t) == BASELINK
5998 || TREE_CODE (t) == IDENTIFIER_NODE
5999 || TREE_CODE (t) == TRAIT_EXPR
6000 || CONSTANT_CLASS_P (t))
6001 dependent_p = (type_dependent_expression_p (t)
6002 || value_dependent_expression_p (t));
6005 gcc_assert (t == error_mark_node);
6006 dependent_p = false;
6009 processing_template_decl = saved_processing_template_decl;
6014 /* Returns true if T depends on any template parameter with level LEVEL. */
6017 uses_template_parms_level (tree t, int level)
6019 return for_each_template_parm (t, template_parm_this_level_p, &level, NULL);
6022 static int tinst_depth;
6023 extern int max_tinst_depth;
6024 #ifdef GATHER_STATISTICS
6027 static int tinst_level_tick;
6028 static int last_template_error_tick;
6030 /* We're starting to instantiate D; record the template instantiation context
6031 for diagnostics and to restore it later. */
6034 push_tinst_level (tree d)
6036 struct tinst_level *new;
6038 if (tinst_depth >= max_tinst_depth)
6040 /* If the instantiation in question still has unbound template parms,
6041 we don't really care if we can't instantiate it, so just return.
6042 This happens with base instantiation for implicit `typename'. */
6043 if (uses_template_parms (d))
6046 last_template_error_tick = tinst_level_tick;
6047 error ("template instantiation depth exceeds maximum of %d (use "
6048 "-ftemplate-depth-NN to increase the maximum) instantiating %qD",
6049 max_tinst_depth, d);
6051 print_instantiation_context ();
6056 new = GGC_NEW (struct tinst_level);
6058 new->locus = input_location;
6059 new->in_system_header_p = in_system_header;
6060 new->next = current_tinst_level;
6061 current_tinst_level = new;
6064 #ifdef GATHER_STATISTICS
6065 if (tinst_depth > depth_reached)
6066 depth_reached = tinst_depth;
6073 /* We're done instantiating this template; return to the instantiation
6077 pop_tinst_level (void)
6079 /* Restore the filename and line number stashed away when we started
6080 this instantiation. */
6081 input_location = current_tinst_level->locus;
6082 in_system_header = current_tinst_level->in_system_header_p;
6083 current_tinst_level = current_tinst_level->next;
6088 /* We're instantiating a deferred template; restore the template
6089 instantiation context in which the instantiation was requested, which
6090 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
6093 reopen_tinst_level (struct tinst_level *level)
6095 struct tinst_level *t;
6098 for (t = level; t; t = t->next)
6101 current_tinst_level = level;
6106 /* Returns the TINST_LEVEL which gives the original instantiation
6109 struct tinst_level *
6110 outermost_tinst_level (void)
6112 struct tinst_level *level = current_tinst_level;
6115 level = level->next;
6119 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
6120 vector of template arguments, as for tsubst.
6122 Returns an appropriate tsubst'd friend declaration. */
6125 tsubst_friend_function (tree decl, tree args)
6129 if (TREE_CODE (decl) == FUNCTION_DECL
6130 && DECL_TEMPLATE_INSTANTIATION (decl)
6131 && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
6132 /* This was a friend declared with an explicit template
6133 argument list, e.g.:
6137 to indicate that f was a template instantiation, not a new
6138 function declaration. Now, we have to figure out what
6139 instantiation of what template. */
6141 tree template_id, arglist, fns;
6144 tree ns = decl_namespace_context (TYPE_MAIN_DECL (current_class_type));
6146 /* Friend functions are looked up in the containing namespace scope.
6147 We must enter that scope, to avoid finding member functions of the
6148 current cless with same name. */
6149 push_nested_namespace (ns);
6150 fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args,
6151 tf_warning_or_error, NULL_TREE,
6152 /*integral_constant_expression_p=*/false);
6153 pop_nested_namespace (ns);
6154 arglist = tsubst (DECL_TI_ARGS (decl), args,
6155 tf_warning_or_error, NULL_TREE);
6156 template_id = lookup_template_function (fns, arglist);
6158 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
6159 tmpl = determine_specialization (template_id, new_friend,
6161 /*need_member_template=*/0,
6162 TREE_VEC_LENGTH (args),
6164 return instantiate_template (tmpl, new_args, tf_error);
6167 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
6169 /* The NEW_FRIEND will look like an instantiation, to the
6170 compiler, but is not an instantiation from the point of view of
6171 the language. For example, we might have had:
6173 template <class T> struct S {
6174 template <class U> friend void f(T, U);
6177 Then, in S<int>, template <class U> void f(int, U) is not an
6178 instantiation of anything. */
6179 if (new_friend == error_mark_node)
6180 return error_mark_node;
6182 DECL_USE_TEMPLATE (new_friend) = 0;
6183 if (TREE_CODE (decl) == TEMPLATE_DECL)
6185 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0;
6186 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend))
6187 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
6190 /* The mangled name for the NEW_FRIEND is incorrect. The function
6191 is not a template instantiation and should not be mangled like
6192 one. Therefore, we forget the mangling here; we'll recompute it
6193 later if we need it. */
6194 if (TREE_CODE (new_friend) != TEMPLATE_DECL)
6196 SET_DECL_RTL (new_friend, NULL_RTX);
6197 SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE);
6200 if (DECL_NAMESPACE_SCOPE_P (new_friend))
6203 tree new_friend_template_info;
6204 tree new_friend_result_template_info;
6206 int new_friend_is_defn;
6208 /* We must save some information from NEW_FRIEND before calling
6209 duplicate decls since that function will free NEW_FRIEND if
6211 new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
6212 new_friend_is_defn =
6213 (DECL_INITIAL (DECL_TEMPLATE_RESULT
6214 (template_for_substitution (new_friend)))
6216 if (TREE_CODE (new_friend) == TEMPLATE_DECL)
6218 /* This declaration is a `primary' template. */
6219 DECL_PRIMARY_TEMPLATE (new_friend) = new_friend;
6221 new_friend_result_template_info
6222 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend));
6225 new_friend_result_template_info = NULL_TREE;
6227 /* Make the init_value nonzero so pushdecl knows this is a defn. */
6228 if (new_friend_is_defn)
6229 DECL_INITIAL (new_friend) = error_mark_node;
6231 /* Inside pushdecl_namespace_level, we will push into the
6232 current namespace. However, the friend function should go
6233 into the namespace of the template. */
6234 ns = decl_namespace_context (new_friend);
6235 push_nested_namespace (ns);
6236 old_decl = pushdecl_namespace_level (new_friend, /*is_friend=*/true);
6237 pop_nested_namespace (ns);
6239 if (old_decl == error_mark_node)
6240 return error_mark_node;
6242 if (old_decl != new_friend)
6244 /* This new friend declaration matched an existing
6245 declaration. For example, given:
6247 template <class T> void f(T);
6248 template <class U> class C {
6249 template <class T> friend void f(T) {}
6252 the friend declaration actually provides the definition
6253 of `f', once C has been instantiated for some type. So,
6254 old_decl will be the out-of-class template declaration,
6255 while new_friend is the in-class definition.
6257 But, if `f' was called before this point, the
6258 instantiation of `f' will have DECL_TI_ARGS corresponding
6259 to `T' but not to `U', references to which might appear
6260 in the definition of `f'. Previously, the most general
6261 template for an instantiation of `f' was the out-of-class
6262 version; now it is the in-class version. Therefore, we
6263 run through all specialization of `f', adding to their
6264 DECL_TI_ARGS appropriately. In particular, they need a
6265 new set of outer arguments, corresponding to the
6266 arguments for this class instantiation.
6268 The same situation can arise with something like this:
6271 template <class T> class C {
6275 when `C<int>' is instantiated. Now, `f(int)' is defined
6278 if (!new_friend_is_defn)
6279 /* On the other hand, if the in-class declaration does
6280 *not* provide a definition, then we don't want to alter
6281 existing definitions. We can just leave everything
6286 /* Overwrite whatever template info was there before, if
6287 any, with the new template information pertaining to
6289 DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
6291 if (TREE_CODE (old_decl) != TEMPLATE_DECL)
6292 reregister_specialization (new_friend,
6293 most_general_template (old_decl),
6298 tree new_friend_args;
6300 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl))
6301 = new_friend_result_template_info;
6303 new_friend_args = TI_ARGS (new_friend_template_info);
6304 for (t = DECL_TEMPLATE_SPECIALIZATIONS (old_decl);
6308 tree spec = TREE_VALUE (t);
6311 = add_outermost_template_args (new_friend_args,
6312 DECL_TI_ARGS (spec));
6315 /* Now, since specializations are always supposed to
6316 hang off of the most general template, we must move
6318 t = most_general_template (old_decl);
6321 DECL_TEMPLATE_SPECIALIZATIONS (t)
6322 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t),
6323 DECL_TEMPLATE_SPECIALIZATIONS (old_decl));
6324 DECL_TEMPLATE_SPECIALIZATIONS (old_decl) = NULL_TREE;
6329 /* The information from NEW_FRIEND has been merged into OLD_DECL
6330 by duplicate_decls. */
6331 new_friend = old_decl;
6336 tree context = DECL_CONTEXT (new_friend);
6340 template <class T> class C {
6341 template <class U> friend void C1<U>::f (); // case 1
6342 friend void C2<T>::f (); // case 2
6344 we only need to make sure CONTEXT is a complete type for
6345 case 2. To distinguish between the two cases, we note that
6346 CONTEXT of case 1 remains dependent type after tsubst while
6347 this isn't true for case 2. */
6348 ++processing_template_decl;
6349 dependent_p = dependent_type_p (context);
6350 --processing_template_decl;
6353 && !complete_type_or_else (context, NULL_TREE))
6354 return error_mark_node;
6356 if (COMPLETE_TYPE_P (context))
6358 /* Check to see that the declaration is really present, and,
6359 possibly obtain an improved declaration. */
6360 tree fn = check_classfn (context,
6361 new_friend, NULL_TREE);
6371 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
6372 template arguments, as for tsubst.
6374 Returns an appropriate tsubst'd friend type or error_mark_node on
6378 tsubst_friend_class (tree friend_tmpl, tree args)
6384 context = DECL_CONTEXT (friend_tmpl);
6388 if (TREE_CODE (context) == NAMESPACE_DECL)
6389 push_nested_namespace (context);
6391 push_nested_class (tsubst (context, args, tf_none, NULL_TREE));
6394 /* Look for a class template declaration. We look for hidden names
6395 because two friend declarations of the same template are the
6396 same. For example, in:
6399 template <typename> friend class F;
6401 template <typename> struct B {
6402 template <typename> friend class F;
6405 both F templates are the same. */
6406 tmpl = lookup_name_real (DECL_NAME (friend_tmpl), 0, 0,
6407 /*block_p=*/true, 0,
6408 LOOKUP_COMPLAIN | LOOKUP_HIDDEN);
6410 /* But, if we don't find one, it might be because we're in a
6411 situation like this:
6419 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
6420 for `S<int>', not the TEMPLATE_DECL. */
6421 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
6423 tmpl = lookup_name_prefer_type (DECL_NAME (friend_tmpl), 1);
6424 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
6427 if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
6429 /* The friend template has already been declared. Just
6430 check to see that the declarations match, and install any new
6431 default parameters. We must tsubst the default parameters,
6432 of course. We only need the innermost template parameters
6433 because that is all that redeclare_class_template will look
6435 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl))
6436 > TMPL_ARGS_DEPTH (args))
6439 parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
6440 args, tf_warning_or_error);
6441 redeclare_class_template (TREE_TYPE (tmpl), parms);
6444 friend_type = TREE_TYPE (tmpl);
6448 /* The friend template has not already been declared. In this
6449 case, the instantiation of the template class will cause the
6450 injection of this template into the global scope. */
6451 tmpl = tsubst (friend_tmpl, args, tf_warning_or_error, NULL_TREE);
6452 if (tmpl == error_mark_node)
6453 return error_mark_node;
6455 /* The new TMPL is not an instantiation of anything, so we
6456 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
6457 the new type because that is supposed to be the corresponding
6458 template decl, i.e., TMPL. */
6459 DECL_USE_TEMPLATE (tmpl) = 0;
6460 DECL_TEMPLATE_INFO (tmpl) = NULL_TREE;
6461 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0;
6462 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl))
6463 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)));
6465 /* Inject this template into the global scope. */
6466 friend_type = TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl, true));
6471 if (TREE_CODE (context) == NAMESPACE_DECL)
6472 pop_nested_namespace (context);
6474 pop_nested_class ();
6480 /* Returns zero if TYPE cannot be completed later due to circularity.
6481 Otherwise returns one. */
6484 can_complete_type_without_circularity (tree type)
6486 if (type == NULL_TREE || type == error_mark_node)
6488 else if (COMPLETE_TYPE_P (type))
6490 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
6491 return can_complete_type_without_circularity (TREE_TYPE (type));
6492 else if (CLASS_TYPE_P (type)
6493 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type)))
6499 /* Apply any attributes which had to be deferred until instantiation
6500 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
6501 ARGS, COMPLAIN, IN_DECL are as tsubst. */
6504 apply_late_template_attributes (tree *decl_p, tree attributes, int attr_flags,
6505 tree args, tsubst_flags_t complain, tree in_decl)
6507 tree last_dep = NULL_TREE;
6511 for (t = attributes; t; t = TREE_CHAIN (t))
6512 if (ATTR_IS_DEPENDENT (t))
6515 attributes = copy_list (attributes);
6519 if (DECL_P (*decl_p))
6520 p = &DECL_ATTRIBUTES (*decl_p);
6522 p = &TYPE_ATTRIBUTES (*decl_p);
6526 tree late_attrs = NULL_TREE;
6527 tree *q = &late_attrs;
6529 for (*p = attributes; *p; )
6532 if (ATTR_IS_DEPENDENT (t))
6534 *p = TREE_CHAIN (t);
6535 TREE_CHAIN (t) = NULL_TREE;
6537 = tsubst_expr (TREE_VALUE (t), args, complain, in_decl,
6538 /*integral_constant_expression_p=*/false);
6540 q = &TREE_CHAIN (t);
6543 p = &TREE_CHAIN (t);
6546 cplus_decl_attributes (decl_p, late_attrs, attr_flags);
6551 instantiate_class_template (tree type)
6553 tree template, args, pattern, t, member;
6558 if (type == error_mark_node)
6559 return error_mark_node;
6561 if (TYPE_BEING_DEFINED (type)
6562 || COMPLETE_TYPE_P (type)
6563 || dependent_type_p (type))
6566 /* Figure out which template is being instantiated. */
6567 template = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
6568 gcc_assert (TREE_CODE (template) == TEMPLATE_DECL);
6570 /* Determine what specialization of the original template to
6572 t = most_specialized_class (type, template);
6573 if (t == error_mark_node)
6575 TYPE_BEING_DEFINED (type) = 1;
6576 return error_mark_node;
6580 /* This TYPE is actually an instantiation of a partial
6581 specialization. We replace the innermost set of ARGS with
6582 the arguments appropriate for substitution. For example,
6585 template <class T> struct S {};
6586 template <class T> struct S<T*> {};
6588 and supposing that we are instantiating S<int*>, ARGS will
6589 presently be {int*} -- but we need {int}. */
6590 pattern = TREE_TYPE (t);
6591 args = TREE_PURPOSE (t);
6595 pattern = TREE_TYPE (template);
6596 args = CLASSTYPE_TI_ARGS (type);
6599 /* If the template we're instantiating is incomplete, then clearly
6600 there's nothing we can do. */
6601 if (!COMPLETE_TYPE_P (pattern))
6604 /* If we've recursively instantiated too many templates, stop. */
6605 if (! push_tinst_level (type))
6608 /* Now we're really doing the instantiation. Mark the type as in
6609 the process of being defined. */
6610 TYPE_BEING_DEFINED (type) = 1;
6612 /* We may be in the middle of deferred access check. Disable
6614 push_deferring_access_checks (dk_no_deferred);
6616 push_to_top_level ();
6618 SET_CLASSTYPE_INTERFACE_UNKNOWN (type);
6620 /* Set the input location to the template definition. This is needed
6621 if tsubsting causes an error. */
6622 typedecl = TYPE_MAIN_DECL (type);
6623 input_location = DECL_SOURCE_LOCATION (typedecl);
6624 in_system_header = DECL_IN_SYSTEM_HEADER (typedecl);
6626 TYPE_HAS_CONSTRUCTOR (type) = TYPE_HAS_CONSTRUCTOR (pattern);
6627 TYPE_HAS_NEW_OPERATOR (type) = TYPE_HAS_NEW_OPERATOR (pattern);
6628 TYPE_HAS_ARRAY_NEW_OPERATOR (type) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern);
6629 TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern);
6630 TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern);
6631 TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern);
6632 TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern);
6633 TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern);
6634 TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern);
6635 TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern);
6636 TYPE_PACKED (type) = TYPE_PACKED (pattern);
6637 TYPE_ALIGN (type) = TYPE_ALIGN (pattern);
6638 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);
6639 TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */
6640 if (ANON_AGGR_TYPE_P (pattern))
6641 SET_ANON_AGGR_TYPE_P (type);
6642 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern))
6644 CLASSTYPE_VISIBILITY_SPECIFIED (type) = 1;
6645 CLASSTYPE_VISIBILITY (type) = CLASSTYPE_VISIBILITY (pattern);
6648 pbinfo = TYPE_BINFO (pattern);
6650 /* We should never instantiate a nested class before its enclosing
6651 class; we need to look up the nested class by name before we can
6652 instantiate it, and that lookup should instantiate the enclosing
6654 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))
6655 || COMPLETE_TYPE_P (TYPE_CONTEXT (type))
6656 || TYPE_BEING_DEFINED (TYPE_CONTEXT (type)));
6658 base_list = NULL_TREE;
6659 if (BINFO_N_BASE_BINFOS (pbinfo))
6662 tree context = TYPE_CONTEXT (type);
6666 /* We must enter the scope containing the type, as that is where
6667 the accessibility of types named in dependent bases are
6669 pushed_scope = push_scope (context ? context : global_namespace);
6671 /* Substitute into each of the bases to determine the actual
6673 for (i = 0; BINFO_BASE_ITERATE (pbinfo, i, pbase_binfo); i++)
6676 tree access = BINFO_BASE_ACCESS (pbinfo, i);
6677 tree expanded_bases = NULL_TREE;
6680 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo)))
6683 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo),
6684 args, tf_error, NULL_TREE);
6685 if (expanded_bases == error_mark_node)
6688 len = TREE_VEC_LENGTH (expanded_bases);
6691 for (idx = 0; idx < len; idx++)
6694 /* Extract the already-expanded base class. */
6695 base = TREE_VEC_ELT (expanded_bases, idx);
6697 /* Substitute to figure out the base class. */
6698 base = tsubst (BINFO_TYPE (pbase_binfo), args, tf_error,
6701 if (base == error_mark_node)
6704 base_list = tree_cons (access, base, base_list);
6705 if (BINFO_VIRTUAL_P (pbase_binfo))
6706 TREE_TYPE (base_list) = integer_type_node;
6710 /* The list is now in reverse order; correct that. */
6711 base_list = nreverse (base_list);
6714 pop_scope (pushed_scope);
6716 /* Now call xref_basetypes to set up all the base-class
6718 xref_basetypes (type, base_list);
6720 apply_late_template_attributes (&type, TYPE_ATTRIBUTES (pattern),
6721 (int) ATTR_FLAG_TYPE_IN_PLACE,
6722 args, tf_error, NULL_TREE);
6724 /* Now that our base classes are set up, enter the scope of the
6725 class, so that name lookups into base classes, etc. will work
6726 correctly. This is precisely analogous to what we do in
6727 begin_class_definition when defining an ordinary non-template
6728 class, except we also need to push the enclosing classes. */
6729 push_nested_class (type);
6731 /* Now members are processed in the order of declaration. */
6732 for (member = CLASSTYPE_DECL_LIST (pattern);
6733 member; member = TREE_CHAIN (member))
6735 tree t = TREE_VALUE (member);
6737 if (TREE_PURPOSE (member))
6741 /* Build new CLASSTYPE_NESTED_UTDS. */
6744 bool class_template_p;
6746 class_template_p = (TREE_CODE (t) != ENUMERAL_TYPE
6747 && TYPE_LANG_SPECIFIC (t)
6748 && CLASSTYPE_IS_TEMPLATE (t));
6749 /* If the member is a class template, then -- even after
6750 substitution -- there may be dependent types in the
6751 template argument list for the class. We increment
6752 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
6753 that function will assume that no types are dependent
6754 when outside of a template. */
6755 if (class_template_p)
6756 ++processing_template_decl;
6757 newtag = tsubst (t, args, tf_error, NULL_TREE);
6758 if (class_template_p)
6759 --processing_template_decl;
6760 if (newtag == error_mark_node)
6763 if (TREE_CODE (newtag) != ENUMERAL_TYPE)
6765 tree name = TYPE_IDENTIFIER (t);
6767 if (class_template_p)
6768 /* Unfortunately, lookup_template_class sets
6769 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
6770 instantiation (i.e., for the type of a member
6771 template class nested within a template class.)
6772 This behavior is required for
6773 maybe_process_partial_specialization to work
6774 correctly, but is not accurate in this case;
6775 the TAG is not an instantiation of anything.
6776 (The corresponding TEMPLATE_DECL is an
6777 instantiation, but the TYPE is not.) */
6778 CLASSTYPE_USE_TEMPLATE (newtag) = 0;
6780 /* Now, we call pushtag to put this NEWTAG into the scope of
6781 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
6782 pushtag calling push_template_decl. We don't have to do
6783 this for enums because it will already have been done in
6786 SET_IDENTIFIER_TYPE_VALUE (name, newtag);
6787 pushtag (name, newtag, /*tag_scope=*/ts_current);
6790 else if (TREE_CODE (t) == FUNCTION_DECL
6791 || DECL_FUNCTION_TEMPLATE_P (t))
6793 /* Build new TYPE_METHODS. */
6796 if (TREE_CODE (t) == TEMPLATE_DECL)
6797 ++processing_template_decl;
6798 r = tsubst (t, args, tf_error, NULL_TREE);
6799 if (TREE_CODE (t) == TEMPLATE_DECL)
6800 --processing_template_decl;
6801 set_current_access_from_decl (r);
6802 finish_member_declaration (r);
6806 /* Build new TYPE_FIELDS. */
6807 if (TREE_CODE (t) == STATIC_ASSERT)
6810 tsubst_expr (STATIC_ASSERT_CONDITION (t), args,
6811 tf_warning_or_error, NULL_TREE,
6812 /*integral_constant_expression_p=*/true);
6813 finish_static_assert (condition,
6814 STATIC_ASSERT_MESSAGE (t),
6815 STATIC_ASSERT_SOURCE_LOCATION (t),
6818 else if (TREE_CODE (t) != CONST_DECL)
6822 /* The the file and line for this declaration, to
6823 assist in error message reporting. Since we
6824 called push_tinst_level above, we don't need to
6826 input_location = DECL_SOURCE_LOCATION (t);
6828 if (TREE_CODE (t) == TEMPLATE_DECL)
6829 ++processing_template_decl;
6830 r = tsubst (t, args, tf_warning_or_error, NULL_TREE);
6831 if (TREE_CODE (t) == TEMPLATE_DECL)
6832 --processing_template_decl;
6833 if (TREE_CODE (r) == VAR_DECL)
6837 [t]he initialization (and any associated
6838 side-effects) of a static data member does
6839 not occur unless the static data member is
6840 itself used in a way that requires the
6841 definition of the static data member to
6844 Therefore, we do not substitute into the
6845 initialized for the static data member here. */
6846 finish_static_data_member_decl
6849 /*init_const_expr_p=*/false,
6850 /*asmspec_tree=*/NULL_TREE,
6852 if (DECL_INITIALIZED_IN_CLASS_P (r))
6853 check_static_variable_definition (r, TREE_TYPE (r));
6855 else if (TREE_CODE (r) == FIELD_DECL)
6857 /* Determine whether R has a valid type and can be
6858 completed later. If R is invalid, then it is
6859 replaced by error_mark_node so that it will not be
6860 added to TYPE_FIELDS. */
6861 tree rtype = TREE_TYPE (r);
6862 if (can_complete_type_without_circularity (rtype))
6863 complete_type (rtype);
6865 if (!COMPLETE_TYPE_P (rtype))
6867 cxx_incomplete_type_error (r, rtype);
6868 r = error_mark_node;
6872 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
6873 such a thing will already have been added to the field
6874 list by tsubst_enum in finish_member_declaration in the
6875 CLASSTYPE_NESTED_UTDS case above. */
6876 if (!(TREE_CODE (r) == TYPE_DECL
6877 && TREE_CODE (TREE_TYPE (r)) == ENUMERAL_TYPE
6878 && DECL_ARTIFICIAL (r)))
6880 set_current_access_from_decl (r);
6881 finish_member_declaration (r);
6888 if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t))
6890 /* Build new CLASSTYPE_FRIEND_CLASSES. */
6892 tree friend_type = t;
6893 bool adjust_processing_template_decl = false;
6895 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
6897 /* template <class T> friend class C; */
6898 friend_type = tsubst_friend_class (friend_type, args);
6899 adjust_processing_template_decl = true;
6901 else if (TREE_CODE (friend_type) == UNBOUND_CLASS_TEMPLATE)
6903 /* template <class T> friend class C::D; */
6904 friend_type = tsubst (friend_type, args,
6905 tf_warning_or_error, NULL_TREE);
6906 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
6907 friend_type = TREE_TYPE (friend_type);
6908 adjust_processing_template_decl = true;
6910 else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
6912 /* This could be either
6916 when dependent_type_p is false or
6918 template <class U> friend class T::C;
6921 friend_type = tsubst (friend_type, args,
6922 tf_warning_or_error, NULL_TREE);
6923 /* Bump processing_template_decl for correct
6924 dependent_type_p calculation. */
6925 ++processing_template_decl;
6926 if (dependent_type_p (friend_type))
6927 adjust_processing_template_decl = true;
6928 --processing_template_decl;
6930 else if (!CLASSTYPE_USE_TEMPLATE (friend_type)
6931 && hidden_name_p (TYPE_NAME (friend_type)))
6935 where C hasn't been declared yet. Let's lookup name
6936 from namespace scope directly, bypassing any name that
6937 come from dependent base class. */
6938 tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type));
6940 /* The call to xref_tag_from_type does injection for friend
6942 push_nested_namespace (ns);
6944 xref_tag_from_type (friend_type, NULL_TREE,
6945 /*tag_scope=*/ts_current);
6946 pop_nested_namespace (ns);
6948 else if (uses_template_parms (friend_type))
6949 /* friend class C<T>; */
6950 friend_type = tsubst (friend_type, args,
6951 tf_warning_or_error, NULL_TREE);
6956 where C is already declared or
6958 friend class C<int>;
6960 We don't have to do anything in these cases. */
6962 if (adjust_processing_template_decl)
6963 /* Trick make_friend_class into realizing that the friend
6964 we're adding is a template, not an ordinary class. It's
6965 important that we use make_friend_class since it will
6966 perform some error-checking and output cross-reference
6968 ++processing_template_decl;
6970 if (friend_type != error_mark_node)
6971 make_friend_class (type, friend_type, /*complain=*/false);
6973 if (adjust_processing_template_decl)
6974 --processing_template_decl;
6978 /* Build new DECL_FRIENDLIST. */
6981 /* The the file and line for this declaration, to
6982 assist in error message reporting. Since we
6983 called push_tinst_level above, we don't need to
6985 input_location = DECL_SOURCE_LOCATION (t);
6987 if (TREE_CODE (t) == TEMPLATE_DECL)
6989 ++processing_template_decl;
6990 push_deferring_access_checks (dk_no_check);
6993 r = tsubst_friend_function (t, args);
6994 add_friend (type, r, /*complain=*/false);
6995 if (TREE_CODE (t) == TEMPLATE_DECL)
6997 pop_deferring_access_checks ();
6998 --processing_template_decl;
7004 /* Set the file and line number information to whatever is given for
7005 the class itself. This puts error messages involving generated
7006 implicit functions at a predictable point, and the same point
7007 that would be used for non-template classes. */
7008 input_location = DECL_SOURCE_LOCATION (typedecl);
7010 unreverse_member_declarations (type);
7011 finish_struct_1 (type);
7012 TYPE_BEING_DEFINED (type) = 0;
7014 /* Now that the class is complete, instantiate default arguments for
7015 any member functions. We don't do this earlier because the
7016 default arguments may reference members of the class. */
7017 if (!PRIMARY_TEMPLATE_P (template))
7018 for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t))
7019 if (TREE_CODE (t) == FUNCTION_DECL
7020 /* Implicitly generated member functions will not have template
7021 information; they are not instantiations, but instead are
7022 created "fresh" for each instantiation. */
7023 && DECL_TEMPLATE_INFO (t))
7024 tsubst_default_arguments (t);
7026 pop_nested_class ();
7027 pop_from_top_level ();
7028 pop_deferring_access_checks ();
7031 /* The vtable for a template class can be emitted in any translation
7032 unit in which the class is instantiated. When there is no key
7033 method, however, finish_struct_1 will already have added TYPE to
7034 the keyed_classes list. */
7035 if (TYPE_CONTAINS_VPTR_P (type) && CLASSTYPE_KEY_METHOD (type))
7036 keyed_classes = tree_cons (NULL_TREE, type, keyed_classes);
7042 tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl)
7048 else if (TYPE_P (t))
7049 r = tsubst (t, args, complain, in_decl);
7052 r = tsubst_expr (t, args, complain, in_decl,
7053 /*integral_constant_expression_p=*/true);
7054 r = fold_non_dependent_expr (r);
7059 /* Substitute ARGS into T, which is an pack expansion
7060 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
7061 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
7062 (if only a partial substitution could be performed) or
7063 ERROR_MARK_NODE if there was an error. */
7065 tsubst_pack_expansion (tree t, tree args, tsubst_flags_t complain,
7069 tree pack, packs = NULL_TREE, unsubstituted_packs = NULL_TREE;
7070 tree first_arg_pack; int i, len = -1;
7074 gcc_assert (PACK_EXPANSION_P (t));
7075 pattern = PACK_EXPANSION_PATTERN (t);
7077 /* Determine the argument packs that will instantiate the parameter
7078 packs used in the expansion expression. While we're at it,
7079 compute the number of arguments to be expanded and make sure it
7081 for (pack = PACK_EXPANSION_PARAMETER_PACKS (t); pack;
7082 pack = TREE_CHAIN (pack))
7084 tree parm_pack = TREE_VALUE (pack);
7085 tree arg_pack = NULL_TREE;
7086 tree orig_arg = NULL_TREE;
7088 if (TREE_CODE (parm_pack) == PARM_DECL)
7090 if (local_specializations)
7091 arg_pack = retrieve_local_specialization (parm_pack);
7095 int level, idx, levels;
7096 template_parm_level_and_index (parm_pack, &level, &idx);
7098 levels = TMPL_ARGS_DEPTH (args);
7099 if (level <= levels)
7100 arg_pack = TMPL_ARG (args, level, idx);
7103 orig_arg = arg_pack;
7104 if (arg_pack && TREE_CODE (arg_pack) == ARGUMENT_PACK_SELECT)
7105 arg_pack = ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack);
7107 if (arg_pack && !ARGUMENT_PACK_P (arg_pack))
7108 /* This can only happen if we forget to expand an argument
7109 pack somewhere else. Just return an error, silently. */
7111 result = make_tree_vec (1);
7112 TREE_VEC_ELT (result, 0) = error_mark_node;
7117 && TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack)) == 1
7118 && PACK_EXPANSION_P (TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg_pack), 0)))
7120 tree expansion = TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg_pack), 0);
7121 tree pattern = PACK_EXPANSION_PATTERN (expansion);
7122 if ((TYPE_P (pattern) && same_type_p (pattern, parm_pack))
7123 || (!TYPE_P (pattern) && cp_tree_equal (parm_pack, pattern)))
7124 /* The argument pack that the parameter maps to is just an
7125 expansion of the parameter itself, such as one would
7126 find in the implicit typedef of a class inside the
7127 class itself. Consider this parameter "unsubstituted",
7128 so that we will maintain the outer pack expansion. */
7129 arg_pack = NULL_TREE;
7135 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack));
7137 /* It's all-or-nothing with incomplete argument packs. */
7138 if (incomplete && !ARGUMENT_PACK_INCOMPLETE_P (arg_pack))
7139 return error_mark_node;
7141 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack))
7147 first_arg_pack = arg_pack;
7149 else if (len != my_len)
7151 if (TREE_CODE (t) == TYPE_PACK_EXPANSION)
7152 error ("mismatched argument pack lengths while expanding "
7156 error ("mismatched argument pack lengths while expanding "
7159 return error_mark_node;
7162 /* Keep track of the parameter packs and their corresponding
7164 packs = tree_cons (parm_pack, arg_pack, packs);
7165 TREE_TYPE (packs) = orig_arg;
7168 /* We can't substitute for this parameter pack. */
7169 unsubstituted_packs = tree_cons (TREE_PURPOSE (pack),
7171 unsubstituted_packs);
7174 /* We cannot expand this expansion expression, because we don't have
7175 all of the argument packs we need. Substitute into the pattern
7176 and return a PACK_EXPANSION_*. The caller will need to deal with
7178 if (unsubstituted_packs)
7179 return make_pack_expansion (tsubst (pattern, args, complain,
7182 /* We could not find any argument packs that work. */
7184 return error_mark_node;
7186 /* For each argument in each argument pack, substitute into the
7188 result = make_tree_vec (len + incomplete);
7189 for (i = 0; i < len + incomplete; ++i)
7191 /* For parameter pack, change the substitution of the parameter
7192 pack to the ith argument in its argument pack, then expand
7194 for (pack = packs; pack; pack = TREE_CHAIN (pack))
7196 tree parm = TREE_PURPOSE (pack);
7198 if (TREE_CODE (parm) == PARM_DECL)
7200 /* Select the Ith argument from the pack. */
7201 tree arg = make_node (ARGUMENT_PACK_SELECT);
7202 ARGUMENT_PACK_SELECT_FROM_PACK (arg) = TREE_VALUE (pack);
7203 ARGUMENT_PACK_SELECT_INDEX (arg) = i;
7205 register_local_specialization (arg, parm);
7211 template_parm_level_and_index (parm, &level, &idx);
7215 /* Select the Ith argument from the pack. */
7216 value = make_node (ARGUMENT_PACK_SELECT);
7217 ARGUMENT_PACK_SELECT_FROM_PACK (value) = TREE_VALUE (pack);
7218 ARGUMENT_PACK_SELECT_INDEX (value) = i;
7221 /* Update the corresponding argument. */
7222 TMPL_ARG (args, level, idx) = value;
7226 /* Substitute into the PATTERN with the altered arguments. */
7227 if (TREE_CODE (t) == EXPR_PACK_EXPANSION)
7228 TREE_VEC_ELT (result, i) =
7229 tsubst_expr (pattern, args, complain, in_decl,
7230 /*integral_constant_expression_p=*/false);
7232 TREE_VEC_ELT (result, i) = tsubst (pattern, args, complain, in_decl);
7235 /* When we have incomplete argument packs, the last "expanded"
7236 result is itself a pack expansion, which allows us
7237 to deduce more arguments. */
7238 TREE_VEC_ELT (result, i) =
7239 make_pack_expansion (TREE_VEC_ELT (result, i));
7241 if (TREE_VEC_ELT (result, i) == error_mark_node)
7243 result = error_mark_node;
7248 /* Update ARGS to restore the substitution from parameter packs to
7249 their argument packs. */
7250 for (pack = packs; pack; pack = TREE_CHAIN (pack))
7252 tree parm = TREE_PURPOSE (pack);
7254 if (TREE_CODE (parm) == PARM_DECL)
7255 register_local_specialization (TREE_TYPE (pack), parm);
7259 template_parm_level_and_index (parm, &level, &idx);
7261 /* Update the corresponding argument. */
7262 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
7263 TREE_VEC_ELT (TREE_VEC_ELT (args, level -1 ), idx) =
7266 TREE_VEC_ELT (args, idx) = TREE_TYPE (pack);
7273 /* Substitute ARGS into the vector or list of template arguments T. */
7276 tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl)
7279 int len = TREE_VEC_LENGTH (t);
7280 int need_new = 0, i, expanded_len_adjust = 0, out;
7281 tree *elts = (tree *) alloca (len * sizeof (tree));
7283 for (i = 0; i < len; i++)
7285 tree orig_arg = TREE_VEC_ELT (t, i);
7288 if (TREE_CODE (orig_arg) == TREE_VEC)
7289 new_arg = tsubst_template_args (orig_arg, args, complain, in_decl);
7290 else if (PACK_EXPANSION_P (orig_arg))
7292 /* Substitute into an expansion expression. */
7293 new_arg = tsubst_pack_expansion (orig_arg, args, complain, in_decl);
7295 if (TREE_CODE (new_arg) == TREE_VEC)
7296 /* Add to the expanded length adjustment the number of
7297 expanded arguments. We subtract one from this
7298 measurement, because the argument pack expression
7299 itself is already counted as 1 in
7300 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
7301 the argument pack is empty. */
7302 expanded_len_adjust += TREE_VEC_LENGTH (new_arg) - 1;
7304 else if (ARGUMENT_PACK_P (orig_arg))
7306 /* Substitute into each of the arguments. */
7307 new_arg = make_node (TREE_CODE (orig_arg));
7309 SET_ARGUMENT_PACK_ARGS (
7311 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg),
7312 args, complain, in_decl));
7314 if (ARGUMENT_PACK_ARGS (new_arg) == error_mark_node)
7315 new_arg = error_mark_node;
7317 if (TREE_CODE (new_arg) == NONTYPE_ARGUMENT_PACK) {
7318 TREE_TYPE (new_arg) = tsubst (TREE_TYPE (orig_arg), args,
7320 TREE_CONSTANT (new_arg) = TREE_CONSTANT (orig_arg);
7322 if (TREE_TYPE (new_arg) == error_mark_node)
7323 new_arg = error_mark_node;
7327 new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl);
7329 if (new_arg == error_mark_node)
7330 return error_mark_node;
7333 if (new_arg != orig_arg)
7340 /* Make space for the expanded arguments coming from template
7342 t = make_tree_vec (len + expanded_len_adjust);
7343 for (i = 0, out = 0; i < len; i++)
7345 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t, i))
7346 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t, i)))
7347 && TREE_CODE (elts[i]) == TREE_VEC)
7351 /* Now expand the template argument pack "in place". */
7352 for (idx = 0; idx < TREE_VEC_LENGTH (elts[i]); idx++, out++)
7353 TREE_VEC_ELT (t, out) = TREE_VEC_ELT (elts[i], idx);
7357 TREE_VEC_ELT (t, out) = elts[i];
7365 /* Return the result of substituting ARGS into the template parameters
7366 given by PARMS. If there are m levels of ARGS and m + n levels of
7367 PARMS, then the result will contain n levels of PARMS. For
7368 example, if PARMS is `template <class T> template <class U>
7369 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
7370 result will be `template <int*, double, class V>'. */
7373 tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain)
7378 /* When substituting into a template, we must set
7379 PROCESSING_TEMPLATE_DECL as the template parameters may be
7380 dependent if they are based on one-another, and the dependency
7381 predicates are short-circuit outside of templates. */
7382 ++processing_template_decl;
7384 for (new_parms = &r;
7385 TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args);
7386 new_parms = &(TREE_CHAIN (*new_parms)),
7387 parms = TREE_CHAIN (parms))
7390 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms)));
7393 for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i)
7399 if (parms == error_mark_node)
7402 tuple = TREE_VEC_ELT (TREE_VALUE (parms), i);
7404 if (tuple == error_mark_node)
7407 default_value = TREE_PURPOSE (tuple);
7408 parm_decl = TREE_VALUE (tuple);
7410 parm_decl = tsubst (parm_decl, args, complain, NULL_TREE);
7411 if (TREE_CODE (parm_decl) == PARM_DECL
7412 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl), complain))
7413 parm_decl = error_mark_node;
7414 default_value = tsubst_template_arg (default_value, args,
7415 complain, NULL_TREE);
7417 tuple = build_tree_list (default_value, parm_decl);
7418 TREE_VEC_ELT (new_vec, i) = tuple;
7422 tree_cons (size_int (TMPL_PARMS_DEPTH (parms)
7423 - TMPL_ARGS_DEPTH (args)),
7424 new_vec, NULL_TREE);
7427 --processing_template_decl;
7432 /* Substitute the ARGS into the indicated aggregate (or enumeration)
7433 type T. If T is not an aggregate or enumeration type, it is
7434 handled as if by tsubst. IN_DECL is as for tsubst. If
7435 ENTERING_SCOPE is nonzero, T is the context for a template which
7436 we are presently tsubst'ing. Return the substituted value. */
7439 tsubst_aggr_type (tree t,
7441 tsubst_flags_t complain,
7448 switch (TREE_CODE (t))
7451 if (TYPE_PTRMEMFUNC_P (t))
7452 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl);
7454 /* Else fall through. */
7457 if (TYPE_TEMPLATE_INFO (t))
7462 bool saved_skip_evaluation;
7464 /* In "sizeof(X<I>)" we need to evaluate "I". */
7465 saved_skip_evaluation = skip_evaluation;
7466 skip_evaluation = false;
7468 /* First, determine the context for the type we are looking
7470 context = TYPE_CONTEXT (t);
7472 context = tsubst_aggr_type (context, args, complain,
7473 in_decl, /*entering_scope=*/1);
7475 /* Then, figure out what arguments are appropriate for the
7476 type we are trying to find. For example, given:
7478 template <class T> struct S;
7479 template <class T, class U> void f(T, U) { S<U> su; }
7481 and supposing that we are instantiating f<int, double>,
7482 then our ARGS will be {int, double}, but, when looking up
7483 S we only want {double}. */
7484 argvec = tsubst_template_args (TYPE_TI_ARGS (t), args,
7486 if (argvec == error_mark_node)
7487 r = error_mark_node;
7490 r = lookup_template_class (t, argvec, in_decl, context,
7491 entering_scope, complain);
7492 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
7495 skip_evaluation = saved_skip_evaluation;
7500 /* This is not a template type, so there's nothing to do. */
7504 return tsubst (t, args, complain, in_decl);
7508 /* Substitute into the default argument ARG (a default argument for
7509 FN), which has the indicated TYPE. */
7512 tsubst_default_argument (tree fn, tree type, tree arg)
7514 tree saved_class_ptr = NULL_TREE;
7515 tree saved_class_ref = NULL_TREE;
7517 /* This default argument came from a template. Instantiate the
7518 default argument here, not in tsubst. In the case of
7527 we must be careful to do name lookup in the scope of S<T>,
7528 rather than in the current class. */
7529 push_access_scope (fn);
7530 /* The "this" pointer is not valid in a default argument. */
7533 saved_class_ptr = current_class_ptr;
7534 cp_function_chain->x_current_class_ptr = NULL_TREE;
7535 saved_class_ref = current_class_ref;
7536 cp_function_chain->x_current_class_ref = NULL_TREE;
7539 push_deferring_access_checks(dk_no_deferred);
7540 /* The default argument expression may cause implicitly defined
7541 member functions to be synthesized, which will result in garbage
7542 collection. We must treat this situation as if we were within
7543 the body of function so as to avoid collecting live data on the
7546 arg = tsubst_expr (arg, DECL_TI_ARGS (fn),
7547 tf_warning_or_error, NULL_TREE,
7548 /*integral_constant_expression_p=*/false);
7550 pop_deferring_access_checks();
7552 /* Restore the "this" pointer. */
7555 cp_function_chain->x_current_class_ptr = saved_class_ptr;
7556 cp_function_chain->x_current_class_ref = saved_class_ref;
7559 pop_access_scope (fn);
7561 /* Make sure the default argument is reasonable. */
7562 arg = check_default_argument (type, arg);
7567 /* Substitute into all the default arguments for FN. */
7570 tsubst_default_arguments (tree fn)
7575 tmpl_args = DECL_TI_ARGS (fn);
7577 /* If this function is not yet instantiated, we certainly don't need
7578 its default arguments. */
7579 if (uses_template_parms (tmpl_args))
7582 for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
7584 arg = TREE_CHAIN (arg))
7585 if (TREE_PURPOSE (arg))
7586 TREE_PURPOSE (arg) = tsubst_default_argument (fn,
7588 TREE_PURPOSE (arg));
7591 /* Substitute the ARGS into the T, which is a _DECL. Return the
7592 result of the substitution. Issue error and warning messages under
7593 control of COMPLAIN. */
7596 tsubst_decl (tree t, tree args, tsubst_flags_t complain)
7598 location_t saved_loc;
7602 /* Set the filename and linenumber to improve error-reporting. */
7603 saved_loc = input_location;
7604 input_location = DECL_SOURCE_LOCATION (t);
7606 switch (TREE_CODE (t))
7610 /* We can get here when processing a member function template,
7611 member class template, and template template parameter of
7612 a template class. */
7613 tree decl = DECL_TEMPLATE_RESULT (t);
7618 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
7620 /* Template template parameter is treated here. */
7621 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
7622 if (new_type == error_mark_node)
7623 return error_mark_node;
7626 TREE_CHAIN (r) = NULL_TREE;
7627 TREE_TYPE (r) = new_type;
7628 DECL_TEMPLATE_RESULT (r)
7629 = build_decl (TYPE_DECL, DECL_NAME (decl), new_type);
7630 DECL_TEMPLATE_PARMS (r)
7631 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
7633 TYPE_NAME (new_type) = r;
7637 /* We might already have an instance of this template.
7638 The ARGS are for the surrounding class type, so the
7639 full args contain the tsubst'd args for the context,
7640 plus the innermost args from the template decl. */
7641 tmpl_args = DECL_CLASS_TEMPLATE_P (t)
7642 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t))
7643 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t));
7644 /* Because this is a template, the arguments will still be
7645 dependent, even after substitution. If
7646 PROCESSING_TEMPLATE_DECL is not set, the dependency
7647 predicates will short-circuit. */
7648 ++processing_template_decl;
7649 full_args = tsubst_template_args (tmpl_args, args,
7651 --processing_template_decl;
7652 if (full_args == error_mark_node)
7653 return error_mark_node;
7655 /* tsubst_template_args doesn't copy the vector if
7656 nothing changed. But, *something* should have
7658 gcc_assert (full_args != tmpl_args);
7660 spec = retrieve_specialization (t, full_args,
7661 /*class_specializations_p=*/true);
7662 if (spec != NULL_TREE)
7668 /* Make a new template decl. It will be similar to the
7669 original, but will record the current template arguments.
7670 We also create a new function declaration, which is just
7671 like the old one, but points to this new template, rather
7672 than the old one. */
7674 gcc_assert (DECL_LANG_SPECIFIC (r) != 0);
7675 TREE_CHAIN (r) = NULL_TREE;
7677 DECL_TEMPLATE_INFO (r) = build_tree_list (t, args);
7679 if (TREE_CODE (decl) == TYPE_DECL)
7682 ++processing_template_decl;
7683 new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
7684 --processing_template_decl;
7685 if (new_type == error_mark_node)
7686 return error_mark_node;
7688 TREE_TYPE (r) = new_type;
7689 CLASSTYPE_TI_TEMPLATE (new_type) = r;
7690 DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type);
7691 DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type);
7692 DECL_CONTEXT (r) = TYPE_CONTEXT (new_type);
7697 ++processing_template_decl;
7698 new_decl = tsubst (decl, args, complain, in_decl);
7699 --processing_template_decl;
7700 if (new_decl == error_mark_node)
7701 return error_mark_node;
7703 DECL_TEMPLATE_RESULT (r) = new_decl;
7704 DECL_TI_TEMPLATE (new_decl) = r;
7705 TREE_TYPE (r) = TREE_TYPE (new_decl);
7706 DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl);
7707 DECL_CONTEXT (r) = DECL_CONTEXT (new_decl);
7710 SET_DECL_IMPLICIT_INSTANTIATION (r);
7711 DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE;
7712 DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE;
7714 /* The template parameters for this new template are all the
7715 template parameters for the old template, except the
7716 outermost level of parameters. */
7717 DECL_TEMPLATE_PARMS (r)
7718 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
7721 if (PRIMARY_TEMPLATE_P (t))
7722 DECL_PRIMARY_TEMPLATE (r) = r;
7724 if (TREE_CODE (decl) != TYPE_DECL)
7725 /* Record this non-type partial instantiation. */
7726 register_specialization (r, t,
7727 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r)),
7735 tree argvec = NULL_TREE;
7743 /* Nobody should be tsubst'ing into non-template functions. */
7744 gcc_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE);
7746 if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL)
7751 /* If T is not dependent, just return it. We have to
7752 increment PROCESSING_TEMPLATE_DECL because
7753 value_dependent_expression_p assumes that nothing is
7754 dependent when PROCESSING_TEMPLATE_DECL is zero. */
7755 ++processing_template_decl;
7756 dependent_p = value_dependent_expression_p (t);
7757 --processing_template_decl;
7761 /* Calculate the most general template of which R is a
7762 specialization, and the complete set of arguments used to
7764 gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
7765 argvec = tsubst_template_args (DECL_TI_ARGS
7766 (DECL_TEMPLATE_RESULT (gen_tmpl)),
7767 args, complain, in_decl);
7769 /* Check to see if we already have this specialization. */
7770 spec = retrieve_specialization (gen_tmpl, argvec,
7771 /*class_specializations_p=*/false);
7779 /* We can see more levels of arguments than parameters if
7780 there was a specialization of a member template, like
7783 template <class T> struct S { template <class U> void f(); }
7784 template <> template <class U> void S<int>::f(U);
7786 Here, we'll be substituting into the specialization,
7787 because that's where we can find the code we actually
7788 want to generate, but we'll have enough arguments for
7789 the most general template.
7791 We also deal with the peculiar case:
7793 template <class T> struct S {
7794 template <class U> friend void f();
7796 template <class U> void f() {}
7798 template void f<double>();
7800 Here, the ARGS for the instantiation of will be {int,
7801 double}. But, we only need as many ARGS as there are
7802 levels of template parameters in CODE_PATTERN. We are
7803 careful not to get fooled into reducing the ARGS in
7806 template <class T> struct S { template <class U> void f(U); }
7807 template <class T> template <> void S<T>::f(int) {}
7809 which we can spot because the pattern will be a
7810 specialization in this case. */
7811 args_depth = TMPL_ARGS_DEPTH (args);
7813 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t)));
7814 if (args_depth > parms_depth
7815 && !DECL_TEMPLATE_SPECIALIZATION (t))
7816 args = get_innermost_template_args (args, parms_depth);
7820 /* This special case arises when we have something like this:
7822 template <class T> struct S {
7823 friend void f<int>(int, double);
7826 Here, the DECL_TI_TEMPLATE for the friend declaration
7827 will be an IDENTIFIER_NODE. We are being called from
7828 tsubst_friend_function, and we want only to create a
7829 new decl (R) with appropriate types so that we can call
7830 determine_specialization. */
7831 gen_tmpl = NULL_TREE;
7834 if (DECL_CLASS_SCOPE_P (t))
7836 if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t)))
7840 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
7841 complain, t, /*entering_scope=*/1);
7846 ctx = DECL_CONTEXT (t);
7848 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
7849 if (type == error_mark_node)
7850 return error_mark_node;
7852 /* We do NOT check for matching decls pushed separately at this
7853 point, as they may not represent instantiations of this
7854 template, and in any case are considered separate under the
7857 DECL_USE_TEMPLATE (r) = 0;
7858 TREE_TYPE (r) = type;
7859 /* Clear out the mangled name and RTL for the instantiation. */
7860 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
7861 SET_DECL_RTL (r, NULL_RTX);
7862 DECL_INITIAL (r) = NULL_TREE;
7863 DECL_CONTEXT (r) = ctx;
7865 if (member && DECL_CONV_FN_P (r))
7866 /* Type-conversion operator. Reconstruct the name, in
7867 case it's the name of one of the template's parameters. */
7868 DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type));
7870 DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args,
7872 DECL_RESULT (r) = NULL_TREE;
7874 TREE_STATIC (r) = 0;
7875 TREE_PUBLIC (r) = TREE_PUBLIC (t);
7876 DECL_EXTERNAL (r) = 1;
7877 /* If this is an instantiation of a function with internal
7878 linkage, we already know what object file linkage will be
7879 assigned to the instantiation. */
7880 DECL_INTERFACE_KNOWN (r) = !TREE_PUBLIC (r);
7881 DECL_DEFER_OUTPUT (r) = 0;
7882 TREE_CHAIN (r) = NULL_TREE;
7883 DECL_PENDING_INLINE_INFO (r) = 0;
7884 DECL_PENDING_INLINE_P (r) = 0;
7885 DECL_SAVED_TREE (r) = NULL_TREE;
7887 if (DECL_CLONED_FUNCTION (r))
7889 DECL_CLONED_FUNCTION (r) = tsubst (DECL_CLONED_FUNCTION (t),
7891 TREE_CHAIN (r) = TREE_CHAIN (DECL_CLONED_FUNCTION (r));
7892 TREE_CHAIN (DECL_CLONED_FUNCTION (r)) = r;
7895 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
7896 this in the special friend case mentioned above where
7897 GEN_TMPL is NULL. */
7900 DECL_TEMPLATE_INFO (r)
7901 = tree_cons (gen_tmpl, argvec, NULL_TREE);
7902 SET_DECL_IMPLICIT_INSTANTIATION (r);
7903 register_specialization (r, gen_tmpl, argvec, false);
7905 /* We're not supposed to instantiate default arguments
7906 until they are called, for a template. But, for a
7909 template <class T> void f ()
7910 { extern void g(int i = T()); }
7912 we should do the substitution when the template is
7913 instantiated. We handle the member function case in
7914 instantiate_class_template since the default arguments
7915 might refer to other members of the class. */
7917 && !PRIMARY_TEMPLATE_P (gen_tmpl)
7918 && !uses_template_parms (argvec))
7919 tsubst_default_arguments (r);
7922 DECL_TEMPLATE_INFO (r) = NULL_TREE;
7924 /* Copy the list of befriending classes. */
7925 for (friends = &DECL_BEFRIENDING_CLASSES (r);
7927 friends = &TREE_CHAIN (*friends))
7929 *friends = copy_node (*friends);
7930 TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends),
7935 if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r))
7937 maybe_retrofit_in_chrg (r);
7938 if (DECL_CONSTRUCTOR_P (r))
7939 grok_ctor_properties (ctx, r);
7940 /* If this is an instantiation of a member template, clone it.
7941 If it isn't, that'll be handled by
7942 clone_constructors_and_destructors. */
7943 if (PRIMARY_TEMPLATE_P (gen_tmpl))
7944 clone_function_decl (r, /*update_method_vec_p=*/0);
7946 else if (IDENTIFIER_OPNAME_P (DECL_NAME (r))
7947 && !grok_op_properties (r, (complain & tf_error) != 0))
7948 return error_mark_node;
7950 if (DECL_FRIEND_P (t) && DECL_FRIEND_CONTEXT (t))
7951 SET_DECL_FRIEND_CONTEXT (r,
7952 tsubst (DECL_FRIEND_CONTEXT (t),
7953 args, complain, in_decl));
7955 /* Possibly limit visibility based on template args. */
7956 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
7957 if (DECL_VISIBILITY_SPECIFIED (t))
7959 DECL_VISIBILITY_SPECIFIED (r) = 0;
7961 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
7963 determine_visibility (r);
7965 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
7966 args, complain, in_decl);
7972 tree type = NULL_TREE;
7974 tree expanded_types = NULL_TREE;
7975 tree prev_r = NULL_TREE;
7976 tree first_r = NULL_TREE;
7978 if (FUNCTION_PARAMETER_PACK_P (t))
7980 /* If there is a local specialization that isn't a
7981 parameter pack, it means that we're doing a "simple"
7982 substitution from inside tsubst_pack_expansion. Just
7983 return the local specialization (which will be a single
7985 tree spec = NULL_TREE;
7986 if (local_specializations)
7987 spec = retrieve_local_specialization (t);
7989 && TREE_CODE (spec) == PARM_DECL
7990 && TREE_CODE (TREE_TYPE (spec)) != TYPE_PACK_EXPANSION)
7993 /* Expand the TYPE_PACK_EXPANSION that provides the types for
7994 the parameters in this function parameter pack. */
7995 expanded_types = tsubst_pack_expansion (TREE_TYPE (t), args,
7997 if (TREE_CODE (expanded_types) == TREE_VEC)
7999 len = TREE_VEC_LENGTH (expanded_types);
8001 /* Zero-length parameter packs are boring. Just substitute
8004 return tsubst (TREE_CHAIN (t), args, complain,
8009 /* All we did was update the type. Make a note of that. */
8010 type = expanded_types;
8011 expanded_types = NULL_TREE;
8015 /* Loop through all of the parameter's we'll build. When T is
8016 a function parameter pack, LEN is the number of expanded
8017 types in EXPANDED_TYPES; otherwise, LEN is 1. */
8019 for (i = 0; i < len; ++i)
8023 if (DECL_TEMPLATE_PARM_P (t))
8024 SET_DECL_TEMPLATE_PARM_P (r);
8027 /* We're on the Ith parameter of the function parameter
8030 /* Get the Ith type. */
8031 type = TREE_VEC_ELT (expanded_types, i);
8034 /* Rename the parameter to include the index. */
8036 make_ith_pack_parameter_name (DECL_NAME (r), i);
8039 /* We're dealing with a normal parameter. */
8040 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8042 type = type_decays_to (type);
8043 TREE_TYPE (r) = type;
8044 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
8046 if (DECL_INITIAL (r))
8048 if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
8049 DECL_INITIAL (r) = TREE_TYPE (r);
8051 DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
8055 DECL_CONTEXT (r) = NULL_TREE;
8057 if (!DECL_TEMPLATE_PARM_P (r))
8058 DECL_ARG_TYPE (r) = type_passed_as (type);
8060 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
8061 args, complain, in_decl);
8063 /* Keep track of the first new parameter we
8064 generate. That's what will be returned to the
8069 /* Build a proper chain of parameters when substituting
8070 into a function parameter pack. */
8072 TREE_CHAIN (prev_r) = r;
8076 TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args,
8077 complain, TREE_CHAIN (t));
8079 /* FIRST_R contains the start of the chain we've built. */
8089 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8090 if (type == error_mark_node)
8091 return error_mark_node;
8092 TREE_TYPE (r) = type;
8093 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
8095 /* DECL_INITIAL gives the number of bits in a bit-field. */
8097 = tsubst_expr (DECL_INITIAL (t), args,
8099 /*integral_constant_expression_p=*/true);
8100 /* We don't have to set DECL_CONTEXT here; it is set by
8101 finish_member_declaration. */
8102 TREE_CHAIN (r) = NULL_TREE;
8103 if (VOID_TYPE_P (type))
8104 error ("instantiation of %q+D as type %qT", r, type);
8106 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
8107 args, complain, in_decl);
8112 /* We reach here only for member using decls. */
8113 if (DECL_DEPENDENT_P (t))
8115 r = do_class_using_decl
8116 (tsubst_copy (USING_DECL_SCOPE (t), args, complain, in_decl),
8117 tsubst_copy (DECL_NAME (t), args, complain, in_decl));
8119 r = error_mark_node;
8124 TREE_CHAIN (r) = NULL_TREE;
8131 tree argvec = NULL_TREE;
8132 tree gen_tmpl = NULL_TREE;
8134 tree tmpl = NULL_TREE;
8136 tree type = NULL_TREE;
8139 if (TREE_CODE (t) == TYPE_DECL
8140 && t == TYPE_MAIN_DECL (TREE_TYPE (t)))
8142 /* If this is the canonical decl, we don't have to
8143 mess with instantiations, and often we can't (for
8144 typename, template type parms and such). Note that
8145 TYPE_NAME is not correct for the above test if
8146 we've copied the type for a typedef. */
8147 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8148 if (type == error_mark_node)
8149 return error_mark_node;
8150 r = TYPE_NAME (type);
8154 /* Check to see if we already have the specialization we
8157 if (DECL_CLASS_SCOPE_P (t) || DECL_NAMESPACE_SCOPE_P (t))
8159 /* T is a static data member or namespace-scope entity.
8160 We have to substitute into namespace-scope variables
8161 (even though such entities are never templates) because
8164 template <class T> void f() { extern T t; }
8166 where the entity referenced is not known until
8167 instantiation time. */
8169 ctx = DECL_CONTEXT (t);
8170 if (DECL_CLASS_SCOPE_P (t))
8172 ctx = tsubst_aggr_type (ctx, args,
8174 in_decl, /*entering_scope=*/1);
8175 /* If CTX is unchanged, then T is in fact the
8176 specialization we want. That situation occurs when
8177 referencing a static data member within in its own
8178 class. We can use pointer equality, rather than
8179 same_type_p, because DECL_CONTEXT is always
8181 if (ctx == DECL_CONTEXT (t))
8187 tmpl = DECL_TI_TEMPLATE (t);
8188 gen_tmpl = most_general_template (tmpl);
8189 argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl);
8190 spec = (retrieve_specialization
8192 /*class_specializations_p=*/false));
8197 /* A local variable. */
8199 /* Subsequent calls to pushdecl will fill this in. */
8201 spec = retrieve_local_specialization (t);
8203 /* If we already have the specialization we need, there is
8204 nothing more to do. */
8211 /* Create a new node for the specialization we need. */
8213 if (type == NULL_TREE)
8214 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8215 if (TREE_CODE (r) == VAR_DECL)
8217 /* Even if the original location is out of scope, the
8218 newly substituted one is not. */
8219 DECL_DEAD_FOR_LOCAL (r) = 0;
8220 DECL_INITIALIZED_P (r) = 0;
8221 DECL_TEMPLATE_INSTANTIATED (r) = 0;
8222 if (type == error_mark_node)
8223 return error_mark_node;
8224 if (TREE_CODE (type) == FUNCTION_TYPE)
8226 /* It may seem that this case cannot occur, since:
8231 declares a function, not a variable. However:
8234 template <typename T> void g() { T t; }
8235 template void g<f>();
8237 is an attempt to declare a variable with function
8239 error ("variable %qD has function type",
8240 /* R is not yet sufficiently initialized, so we
8241 just use its name. */
8243 return error_mark_node;
8245 type = complete_type (type);
8246 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
8247 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t);
8248 type = check_var_type (DECL_NAME (r), type);
8250 if (DECL_HAS_VALUE_EXPR_P (t))
8252 tree ve = DECL_VALUE_EXPR (t);
8253 ve = tsubst_expr (ve, args, complain, in_decl,
8254 /*constant_expression_p=*/false);
8255 SET_DECL_VALUE_EXPR (r, ve);
8258 else if (DECL_SELF_REFERENCE_P (t))
8259 SET_DECL_SELF_REFERENCE_P (r);
8260 TREE_TYPE (r) = type;
8261 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
8262 DECL_CONTEXT (r) = ctx;
8263 /* Clear out the mangled name and RTL for the instantiation. */
8264 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
8265 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
8266 SET_DECL_RTL (r, NULL_RTX);
8267 /* The initializer must not be expanded until it is required;
8269 DECL_INITIAL (r) = NULL_TREE;
8270 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
8271 SET_DECL_RTL (r, NULL_RTX);
8272 DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0;
8273 if (TREE_CODE (r) == VAR_DECL)
8275 /* Possibly limit visibility based on template args. */
8276 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
8277 if (DECL_VISIBILITY_SPECIFIED (t))
8279 DECL_VISIBILITY_SPECIFIED (r) = 0;
8281 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
8283 determine_visibility (r);
8285 /* Preserve a typedef that names a type. */
8286 else if (TREE_CODE (r) == TYPE_DECL
8287 && DECL_ORIGINAL_TYPE (t)
8288 && type != error_mark_node)
8290 DECL_ORIGINAL_TYPE (r) = tsubst (DECL_ORIGINAL_TYPE (t),
8291 args, complain, in_decl);
8292 TREE_TYPE (r) = type = build_variant_type_copy (type);
8293 TYPE_NAME (type) = r;
8298 /* A static data member declaration is always marked
8299 external when it is declared in-class, even if an
8300 initializer is present. We mimic the non-template
8302 DECL_EXTERNAL (r) = 1;
8304 register_specialization (r, gen_tmpl, argvec, false);
8305 DECL_TEMPLATE_INFO (r) = tree_cons (tmpl, argvec, NULL_TREE);
8306 SET_DECL_IMPLICIT_INSTANTIATION (r);
8309 register_local_specialization (r, t);
8311 TREE_CHAIN (r) = NULL_TREE;
8313 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r),
8314 (int) ATTR_FLAG_TYPE_IN_PLACE,
8315 args, complain, in_decl);
8324 /* Restore the file and line information. */
8325 input_location = saved_loc;
8330 /* Substitute into the ARG_TYPES of a function type. */
8333 tsubst_arg_types (tree arg_types,
8335 tsubst_flags_t complain,
8338 tree remaining_arg_types;
8339 tree type = NULL_TREE;
8341 tree expanded_args = NULL_TREE;
8344 if (!arg_types || arg_types == void_list_node)
8347 remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types),
8348 args, complain, in_decl);
8349 if (remaining_arg_types == error_mark_node)
8350 return error_mark_node;
8352 if (PACK_EXPANSION_P (TREE_VALUE (arg_types)))
8354 /* For a pack expansion, perform substitution on the
8355 entire expression. Later on, we'll handle the arguments
8357 expanded_args = tsubst_pack_expansion (TREE_VALUE (arg_types),
8358 args, complain, in_decl);
8360 if (TREE_CODE (expanded_args) == TREE_VEC)
8361 /* So that we'll spin through the parameters, one by one. */
8362 i = TREE_VEC_LENGTH (expanded_args);
8365 /* We only partially substituted into the parameter
8366 pack. Our type is TYPE_PACK_EXPANSION. */
8367 type = expanded_args;
8368 expanded_args = NULL_TREE;
8376 type = TREE_VEC_ELT (expanded_args, i);
8378 type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
8380 if (type == error_mark_node)
8381 return error_mark_node;
8382 if (VOID_TYPE_P (type))
8384 if (complain & tf_error)
8386 error ("invalid parameter type %qT", type);
8388 error ("in declaration %q+D", in_decl);
8390 return error_mark_node;
8393 /* Do array-to-pointer, function-to-pointer conversion, and ignore
8394 top-level qualifiers as required. */
8395 type = TYPE_MAIN_VARIANT (type_decays_to (type));
8397 /* We do not substitute into default arguments here. The standard
8398 mandates that they be instantiated only when needed, which is
8399 done in build_over_call. */
8400 default_arg = TREE_PURPOSE (arg_types);
8402 if (default_arg && TREE_CODE (default_arg) == DEFAULT_ARG)
8404 /* We've instantiated a template before its default arguments
8405 have been parsed. This can happen for a nested template
8406 class, and is not an error unless we require the default
8407 argument in a call of this function. */
8408 remaining_arg_types =
8409 tree_cons (default_arg, type, remaining_arg_types);
8410 VEC_safe_push (tree, gc, DEFARG_INSTANTIATIONS (default_arg),
8411 remaining_arg_types);
8414 remaining_arg_types =
8415 hash_tree_cons (default_arg, type, remaining_arg_types);
8418 return remaining_arg_types;
8421 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
8422 *not* handle the exception-specification for FNTYPE, because the
8423 initial substitution of explicitly provided template parameters
8424 during argument deduction forbids substitution into the
8425 exception-specification:
8429 All references in the function type of the function template to the
8430 corresponding template parameters are replaced by the specified tem-
8431 plate argument values. If a substitution in a template parameter or
8432 in the function type of the function template results in an invalid
8433 type, type deduction fails. [Note: The equivalent substitution in
8434 exception specifications is done only when the function is instanti-
8435 ated, at which point a program is ill-formed if the substitution
8436 results in an invalid type.] */
8439 tsubst_function_type (tree t,
8441 tsubst_flags_t complain,
8448 /* The TYPE_CONTEXT is not used for function/method types. */
8449 gcc_assert (TYPE_CONTEXT (t) == NULL_TREE);
8451 /* Substitute the return type. */
8452 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8453 if (return_type == error_mark_node)
8454 return error_mark_node;
8455 /* The standard does not presently indicate that creation of a
8456 function type with an invalid return type is a deduction failure.
8457 However, that is clearly analogous to creating an array of "void"
8458 or a reference to a reference. This is core issue #486. */
8459 if (TREE_CODE (return_type) == ARRAY_TYPE
8460 || TREE_CODE (return_type) == FUNCTION_TYPE)
8462 if (complain & tf_error)
8464 if (TREE_CODE (return_type) == ARRAY_TYPE)
8465 error ("function returning an array");
8467 error ("function returning a function");
8469 return error_mark_node;
8472 /* Substitute the argument types. */
8473 arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args,
8475 if (arg_types == error_mark_node)
8476 return error_mark_node;
8478 if (TYPE_QUALS (return_type) != TYPE_UNQUALIFIED
8479 && in_decl != NULL_TREE
8480 && !TREE_NO_WARNING (in_decl)
8481 && (SCALAR_TYPE_P (return_type) || VOID_TYPE_P (return_type)))
8482 warning (OPT_Wreturn_type,
8483 "type qualifiers ignored on function return type");
8485 /* Construct a new type node and return it. */
8486 if (TREE_CODE (t) == FUNCTION_TYPE)
8487 fntype = build_function_type (return_type, arg_types);
8490 tree r = TREE_TYPE (TREE_VALUE (arg_types));
8491 if (! IS_AGGR_TYPE (r))
8495 Type deduction may fail for any of the following
8498 -- Attempting to create "pointer to member of T" when T
8499 is not a class type. */
8500 if (complain & tf_error)
8501 error ("creating pointer to member function of non-class type %qT",
8503 return error_mark_node;
8506 fntype = build_method_type_directly (r, return_type,
8507 TREE_CHAIN (arg_types));
8509 fntype = cp_build_qualified_type_real (fntype, TYPE_QUALS (t), complain);
8510 fntype = cp_build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t));
8515 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
8516 ARGS into that specification, and return the substituted
8517 specification. If there is no specification, return NULL_TREE. */
8520 tsubst_exception_specification (tree fntype,
8522 tsubst_flags_t complain,
8528 specs = TYPE_RAISES_EXCEPTIONS (fntype);
8529 new_specs = NULL_TREE;
8532 if (! TREE_VALUE (specs))
8539 tree expanded_specs = NULL_TREE;
8541 if (PACK_EXPANSION_P (TREE_VALUE (specs)))
8543 /* Expand the pack expansion type. */
8544 expanded_specs = tsubst_pack_expansion (TREE_VALUE (specs),
8547 len = TREE_VEC_LENGTH (expanded_specs);
8550 for (i = 0; i < len; ++i)
8553 spec = TREE_VEC_ELT (expanded_specs, i);
8555 spec = tsubst (TREE_VALUE (specs), args, complain, in_decl);
8556 if (spec == error_mark_node)
8558 new_specs = add_exception_specifier (new_specs, spec,
8562 specs = TREE_CHAIN (specs);
8568 /* Take the tree structure T and replace template parameters used
8569 therein with the argument vector ARGS. IN_DECL is an associated
8570 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
8571 Issue error and warning messages under control of COMPLAIN. Note
8572 that we must be relatively non-tolerant of extensions here, in
8573 order to preserve conformance; if we allow substitutions that
8574 should not be allowed, we may allow argument deductions that should
8575 not succeed, and therefore report ambiguous overload situations
8576 where there are none. In theory, we could allow the substitution,
8577 but indicate that it should have failed, and allow our caller to
8578 make sure that the right thing happens, but we don't try to do this
8581 This function is used for dealing with types, decls and the like;
8582 for expressions, use tsubst_expr or tsubst_copy. */
8585 tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
8589 if (t == NULL_TREE || t == error_mark_node
8590 || t == integer_type_node
8591 || t == void_type_node
8592 || t == char_type_node
8593 || t == unknown_type_node
8594 || TREE_CODE (t) == NAMESPACE_DECL)
8598 return tsubst_decl (t, args, complain);
8600 if (TREE_CODE (t) == IDENTIFIER_NODE)
8601 type = IDENTIFIER_TYPE_VALUE (t);
8603 type = TREE_TYPE (t);
8605 gcc_assert (type != unknown_type_node);
8607 /* Reuse typedefs. We need to do this to handle dependent attributes,
8608 such as attribute aligned. */
8611 && TYPE_NAME (t) != TYPE_MAIN_DECL (t))
8613 tree decl = TYPE_NAME (t);
8615 if (DECL_CLASS_SCOPE_P (decl)
8616 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl)))
8618 tree tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
8619 tree gen_args = tsubst (DECL_TI_ARGS (decl), args, complain, in_decl);
8620 r = retrieve_specialization (tmpl, gen_args, false);
8622 else if (DECL_FUNCTION_SCOPE_P (decl))
8623 r = retrieve_local_specialization (decl);
8630 r = cp_build_qualified_type_real
8631 (r, cp_type_quals (t) | cp_type_quals (r),
8632 complain | tf_ignore_bad_quals);
8635 /* Else we must be instantiating the typedef, so fall through. */
8639 && TREE_CODE (t) != TYPENAME_TYPE
8640 && TREE_CODE (t) != IDENTIFIER_NODE
8641 && TREE_CODE (t) != FUNCTION_TYPE
8642 && TREE_CODE (t) != METHOD_TYPE)
8643 type = tsubst (type, args, complain, in_decl);
8644 if (type == error_mark_node)
8645 return error_mark_node;
8647 switch (TREE_CODE (t))
8652 return tsubst_aggr_type (t, args, complain, in_decl,
8653 /*entering_scope=*/0);
8656 case IDENTIFIER_NODE:
8668 if (t == integer_type_node)
8671 if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
8672 && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
8676 tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);
8678 max = tsubst_expr (omax, args, complain, in_decl,
8679 /*integral_constant_expression_p=*/false);
8680 max = fold_decl_constant_value (max);
8682 if (TREE_CODE (max) != INTEGER_CST
8683 && TREE_CODE (max) != TEMPLATE_PARM_INDEX
8684 && !at_function_scope_p ())
8686 if (complain & tf_error)
8687 error ("array bound is not an integer constant");
8688 return error_mark_node;
8693 Type deduction may fail for any of the following
8696 Attempting to create an array with a size that is
8697 zero or negative. */
8698 if (integer_zerop (max) && !(complain & tf_error))
8699 /* We must fail if performing argument deduction (as
8700 indicated by the state of complain), so that
8701 another substitution can be found. */
8702 return error_mark_node;
8703 else if (TREE_CODE (max) == INTEGER_CST
8704 && INT_CST_LT (max, integer_zero_node))
8706 if (complain & tf_error)
8707 error ("creating array with negative size (%qE)", max);
8709 return error_mark_node;
8712 return compute_array_index_type (NULL_TREE, max);
8715 case TEMPLATE_TYPE_PARM:
8716 case TEMPLATE_TEMPLATE_PARM:
8717 case BOUND_TEMPLATE_TEMPLATE_PARM:
8718 case TEMPLATE_PARM_INDEX:
8723 tree arg = NULL_TREE;
8727 gcc_assert (TREE_VEC_LENGTH (args) > 0);
8728 template_parm_level_and_index (t, &level, &idx);
8730 levels = TMPL_ARGS_DEPTH (args);
8731 if (level <= levels)
8733 arg = TMPL_ARG (args, level, idx);
8735 if (arg && TREE_CODE (arg) == ARGUMENT_PACK_SELECT)
8736 /* See through ARGUMENT_PACK_SELECT arguments. */
8737 arg = ARGUMENT_PACK_SELECT_ARG (arg);
8740 if (arg == error_mark_node)
8741 return error_mark_node;
8742 else if (arg != NULL_TREE)
8744 if (ARGUMENT_PACK_P (arg))
8745 /* If ARG is an argument pack, we don't actually want to
8746 perform a substitution here, because substitutions
8747 for argument packs are only done
8748 element-by-element. We can get to this point when
8749 substituting the type of a non-type template
8750 parameter pack, when that type actually contains
8751 template parameter packs from an outer template, e.g.,
8753 template<typename... Types> struct A {
8754 template<Types... Values> struct B { };
8758 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
8761 gcc_assert (TYPE_P (arg));
8763 /* cv-quals from the template are discarded when
8764 substituting in a function or reference type. */
8765 if (TREE_CODE (arg) == FUNCTION_TYPE
8766 || TREE_CODE (arg) == METHOD_TYPE
8767 || TREE_CODE (arg) == REFERENCE_TYPE)
8768 quals = cp_type_quals (arg);
8770 quals = cp_type_quals (arg) | cp_type_quals (t);
8772 return cp_build_qualified_type_real
8773 (arg, quals, complain | tf_ignore_bad_quals);
8775 else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
8777 /* We are processing a type constructed from a
8778 template template parameter. */
8779 tree argvec = tsubst (TYPE_TI_ARGS (t),
8780 args, complain, in_decl);
8781 if (argvec == error_mark_node)
8782 return error_mark_node;
8784 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
8785 are resolving nested-types in the signature of a
8786 member function templates. Otherwise ARG is a
8787 TEMPLATE_DECL and is the real template to be
8789 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
8790 arg = TYPE_NAME (arg);
8792 r = lookup_template_class (arg,
8795 /*entering_scope=*/0,
8797 return cp_build_qualified_type_real
8798 (r, TYPE_QUALS (t), complain);
8801 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
8806 /* This can happen during the attempted tsubst'ing in
8807 unify. This means that we don't yet have any information
8808 about the template parameter in question. */
8811 /* If we get here, we must have been looking at a parm for a
8812 more deeply nested template. Make a new version of this
8813 template parameter, but with a lower level. */
8814 switch (TREE_CODE (t))
8816 case TEMPLATE_TYPE_PARM:
8817 case TEMPLATE_TEMPLATE_PARM:
8818 case BOUND_TEMPLATE_TEMPLATE_PARM:
8819 if (cp_type_quals (t))
8821 r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
8822 r = cp_build_qualified_type_real
8823 (r, cp_type_quals (t),
8824 complain | (TREE_CODE (t) == TEMPLATE_TYPE_PARM
8825 ? tf_ignore_bad_quals : 0));
8830 TEMPLATE_TYPE_PARM_INDEX (r)
8831 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t),
8833 TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r);
8834 TYPE_MAIN_VARIANT (r) = r;
8835 TYPE_POINTER_TO (r) = NULL_TREE;
8836 TYPE_REFERENCE_TO (r) = NULL_TREE;
8838 if (TREE_CODE (r) == TEMPLATE_TEMPLATE_PARM)
8839 /* We have reduced the level of the template
8840 template parameter, but not the levels of its
8841 template parameters, so canonical_type_parameter
8842 will not be able to find the canonical template
8843 template parameter for this level. Thus, we
8844 require structural equality checking to compare
8845 TEMPLATE_TEMPLATE_PARMs. */
8846 SET_TYPE_STRUCTURAL_EQUALITY (r);
8847 else if (TYPE_STRUCTURAL_EQUALITY_P (t))
8848 SET_TYPE_STRUCTURAL_EQUALITY (r);
8850 TYPE_CANONICAL (r) = canonical_type_parameter (r);
8852 if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
8854 tree argvec = tsubst (TYPE_TI_ARGS (t), args,
8856 if (argvec == error_mark_node)
8857 return error_mark_node;
8859 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r)
8860 = tree_cons (TYPE_TI_TEMPLATE (t), argvec, NULL_TREE);
8865 case TEMPLATE_PARM_INDEX:
8866 r = reduce_template_parm_level (t, type, levels);
8878 tree purpose, value, chain;
8880 if (t == void_list_node)
8883 purpose = TREE_PURPOSE (t);
8886 purpose = tsubst (purpose, args, complain, in_decl);
8887 if (purpose == error_mark_node)
8888 return error_mark_node;
8890 value = TREE_VALUE (t);
8893 value = tsubst (value, args, complain, in_decl);
8894 if (value == error_mark_node)
8895 return error_mark_node;
8897 chain = TREE_CHAIN (t);
8898 if (chain && chain != void_type_node)
8900 chain = tsubst (chain, args, complain, in_decl);
8901 if (chain == error_mark_node)
8902 return error_mark_node;
8904 if (purpose == TREE_PURPOSE (t)
8905 && value == TREE_VALUE (t)
8906 && chain == TREE_CHAIN (t))
8908 return hash_tree_cons (purpose, value, chain);
8912 /* We should never be tsubsting a binfo. */
8916 /* A vector of template arguments. */
8918 return tsubst_template_args (t, args, complain, in_decl);
8921 case REFERENCE_TYPE:
8923 enum tree_code code;
8925 if (type == TREE_TYPE (t) && TREE_CODE (type) != METHOD_TYPE)
8928 code = TREE_CODE (t);
8933 Type deduction may fail for any of the following
8936 -- Attempting to create a pointer to reference type.
8937 -- Attempting to create a reference to a reference type or
8938 a reference to void.
8940 Core issue 106 says that creating a reference to a reference
8941 during instantiation is no longer a cause for failure. We
8942 only enforce this check in strict C++98 mode. */
8943 if ((TREE_CODE (type) == REFERENCE_TYPE
8944 && (((cxx_dialect == cxx98) && flag_iso) || code != REFERENCE_TYPE))
8945 || (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE))
8947 static location_t last_loc;
8949 /* We keep track of the last time we issued this error
8950 message to avoid spewing a ton of messages during a
8951 single bad template instantiation. */
8952 if (complain & tf_error
8953 #ifdef USE_MAPPED_LOCATION
8954 && last_loc != input_location
8956 && (last_loc.line != input_line
8957 || last_loc.file != input_filename)
8961 if (TREE_CODE (type) == VOID_TYPE)
8962 error ("forming reference to void");
8964 error ("forming %s to reference type %qT",
8965 (code == POINTER_TYPE) ? "pointer" : "reference",
8967 last_loc = input_location;
8970 return error_mark_node;
8972 else if (code == POINTER_TYPE)
8974 r = build_pointer_type (type);
8975 if (TREE_CODE (type) == METHOD_TYPE)
8976 r = build_ptrmemfunc_type (r);
8978 else if (TREE_CODE (type) == REFERENCE_TYPE)
8979 /* In C++0x, during template argument substitution, when there is an
8980 attempt to create a reference to a reference type, reference
8981 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
8983 "If a template-argument for a template-parameter T names a type
8984 that is a reference to a type A, an attempt to create the type
8985 'lvalue reference to cv T' creates the type 'lvalue reference to
8986 A,' while an attempt to create the type type rvalue reference to
8987 cv T' creates the type T"
8989 r = cp_build_reference_type
8991 TYPE_REF_IS_RVALUE (t) && TYPE_REF_IS_RVALUE (type));
8993 r = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
8994 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
8996 if (r != error_mark_node)
8997 /* Will this ever be needed for TYPE_..._TO values? */
9004 r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
9005 if (r == error_mark_node || !IS_AGGR_TYPE (r))
9009 Type deduction may fail for any of the following
9012 -- Attempting to create "pointer to member of T" when T
9013 is not a class type. */
9014 if (complain & tf_error)
9015 error ("creating pointer to member of non-class type %qT", r);
9016 return error_mark_node;
9018 if (TREE_CODE (type) == REFERENCE_TYPE)
9020 if (complain & tf_error)
9021 error ("creating pointer to member reference type %qT", type);
9022 return error_mark_node;
9024 if (TREE_CODE (type) == VOID_TYPE)
9026 if (complain & tf_error)
9027 error ("creating pointer to member of type void");
9028 return error_mark_node;
9030 gcc_assert (TREE_CODE (type) != METHOD_TYPE);
9031 if (TREE_CODE (type) == FUNCTION_TYPE)
9033 /* The type of the implicit object parameter gets its
9034 cv-qualifiers from the FUNCTION_TYPE. */
9036 tree this_type = cp_build_qualified_type (TYPE_MAIN_VARIANT (r),
9037 cp_type_quals (type));
9039 method_type = build_method_type_directly (this_type,
9041 TYPE_ARG_TYPES (type));
9042 memptr = build_ptrmemfunc_type (build_pointer_type (method_type));
9043 return cp_build_qualified_type_real (memptr, cp_type_quals (t),
9047 return cp_build_qualified_type_real (build_ptrmem_type (r, type),
9056 fntype = tsubst_function_type (t, args, complain, in_decl);
9057 if (fntype == error_mark_node)
9058 return error_mark_node;
9060 /* Substitute the exception specification. */
9061 specs = tsubst_exception_specification (t, args, complain,
9063 if (specs == error_mark_node)
9064 return error_mark_node;
9066 fntype = build_exception_variant (fntype, specs);
9071 tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
9072 if (domain == error_mark_node)
9073 return error_mark_node;
9075 /* As an optimization, we avoid regenerating the array type if
9076 it will obviously be the same as T. */
9077 if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
9080 /* These checks should match the ones in grokdeclarator.
9084 The deduction may fail for any of the following reasons:
9086 -- Attempting to create an array with an element type that
9087 is void, a function type, or a reference type, or [DR337]
9088 an abstract class type. */
9089 if (TREE_CODE (type) == VOID_TYPE
9090 || TREE_CODE (type) == FUNCTION_TYPE
9091 || TREE_CODE (type) == REFERENCE_TYPE)
9093 if (complain & tf_error)
9094 error ("creating array of %qT", type);
9095 return error_mark_node;
9097 if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
9099 if (complain & tf_error)
9100 error ("creating array of %qT, which is an abstract class type",
9102 return error_mark_node;
9105 r = build_cplus_array_type (type, domain);
9107 if (TYPE_USER_ALIGN (t))
9109 TYPE_ALIGN (r) = TYPE_ALIGN (t);
9110 TYPE_USER_ALIGN (r) = 1;
9119 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
9120 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
9122 if (e1 == error_mark_node || e2 == error_mark_node)
9123 return error_mark_node;
9125 return fold_build2 (TREE_CODE (t), TREE_TYPE (t), e1, e2);
9131 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
9132 if (e == error_mark_node)
9133 return error_mark_node;
9135 return fold_build1 (TREE_CODE (t), TREE_TYPE (t), e);
9140 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
9141 in_decl, /*entering_scope=*/1);
9142 tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
9145 if (ctx == error_mark_node || f == error_mark_node)
9146 return error_mark_node;
9148 if (!IS_AGGR_TYPE (ctx))
9150 if (complain & tf_error)
9151 error ("%qT is not a class, struct, or union type", ctx);
9152 return error_mark_node;
9154 else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
9156 /* Normally, make_typename_type does not require that the CTX
9157 have complete type in order to allow things like:
9159 template <class T> struct S { typename S<T>::X Y; };
9161 But, such constructs have already been resolved by this
9162 point, so here CTX really should have complete type, unless
9163 it's a partial instantiation. */
9164 ctx = complete_type (ctx);
9165 if (!COMPLETE_TYPE_P (ctx))
9167 if (complain & tf_error)
9168 cxx_incomplete_type_error (NULL_TREE, ctx);
9169 return error_mark_node;
9173 f = make_typename_type (ctx, f, typename_type,
9174 (complain & tf_error) | tf_keep_type_decl);
9175 if (f == error_mark_node)
9177 if (TREE_CODE (f) == TYPE_DECL)
9179 complain |= tf_ignore_bad_quals;
9183 if (TREE_CODE (f) != TYPENAME_TYPE)
9185 if (TYPENAME_IS_ENUM_P (t) && TREE_CODE (f) != ENUMERAL_TYPE)
9186 error ("%qT resolves to %qT, which is not an enumeration type",
9188 else if (TYPENAME_IS_CLASS_P (t) && !CLASS_TYPE_P (f))
9189 error ("%qT resolves to %qT, which is is not a class type",
9193 return cp_build_qualified_type_real
9194 (f, cp_type_quals (f) | cp_type_quals (t), complain);
9197 case UNBOUND_CLASS_TEMPLATE:
9199 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
9200 in_decl, /*entering_scope=*/1);
9201 tree name = TYPE_IDENTIFIER (t);
9202 tree parm_list = DECL_TEMPLATE_PARMS (TYPE_NAME (t));
9204 if (ctx == error_mark_node || name == error_mark_node)
9205 return error_mark_node;
9208 parm_list = tsubst_template_parms (parm_list, args, complain);
9209 return make_unbound_class_template (ctx, name, parm_list, complain);
9219 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
9220 tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl,
9221 /*integral_constant_expression_p=*/false);
9222 if (e1 == error_mark_node || e2 == error_mark_node)
9223 return error_mark_node;
9225 return build_nt (ARRAY_REF, e1, e2, NULL_TREE, NULL_TREE);
9230 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
9231 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
9232 if (e1 == error_mark_node || e2 == error_mark_node)
9233 return error_mark_node;
9235 return build_qualified_name (/*type=*/NULL_TREE,
9236 e1, e2, QUALIFIED_NAME_IS_TEMPLATE (t));
9243 type = finish_typeof (tsubst_expr
9244 (TYPEOF_TYPE_EXPR (t), args,
9246 /*integral_constant_expression_p=*/false));
9247 return cp_build_qualified_type_real (type,
9249 | cp_type_quals (type),
9258 finish_decltype_type (tsubst_expr
9259 (DECLTYPE_TYPE_EXPR (t), args,
9261 /*integral_constant_expression_p=*/false),
9262 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t));
9263 return cp_build_qualified_type_real (type,
9265 | cp_type_quals (type),
9269 case TYPE_ARGUMENT_PACK:
9270 case NONTYPE_ARGUMENT_PACK:
9272 tree r = make_node (TREE_CODE (t));
9274 tsubst_template_args (ARGUMENT_PACK_ARGS (t),
9278 SET_ARGUMENT_PACK_ARGS (r, packed_out);
9280 /* For template nontype argument packs, also substitute into
9282 if (TREE_CODE (t) == NONTYPE_ARGUMENT_PACK)
9283 TREE_TYPE (r) = tsubst (TREE_TYPE (t), args, complain, in_decl);
9290 sorry ("use of %qs in template",
9291 tree_code_name [(int) TREE_CODE (t)]);
9292 return error_mark_node;
9296 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
9297 type of the expression on the left-hand side of the "." or "->"
9301 tsubst_baselink (tree baselink, tree object_type,
9302 tree args, tsubst_flags_t complain, tree in_decl)
9305 tree qualifying_scope;
9308 tree template_args = 0;
9309 bool template_id_p = false;
9311 /* A baselink indicates a function from a base class. Both the
9312 BASELINK_ACCESS_BINFO and the base class referenced may
9313 indicate bases of the template class, rather than the
9314 instantiated class. In addition, lookups that were not
9315 ambiguous before may be ambiguous now. Therefore, we perform
9316 the lookup again. */
9317 qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink));
9318 qualifying_scope = tsubst (qualifying_scope, args,
9320 fns = BASELINK_FUNCTIONS (baselink);
9321 optype = BASELINK_OPTYPE (baselink);
9322 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
9324 template_id_p = true;
9325 template_args = TREE_OPERAND (fns, 1);
9326 fns = TREE_OPERAND (fns, 0);
9328 template_args = tsubst_template_args (template_args, args,
9331 name = DECL_NAME (get_first_fn (fns));
9332 baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1);
9334 /* If lookup found a single function, mark it as used at this
9335 point. (If it lookup found multiple functions the one selected
9336 later by overload resolution will be marked as used at that
9338 if (BASELINK_P (baselink))
9339 fns = BASELINK_FUNCTIONS (baselink);
9340 if (!template_id_p && !really_overloaded_fn (fns))
9341 mark_used (OVL_CURRENT (fns));
9343 /* Add back the template arguments, if present. */
9344 if (BASELINK_P (baselink) && template_id_p)
9345 BASELINK_FUNCTIONS (baselink)
9346 = build_nt (TEMPLATE_ID_EXPR,
9347 BASELINK_FUNCTIONS (baselink),
9349 /* Update the conversion operator type. */
9350 BASELINK_OPTYPE (baselink)
9351 = tsubst (optype, args, complain, in_decl);
9354 object_type = current_class_type;
9355 return adjust_result_of_qualified_name_lookup (baselink,
9360 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
9361 true if the qualified-id will be a postfix-expression in-and-of
9362 itself; false if more of the postfix-expression follows the
9363 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
9367 tsubst_qualified_id (tree qualified_id, tree args,
9368 tsubst_flags_t complain, tree in_decl,
9369 bool done, bool address_p)
9377 gcc_assert (TREE_CODE (qualified_id) == SCOPE_REF);
9379 /* Figure out what name to look up. */
9380 name = TREE_OPERAND (qualified_id, 1);
9381 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
9384 template_args = TREE_OPERAND (name, 1);
9386 template_args = tsubst_template_args (template_args, args,
9388 name = TREE_OPERAND (name, 0);
9392 is_template = false;
9393 template_args = NULL_TREE;
9396 /* Substitute into the qualifying scope. When there are no ARGS, we
9397 are just trying to simplify a non-dependent expression. In that
9398 case the qualifying scope may be dependent, and, in any case,
9399 substituting will not help. */
9400 scope = TREE_OPERAND (qualified_id, 0);
9403 scope = tsubst (scope, args, complain, in_decl);
9404 expr = tsubst_copy (name, args, complain, in_decl);
9409 if (dependent_type_p (scope))
9410 return build_qualified_name (/*type=*/NULL_TREE,
9412 QUALIFIED_NAME_IS_TEMPLATE (qualified_id));
9414 if (!BASELINK_P (name) && !DECL_P (expr))
9416 if (TREE_CODE (expr) == BIT_NOT_EXPR)
9417 /* If this were actually a destructor call, it would have been
9418 parsed as such by the parser. */
9419 expr = error_mark_node;
9421 expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0, false);
9422 if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL
9423 ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL)
9425 if (complain & tf_error)
9427 error ("dependent-name %qE is parsed as a non-type, but "
9428 "instantiation yields a type", qualified_id);
9429 inform ("say %<typename %E%> if a type is meant", qualified_id);
9431 return error_mark_node;
9437 check_accessibility_of_qualified_id (expr, /*object_type=*/NULL_TREE,
9439 /* Remember that there was a reference to this entity. */
9443 if (expr == error_mark_node || TREE_CODE (expr) == TREE_LIST)
9445 if (complain & tf_error)
9446 qualified_name_lookup_error (scope,
9447 TREE_OPERAND (qualified_id, 1),
9449 return error_mark_node;
9453 expr = lookup_template_function (expr, template_args);
9455 if (expr == error_mark_node && complain & tf_error)
9456 qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1),
9458 else if (TYPE_P (scope))
9460 expr = (adjust_result_of_qualified_name_lookup
9461 (expr, scope, current_class_type));
9462 expr = (finish_qualified_id_expr
9463 (scope, expr, done, address_p,
9464 QUALIFIED_NAME_IS_TEMPLATE (qualified_id),
9465 /*template_arg_p=*/false));
9468 /* Expressions do not generally have reference type. */
9469 if (TREE_CODE (expr) != SCOPE_REF
9470 /* However, if we're about to form a pointer-to-member, we just
9471 want the referenced member referenced. */
9472 && TREE_CODE (expr) != OFFSET_REF)
9473 expr = convert_from_reference (expr);
9478 /* Like tsubst, but deals with expressions. This function just replaces
9479 template parms; to finish processing the resultant expression, use
9483 tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
9485 enum tree_code code;
9488 if (t == NULL_TREE || t == error_mark_node)
9491 code = TREE_CODE (t);
9496 r = retrieve_local_specialization (t);
9497 gcc_assert (r != NULL);
9498 if (TREE_CODE (r) == ARGUMENT_PACK_SELECT)
9499 r = ARGUMENT_PACK_SELECT_ARG (r);
9508 if (DECL_TEMPLATE_PARM_P (t))
9509 return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
9510 /* There is no need to substitute into namespace-scope
9512 if (DECL_NAMESPACE_SCOPE_P (t))
9514 /* If ARGS is NULL, then T is known to be non-dependent. */
9515 if (args == NULL_TREE)
9516 return integral_constant_value (t);
9518 /* Unfortunately, we cannot just call lookup_name here.
9521 template <int I> int f() {
9523 struct S { void g() { E e = a; } };
9526 When we instantiate f<7>::S::g(), say, lookup_name is not
9527 clever enough to find f<7>::a. */
9529 = tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl,
9530 /*entering_scope=*/0);
9532 for (v = TYPE_VALUES (enum_type);
9535 if (TREE_PURPOSE (v) == DECL_NAME (t))
9536 return TREE_VALUE (v);
9538 /* We didn't find the name. That should never happen; if
9539 name-lookup found it during preliminary parsing, we
9540 should find it again here during instantiation. */
9546 if (DECL_CONTEXT (t))
9550 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
9551 /*entering_scope=*/1);
9552 if (ctx != DECL_CONTEXT (t))
9554 tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
9557 if (complain & tf_error)
9558 error ("using invalid field %qD", t);
9559 return error_mark_node;
9569 if ((DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
9570 || local_variable_p (t))
9571 t = tsubst (t, args, complain, in_decl);
9576 return tsubst_baselink (t, current_class_type, args, complain, in_decl);
9579 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
9580 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
9581 args, complain, in_decl);
9582 else if (DECL_FUNCTION_TEMPLATE_P (t) && DECL_MEMBER_TEMPLATE_P (t))
9583 return tsubst (t, args, complain, in_decl);
9584 else if (DECL_CLASS_SCOPE_P (t)
9585 && uses_template_parms (DECL_CONTEXT (t)))
9587 /* Template template argument like the following example need
9590 template <template <class> class TT> struct C {};
9591 template <class T> struct D {
9592 template <class U> struct E {};
9597 We are processing the template argument `E' in #1 for
9598 the template instantiation #2. Originally, `E' is a
9599 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
9600 have to substitute this with one having context `D<int>'. */
9602 tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
9603 return lookup_field (context, DECL_NAME(t), 0, false);
9606 /* Ordinary template template argument. */
9610 case REINTERPRET_CAST_EXPR:
9611 case CONST_CAST_EXPR:
9612 case STATIC_CAST_EXPR:
9613 case DYNAMIC_CAST_EXPR:
9616 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
9617 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
9620 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
9622 /* We only want to compute the number of arguments. */
9623 tree expanded = tsubst_pack_expansion (TREE_OPERAND (t, 0), args,
9625 if (expanded == error_mark_node)
9626 return error_mark_node;
9627 return build_int_cst (size_type_node, TREE_VEC_LENGTH (expanded));
9633 case TRUTH_NOT_EXPR:
9636 case UNARY_PLUS_EXPR: /* Unary + */
9644 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
9645 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
9652 object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
9653 name = TREE_OPERAND (t, 1);
9654 if (TREE_CODE (name) == BIT_NOT_EXPR)
9656 name = tsubst_copy (TREE_OPERAND (name, 0), args,
9658 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
9660 else if (TREE_CODE (name) == SCOPE_REF
9661 && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
9663 tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
9665 name = TREE_OPERAND (name, 1);
9666 name = tsubst_copy (TREE_OPERAND (name, 0), args,
9668 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
9669 name = build_qualified_name (/*type=*/NULL_TREE,
9671 /*template_p=*/false);
9673 else if (TREE_CODE (name) == BASELINK)
9674 name = tsubst_baselink (name,
9675 non_reference (TREE_TYPE (object)),
9679 name = tsubst_copy (name, args, complain, in_decl);
9680 return build_nt (COMPONENT_REF, object, name, NULL_TREE);
9686 case TRUNC_DIV_EXPR:
9688 case FLOOR_DIV_EXPR:
9689 case ROUND_DIV_EXPR:
9690 case EXACT_DIV_EXPR:
9694 case TRUNC_MOD_EXPR:
9695 case FLOOR_MOD_EXPR:
9696 case TRUTH_ANDIF_EXPR:
9697 case TRUTH_ORIF_EXPR:
9698 case TRUTH_AND_EXPR:
9715 case PREDECREMENT_EXPR:
9716 case PREINCREMENT_EXPR:
9717 case POSTDECREMENT_EXPR:
9718 case POSTINCREMENT_EXPR:
9720 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9721 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
9724 return build_qualified_name (/*type=*/NULL_TREE,
9725 tsubst_copy (TREE_OPERAND (t, 0),
9726 args, complain, in_decl),
9727 tsubst_copy (TREE_OPERAND (t, 1),
9728 args, complain, in_decl),
9729 QUALIFIED_NAME_IS_TEMPLATE (t));
9734 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9735 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
9736 NULL_TREE, NULL_TREE);
9740 int n = VL_EXP_OPERAND_LENGTH (t);
9741 tree result = build_vl_exp (CALL_EXPR, n);
9743 for (i = 0; i < n; i++)
9744 TREE_OPERAND (t, i) = tsubst_copy (TREE_OPERAND (t, i), args,
9751 case PSEUDO_DTOR_EXPR:
9754 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9755 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
9756 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
9757 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
9764 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9765 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
9766 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
9767 NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
9774 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9775 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
9776 DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
9777 DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
9781 case TEMPLATE_ID_EXPR:
9783 /* Substituted template arguments */
9784 tree fn = TREE_OPERAND (t, 0);
9785 tree targs = TREE_OPERAND (t, 1);
9787 fn = tsubst_copy (fn, args, complain, in_decl);
9789 targs = tsubst_template_args (targs, args, complain, in_decl);
9791 return lookup_template_function (fn, targs);
9796 tree purpose, value, chain;
9798 if (t == void_list_node)
9801 purpose = TREE_PURPOSE (t);
9803 purpose = tsubst_copy (purpose, args, complain, in_decl);
9804 value = TREE_VALUE (t);
9806 value = tsubst_copy (value, args, complain, in_decl);
9807 chain = TREE_CHAIN (t);
9808 if (chain && chain != void_type_node)
9809 chain = tsubst_copy (chain, args, complain, in_decl);
9810 if (purpose == TREE_PURPOSE (t)
9811 && value == TREE_VALUE (t)
9812 && chain == TREE_CHAIN (t))
9814 return tree_cons (purpose, value, chain);
9821 case TEMPLATE_TYPE_PARM:
9822 case TEMPLATE_TEMPLATE_PARM:
9823 case BOUND_TEMPLATE_TEMPLATE_PARM:
9824 case TEMPLATE_PARM_INDEX:
9826 case REFERENCE_TYPE:
9832 case UNBOUND_CLASS_TEMPLATE:
9836 return tsubst (t, args, complain, in_decl);
9838 case IDENTIFIER_NODE:
9839 if (IDENTIFIER_TYPENAME_P (t))
9841 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
9842 return mangle_conv_op_name_for_type (new_type);
9848 /* This is handled by tsubst_copy_and_build. */
9852 return build_x_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain,
9854 tsubst (TREE_TYPE (t), args, complain, in_decl));
9856 case CLEANUP_POINT_EXPR:
9857 /* We shouldn't have built any of these during initial template
9858 generation. Instead, they should be built during instantiation
9859 in response to the saved STMT_IS_FULL_EXPR_P setting. */
9863 mark_used (TREE_OPERAND (t, 1));
9866 case EXPR_PACK_EXPANSION:
9867 error ("invalid use of pack expansion expression");
9868 return error_mark_node;
9870 case NONTYPE_ARGUMENT_PACK:
9871 error ("use %<...%> to expand argument pack");
9872 return error_mark_node;
9879 /* Like tsubst_copy, but specifically for OpenMP clauses. */
9882 tsubst_omp_clauses (tree clauses, tree args, tsubst_flags_t complain,
9885 tree new_clauses = NULL, nc, oc;
9887 for (oc = clauses; oc ; oc = OMP_CLAUSE_CHAIN (oc))
9889 nc = copy_node (oc);
9890 OMP_CLAUSE_CHAIN (nc) = new_clauses;
9893 switch (OMP_CLAUSE_CODE (nc))
9895 case OMP_CLAUSE_PRIVATE:
9896 case OMP_CLAUSE_SHARED:
9897 case OMP_CLAUSE_FIRSTPRIVATE:
9898 case OMP_CLAUSE_LASTPRIVATE:
9899 case OMP_CLAUSE_REDUCTION:
9900 case OMP_CLAUSE_COPYIN:
9901 case OMP_CLAUSE_COPYPRIVATE:
9903 case OMP_CLAUSE_NUM_THREADS:
9904 case OMP_CLAUSE_SCHEDULE:
9905 OMP_CLAUSE_OPERAND (nc, 0)
9906 = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 0), args, complain,
9907 in_decl, /*integral_constant_expression_p=*/false);
9909 case OMP_CLAUSE_NOWAIT:
9910 case OMP_CLAUSE_ORDERED:
9911 case OMP_CLAUSE_DEFAULT:
9918 return finish_omp_clauses (nreverse (new_clauses));
9921 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
9924 tsubst_copy_asm_operands (tree t, tree args, tsubst_flags_t complain,
9927 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
9929 tree purpose, value, chain;
9934 if (TREE_CODE (t) != TREE_LIST)
9935 return tsubst_copy_and_build (t, args, complain, in_decl,
9936 /*function_p=*/false,
9937 /*integral_constant_expression_p=*/false);
9939 if (t == void_list_node)
9942 purpose = TREE_PURPOSE (t);
9944 purpose = RECUR (purpose);
9945 value = TREE_VALUE (t);
9947 value = RECUR (value);
9948 chain = TREE_CHAIN (t);
9949 if (chain && chain != void_type_node)
9950 chain = RECUR (chain);
9951 return tree_cons (purpose, value, chain);
9955 /* Like tsubst_copy for expressions, etc. but also does semantic
9959 tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl,
9960 bool integral_constant_expression_p)
9962 #define RECUR(NODE) \
9963 tsubst_expr ((NODE), args, complain, in_decl, \
9964 integral_constant_expression_p)
9968 if (t == NULL_TREE || t == error_mark_node)
9971 if (EXPR_HAS_LOCATION (t))
9972 input_location = EXPR_LOCATION (t);
9973 if (STATEMENT_CODE_P (TREE_CODE (t)))
9974 current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
9976 switch (TREE_CODE (t))
9978 case STATEMENT_LIST:
9980 tree_stmt_iterator i;
9981 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
9982 RECUR (tsi_stmt (i));
9986 case CTOR_INITIALIZER:
9987 finish_mem_initializers (tsubst_initializer_list
9988 (TREE_OPERAND (t, 0), args));
9992 finish_return_stmt (RECUR (TREE_OPERAND (t, 0)));
9996 tmp = RECUR (EXPR_STMT_EXPR (t));
9997 if (EXPR_STMT_STMT_EXPR_RESULT (t))
9998 finish_stmt_expr_expr (tmp, cur_stmt_expr);
10000 finish_expr_stmt (tmp);
10004 do_using_directive (RECUR (USING_STMT_NAMESPACE (t)));
10012 decl = DECL_EXPR_DECL (t);
10013 if (TREE_CODE (decl) == LABEL_DECL)
10014 finish_label_decl (DECL_NAME (decl));
10015 else if (TREE_CODE (decl) == USING_DECL)
10017 tree scope = USING_DECL_SCOPE (decl);
10018 tree name = DECL_NAME (decl);
10021 scope = RECUR (scope);
10022 decl = lookup_qualified_name (scope, name,
10023 /*is_type_p=*/false,
10024 /*complain=*/false);
10025 if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
10026 qualified_name_lookup_error (scope, name, decl);
10028 do_local_using_decl (decl, scope, name);
10032 init = DECL_INITIAL (decl);
10033 decl = tsubst (decl, args, complain, in_decl);
10034 if (decl != error_mark_node)
10036 /* By marking the declaration as instantiated, we avoid
10037 trying to instantiate it. Since instantiate_decl can't
10038 handle local variables, and since we've already done
10039 all that needs to be done, that's the right thing to
10041 if (TREE_CODE (decl) == VAR_DECL)
10042 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
10043 if (TREE_CODE (decl) == VAR_DECL
10044 && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
10045 /* Anonymous aggregates are a special case. */
10046 finish_anon_union (decl);
10049 maybe_push_decl (decl);
10050 if (TREE_CODE (decl) == VAR_DECL
10051 && DECL_PRETTY_FUNCTION_P (decl))
10053 /* For __PRETTY_FUNCTION__ we have to adjust the
10055 const char *const name
10056 = cxx_printable_name (current_function_decl, 2);
10057 init = cp_fname_init (name, &TREE_TYPE (decl));
10061 tree t = RECUR (init);
10064 /* If we had an initializer but it
10065 instantiated to nothing,
10066 value-initialize the object. This will
10067 only occur when the initializer was a
10068 pack expansion where the parameter packs
10069 used in that expansion were of length
10071 init = build_default_init (TREE_TYPE (decl),
10077 finish_decl (decl, init, NULL_TREE);
10082 /* A DECL_EXPR can also be used as an expression, in the condition
10083 clause of an if/for/while construct. */
10088 stmt = begin_for_stmt ();
10089 RECUR (FOR_INIT_STMT (t));
10090 finish_for_init_stmt (stmt);
10091 tmp = RECUR (FOR_COND (t));
10092 finish_for_cond (tmp, stmt);
10093 tmp = RECUR (FOR_EXPR (t));
10094 finish_for_expr (tmp, stmt);
10095 RECUR (FOR_BODY (t));
10096 finish_for_stmt (stmt);
10100 stmt = begin_while_stmt ();
10101 tmp = RECUR (WHILE_COND (t));
10102 finish_while_stmt_cond (tmp, stmt);
10103 RECUR (WHILE_BODY (t));
10104 finish_while_stmt (stmt);
10108 stmt = begin_do_stmt ();
10109 RECUR (DO_BODY (t));
10110 finish_do_body (stmt);
10111 tmp = RECUR (DO_COND (t));
10112 finish_do_stmt (tmp, stmt);
10116 stmt = begin_if_stmt ();
10117 tmp = RECUR (IF_COND (t));
10118 finish_if_stmt_cond (tmp, stmt);
10119 RECUR (THEN_CLAUSE (t));
10120 finish_then_clause (stmt);
10122 if (ELSE_CLAUSE (t))
10124 begin_else_clause (stmt);
10125 RECUR (ELSE_CLAUSE (t));
10126 finish_else_clause (stmt);
10129 finish_if_stmt (stmt);
10133 if (BIND_EXPR_BODY_BLOCK (t))
10134 stmt = begin_function_body ();
10136 stmt = begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t)
10137 ? BCS_TRY_BLOCK : 0);
10139 RECUR (BIND_EXPR_BODY (t));
10141 if (BIND_EXPR_BODY_BLOCK (t))
10142 finish_function_body (stmt);
10144 finish_compound_stmt (stmt);
10148 finish_break_stmt ();
10151 case CONTINUE_STMT:
10152 finish_continue_stmt ();
10156 stmt = begin_switch_stmt ();
10157 tmp = RECUR (SWITCH_STMT_COND (t));
10158 finish_switch_cond (tmp, stmt);
10159 RECUR (SWITCH_STMT_BODY (t));
10160 finish_switch_stmt (stmt);
10163 case CASE_LABEL_EXPR:
10164 finish_case_label (RECUR (CASE_LOW (t)),
10165 RECUR (CASE_HIGH (t)));
10169 finish_label_stmt (DECL_NAME (LABEL_EXPR_LABEL (t)));
10173 tmp = GOTO_DESTINATION (t);
10174 if (TREE_CODE (tmp) != LABEL_DECL)
10175 /* Computed goto's must be tsubst'd into. On the other hand,
10176 non-computed gotos must not be; the identifier in question
10177 will have no binding. */
10180 tmp = DECL_NAME (tmp);
10181 finish_goto_stmt (tmp);
10185 tmp = finish_asm_stmt
10186 (ASM_VOLATILE_P (t),
10187 RECUR (ASM_STRING (t)),
10188 tsubst_copy_asm_operands (ASM_OUTPUTS (t), args, complain, in_decl),
10189 tsubst_copy_asm_operands (ASM_INPUTS (t), args, complain, in_decl),
10190 tsubst_copy_asm_operands (ASM_CLOBBERS (t), args, complain, in_decl));
10192 tree asm_expr = tmp;
10193 if (TREE_CODE (asm_expr) == CLEANUP_POINT_EXPR)
10194 asm_expr = TREE_OPERAND (asm_expr, 0);
10195 ASM_INPUT_P (asm_expr) = ASM_INPUT_P (t);
10202 stmt = begin_try_block ();
10203 RECUR (TRY_STMTS (t));
10204 finish_cleanup_try_block (stmt);
10205 finish_cleanup (RECUR (TRY_HANDLERS (t)), stmt);
10209 tree compound_stmt = NULL_TREE;
10211 if (FN_TRY_BLOCK_P (t))
10212 stmt = begin_function_try_block (&compound_stmt);
10214 stmt = begin_try_block ();
10216 RECUR (TRY_STMTS (t));
10218 if (FN_TRY_BLOCK_P (t))
10219 finish_function_try_block (stmt);
10221 finish_try_block (stmt);
10223 RECUR (TRY_HANDLERS (t));
10224 if (FN_TRY_BLOCK_P (t))
10225 finish_function_handler_sequence (stmt, compound_stmt);
10227 finish_handler_sequence (stmt);
10233 tree decl = HANDLER_PARMS (t);
10237 decl = tsubst (decl, args, complain, in_decl);
10238 /* Prevent instantiate_decl from trying to instantiate
10239 this variable. We've already done all that needs to be
10241 if (decl != error_mark_node)
10242 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
10244 stmt = begin_handler ();
10245 finish_handler_parms (decl, stmt);
10246 RECUR (HANDLER_BODY (t));
10247 finish_handler (stmt);
10252 tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
10255 case STATIC_ASSERT:
10258 tsubst_expr (STATIC_ASSERT_CONDITION (t),
10261 /*integral_constant_expression_p=*/true);
10262 finish_static_assert (condition,
10263 STATIC_ASSERT_MESSAGE (t),
10264 STATIC_ASSERT_SOURCE_LOCATION (t),
10265 /*member_p=*/false);
10270 tmp = tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t),
10271 args, complain, in_decl);
10272 stmt = begin_omp_parallel ();
10273 RECUR (OMP_PARALLEL_BODY (t));
10274 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp, stmt))
10275 = OMP_PARALLEL_COMBINED (t);
10280 tree clauses, decl, init, cond, incr, body, pre_body;
10282 clauses = tsubst_omp_clauses (OMP_FOR_CLAUSES (t),
10283 args, complain, in_decl);
10284 init = OMP_FOR_INIT (t);
10285 gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
10286 decl = RECUR (TREE_OPERAND (init, 0));
10287 init = RECUR (TREE_OPERAND (init, 1));
10288 cond = RECUR (OMP_FOR_COND (t));
10289 incr = RECUR (OMP_FOR_INCR (t));
10291 stmt = begin_omp_structured_block ();
10293 pre_body = push_stmt_list ();
10294 RECUR (OMP_FOR_PRE_BODY (t));
10295 pre_body = pop_stmt_list (pre_body);
10297 body = push_stmt_list ();
10298 RECUR (OMP_FOR_BODY (t));
10299 body = pop_stmt_list (body);
10301 t = finish_omp_for (EXPR_LOCATION (t), decl, init, cond, incr, body,
10304 OMP_FOR_CLAUSES (t) = clauses;
10306 add_stmt (finish_omp_structured_block (stmt));
10312 tmp = tsubst_omp_clauses (OMP_CLAUSES (t), args, complain, in_decl);
10313 stmt = push_stmt_list ();
10314 RECUR (OMP_BODY (t));
10315 stmt = pop_stmt_list (stmt);
10318 OMP_BODY (t) = stmt;
10319 OMP_CLAUSES (t) = tmp;
10327 stmt = push_stmt_list ();
10328 RECUR (OMP_BODY (t));
10329 stmt = pop_stmt_list (stmt);
10332 OMP_BODY (t) = stmt;
10337 if (OMP_ATOMIC_DEPENDENT_P (t))
10339 tree op1 = TREE_OPERAND (t, 1);
10340 tree lhs = RECUR (TREE_OPERAND (op1, 0));
10341 tree rhs = RECUR (TREE_OPERAND (op1, 1));
10342 finish_omp_atomic (TREE_CODE (op1), lhs, rhs);
10346 case EXPR_PACK_EXPANSION:
10347 error ("invalid use of pack expansion expression");
10348 return error_mark_node;
10350 case NONTYPE_ARGUMENT_PACK:
10351 error ("use %<...%> to expand argument pack");
10352 return error_mark_node;
10355 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t)));
10357 return tsubst_copy_and_build (t, args, complain, in_decl,
10358 /*function_p=*/false,
10359 integral_constant_expression_p);
10366 /* T is a postfix-expression that is not being used in a function
10367 call. Return the substituted version of T. */
10370 tsubst_non_call_postfix_expression (tree t, tree args,
10371 tsubst_flags_t complain,
10374 if (TREE_CODE (t) == SCOPE_REF)
10375 t = tsubst_qualified_id (t, args, complain, in_decl,
10376 /*done=*/false, /*address_p=*/false);
10378 t = tsubst_copy_and_build (t, args, complain, in_decl,
10379 /*function_p=*/false,
10380 /*integral_constant_expression_p=*/false);
10385 /* Like tsubst but deals with expressions and performs semantic
10386 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
10389 tsubst_copy_and_build (tree t,
10391 tsubst_flags_t complain,
10394 bool integral_constant_expression_p)
10396 #define RECUR(NODE) \
10397 tsubst_copy_and_build (NODE, args, complain, in_decl, \
10398 /*function_p=*/false, \
10399 integral_constant_expression_p)
10403 if (t == NULL_TREE || t == error_mark_node)
10406 switch (TREE_CODE (t))
10410 /* Fall through. */
10411 case IDENTIFIER_NODE:
10415 bool non_integral_constant_expression_p;
10416 const char *error_msg;
10418 if (IDENTIFIER_TYPENAME_P (t))
10420 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10421 t = mangle_conv_op_name_for_type (new_type);
10424 /* Look up the name. */
10425 decl = lookup_name (t);
10427 /* By convention, expressions use ERROR_MARK_NODE to indicate
10428 failure, not NULL_TREE. */
10429 if (decl == NULL_TREE)
10430 decl = error_mark_node;
10432 decl = finish_id_expression (t, decl, NULL_TREE,
10434 integral_constant_expression_p,
10435 /*allow_non_integral_constant_expression_p=*/false,
10436 &non_integral_constant_expression_p,
10437 /*template_p=*/false,
10439 /*address_p=*/false,
10440 /*template_arg_p=*/false,
10444 if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE)
10445 decl = unqualified_name_lookup_error (decl);
10449 case TEMPLATE_ID_EXPR:
10452 tree template = RECUR (TREE_OPERAND (t, 0));
10453 tree targs = TREE_OPERAND (t, 1);
10456 targs = tsubst_template_args (targs, args, complain, in_decl);
10458 if (TREE_CODE (template) == COMPONENT_REF)
10460 object = TREE_OPERAND (template, 0);
10461 template = TREE_OPERAND (template, 1);
10464 object = NULL_TREE;
10465 template = lookup_template_function (template, targs);
10468 return build3 (COMPONENT_REF, TREE_TYPE (template),
10469 object, template, NULL_TREE);
10471 return baselink_for_fns (template);
10476 tree r = RECUR (TREE_OPERAND (t, 0));
10478 if (REFERENCE_REF_P (t))
10480 /* A type conversion to reference type will be enclosed in
10481 such an indirect ref, but the substitution of the cast
10482 will have also added such an indirect ref. */
10483 if (TREE_CODE (TREE_TYPE (r)) == REFERENCE_TYPE)
10484 r = convert_from_reference (r);
10487 r = build_x_indirect_ref (r, "unary *");
10493 (tsubst (TREE_TYPE (t), args, complain, in_decl),
10494 RECUR (TREE_OPERAND (t, 0)));
10497 case REINTERPRET_CAST_EXPR:
10498 case CONST_CAST_EXPR:
10499 case DYNAMIC_CAST_EXPR:
10500 case STATIC_CAST_EXPR:
10505 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10506 if (integral_constant_expression_p
10507 && !cast_valid_in_integral_constant_expression_p (type))
10509 error ("a cast to a type other than an integral or "
10510 "enumeration type cannot appear in a constant-expression");
10511 return error_mark_node;
10514 op = RECUR (TREE_OPERAND (t, 0));
10516 switch (TREE_CODE (t))
10519 return build_functional_cast (type, op);
10520 case REINTERPRET_CAST_EXPR:
10521 return build_reinterpret_cast (type, op);
10522 case CONST_CAST_EXPR:
10523 return build_const_cast (type, op);
10524 case DYNAMIC_CAST_EXPR:
10525 return build_dynamic_cast (type, op);
10526 case STATIC_CAST_EXPR:
10527 return build_static_cast (type, op);
10529 gcc_unreachable ();
10533 case POSTDECREMENT_EXPR:
10534 case POSTINCREMENT_EXPR:
10535 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
10536 args, complain, in_decl);
10537 return build_x_unary_op (TREE_CODE (t), op1);
10539 case PREDECREMENT_EXPR:
10540 case PREINCREMENT_EXPR:
10544 case TRUTH_NOT_EXPR:
10545 case UNARY_PLUS_EXPR: /* Unary + */
10546 case REALPART_EXPR:
10547 case IMAGPART_EXPR:
10548 return build_x_unary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0)));
10551 op1 = TREE_OPERAND (t, 0);
10552 if (TREE_CODE (op1) == SCOPE_REF)
10553 op1 = tsubst_qualified_id (op1, args, complain, in_decl,
10554 /*done=*/true, /*address_p=*/true);
10556 op1 = tsubst_non_call_postfix_expression (op1, args, complain,
10558 if (TREE_CODE (op1) == LABEL_DECL)
10559 return finish_label_address_expr (DECL_NAME (op1));
10560 return build_x_unary_op (ADDR_EXPR, op1);
10565 case TRUNC_DIV_EXPR:
10566 case CEIL_DIV_EXPR:
10567 case FLOOR_DIV_EXPR:
10568 case ROUND_DIV_EXPR:
10569 case EXACT_DIV_EXPR:
10573 case TRUNC_MOD_EXPR:
10574 case FLOOR_MOD_EXPR:
10575 case TRUTH_ANDIF_EXPR:
10576 case TRUTH_ORIF_EXPR:
10577 case TRUTH_AND_EXPR:
10578 case TRUTH_OR_EXPR:
10593 return build_x_binary_op
10595 RECUR (TREE_OPERAND (t, 0)),
10596 (TREE_NO_WARNING (TREE_OPERAND (t, 0))
10598 : TREE_CODE (TREE_OPERAND (t, 0))),
10599 RECUR (TREE_OPERAND (t, 1)),
10600 (TREE_NO_WARNING (TREE_OPERAND (t, 1))
10602 : TREE_CODE (TREE_OPERAND (t, 1))),
10603 /*overloaded_p=*/NULL);
10606 return tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
10607 /*address_p=*/false);
10609 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
10610 args, complain, in_decl);
10611 return build_x_binary_op (ARRAY_REF, op1,
10612 (TREE_NO_WARNING (TREE_OPERAND (t, 0))
10614 : TREE_CODE (TREE_OPERAND (t, 0))),
10615 RECUR (TREE_OPERAND (t, 1)),
10616 (TREE_NO_WARNING (TREE_OPERAND (t, 1))
10618 : TREE_CODE (TREE_OPERAND (t, 1))),
10619 /*overloaded_p=*/NULL);
10622 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
10624 /* We only want to compute the number of arguments. */
10625 tree expanded = tsubst_pack_expansion (TREE_OPERAND (t, 0), args,
10626 complain, in_decl);
10627 if (expanded == error_mark_node)
10628 return error_mark_node;
10629 return build_int_cst (size_type_node, TREE_VEC_LENGTH (expanded));
10634 op1 = TREE_OPERAND (t, 0);
10637 /* When there are no ARGS, we are trying to evaluate a
10638 non-dependent expression from the parser. Trying to do
10639 the substitutions may not work. */
10641 op1 = TREE_TYPE (op1);
10646 op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
10647 /*function_p=*/false,
10648 /*integral_constant_expression_p=*/false);
10652 return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t), true);
10654 return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t));
10658 tree r = build_x_modify_expr
10659 (RECUR (TREE_OPERAND (t, 0)),
10660 TREE_CODE (TREE_OPERAND (t, 1)),
10661 RECUR (TREE_OPERAND (t, 2)));
10662 /* TREE_NO_WARNING must be set if either the expression was
10663 parenthesized or it uses an operator such as >>= rather
10664 than plain assignment. In the former case, it was already
10665 set and must be copied. In the latter case,
10666 build_x_modify_expr sets it and it must not be reset
10668 if (TREE_NO_WARNING (t))
10669 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
10674 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
10675 args, complain, in_decl);
10676 /* Remember that there was a reference to this entity. */
10679 return build_x_arrow (op1);
10683 tree init = RECUR (TREE_OPERAND (t, 3));
10685 if (TREE_OPERAND (t, 3) && !init)
10686 /* If there was an initializer in the the original tree, but
10687 it instantiated to an empty list, then we should pass on
10688 VOID_ZERO_NODE to tell build_new that it was an empty
10689 initializer () rather than no initializer. This can only
10690 happen when the initializer is a pack expansion whose
10691 parameter packs are of length zero. */
10692 init = void_zero_node;
10695 (RECUR (TREE_OPERAND (t, 0)),
10696 RECUR (TREE_OPERAND (t, 1)),
10697 RECUR (TREE_OPERAND (t, 2)),
10699 NEW_EXPR_USE_GLOBAL (t));
10703 return delete_sanity
10704 (RECUR (TREE_OPERAND (t, 0)),
10705 RECUR (TREE_OPERAND (t, 1)),
10706 DELETE_EXPR_USE_VEC (t),
10707 DELETE_EXPR_USE_GLOBAL (t));
10709 case COMPOUND_EXPR:
10710 return build_x_compound_expr (RECUR (TREE_OPERAND (t, 0)),
10711 RECUR (TREE_OPERAND (t, 1)));
10720 function = CALL_EXPR_FN (t);
10721 /* When we parsed the expression, we determined whether or
10722 not Koenig lookup should be performed. */
10723 koenig_p = KOENIG_LOOKUP_P (t);
10724 if (TREE_CODE (function) == SCOPE_REF)
10726 qualified_p = true;
10727 function = tsubst_qualified_id (function, args, complain, in_decl,
10729 /*address_p=*/false);
10733 if (TREE_CODE (function) == COMPONENT_REF)
10735 tree op = TREE_OPERAND (function, 1);
10737 qualified_p = (TREE_CODE (op) == SCOPE_REF
10738 || (BASELINK_P (op)
10739 && BASELINK_QUALIFIED_P (op)));
10742 qualified_p = false;
10744 function = tsubst_copy_and_build (function, args, complain,
10747 integral_constant_expression_p);
10749 if (BASELINK_P (function))
10750 qualified_p = true;
10753 /* FIXME: Rewrite this so as not to construct an arglist. */
10754 call_args = RECUR (CALL_EXPR_ARGS (t));
10756 /* We do not perform argument-dependent lookup if normal
10757 lookup finds a non-function, in accordance with the
10758 expected resolution of DR 218. */
10760 && ((is_overloaded_fn (function)
10761 /* If lookup found a member function, the Koenig lookup is
10762 not appropriate, even if an unqualified-name was used
10763 to denote the function. */
10764 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function)))
10765 || TREE_CODE (function) == IDENTIFIER_NODE))
10766 function = perform_koenig_lookup (function, call_args);
10768 if (TREE_CODE (function) == IDENTIFIER_NODE)
10770 unqualified_name_lookup_error (function);
10771 return error_mark_node;
10774 /* Remember that there was a reference to this entity. */
10775 if (DECL_P (function))
10776 mark_used (function);
10778 if (TREE_CODE (function) == OFFSET_REF)
10779 return build_offset_ref_call_from_tree (function, call_args);
10780 if (TREE_CODE (function) == COMPONENT_REF)
10782 if (!BASELINK_P (TREE_OPERAND (function, 1)))
10783 return finish_call_expr (function, call_args,
10784 /*disallow_virtual=*/false,
10785 /*koenig_p=*/false);
10787 return (build_new_method_call
10788 (TREE_OPERAND (function, 0),
10789 TREE_OPERAND (function, 1),
10790 call_args, NULL_TREE,
10791 qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL,
10794 return finish_call_expr (function, call_args,
10795 /*disallow_virtual=*/qualified_p,
10800 return build_x_conditional_expr
10801 (RECUR (TREE_OPERAND (t, 0)),
10802 RECUR (TREE_OPERAND (t, 1)),
10803 RECUR (TREE_OPERAND (t, 2)));
10805 case PSEUDO_DTOR_EXPR:
10806 return finish_pseudo_destructor_expr
10807 (RECUR (TREE_OPERAND (t, 0)),
10808 RECUR (TREE_OPERAND (t, 1)),
10809 RECUR (TREE_OPERAND (t, 2)));
10813 tree purpose, value, chain;
10815 if (t == void_list_node)
10818 if ((TREE_PURPOSE (t) && PACK_EXPANSION_P (TREE_PURPOSE (t)))
10819 || (TREE_VALUE (t) && PACK_EXPANSION_P (TREE_VALUE (t))))
10821 /* We have pack expansions, so expand those and
10822 create a new list out of it. */
10823 tree purposevec = NULL_TREE;
10824 tree valuevec = NULL_TREE;
10828 /* Expand the argument expressions. */
10829 if (TREE_PURPOSE (t))
10830 purposevec = tsubst_pack_expansion (TREE_PURPOSE (t), args,
10831 complain, in_decl);
10832 if (TREE_VALUE (t))
10833 valuevec = tsubst_pack_expansion (TREE_VALUE (t), args,
10834 complain, in_decl);
10836 /* Build the rest of the list. */
10837 chain = TREE_CHAIN (t);
10838 if (chain && chain != void_type_node)
10839 chain = RECUR (chain);
10841 /* Determine the number of arguments. */
10842 if (purposevec && TREE_CODE (purposevec) == TREE_VEC)
10844 len = TREE_VEC_LENGTH (purposevec);
10845 gcc_assert (!valuevec || len == TREE_VEC_LENGTH (valuevec));
10847 else if (TREE_CODE (valuevec) == TREE_VEC)
10848 len = TREE_VEC_LENGTH (valuevec);
10851 /* Since we only performed a partial substitution into
10852 the argument pack, we only return a single list
10854 if (purposevec == TREE_PURPOSE (t)
10855 && valuevec == TREE_VALUE (t)
10856 && chain == TREE_CHAIN (t))
10859 return tree_cons (purposevec, valuevec, chain);
10862 /* Convert the argument vectors into a TREE_LIST */
10866 /* Grab the Ith values. */
10868 purpose = purposevec ? TREE_VEC_ELT (purposevec, i)
10871 = valuevec ? convert_from_reference (TREE_VEC_ELT (valuevec, i))
10874 /* Build the list (backwards). */
10875 chain = tree_cons (purpose, value, chain);
10881 purpose = TREE_PURPOSE (t);
10883 purpose = RECUR (purpose);
10884 value = TREE_VALUE (t);
10886 value = RECUR (value);
10887 chain = TREE_CHAIN (t);
10888 if (chain && chain != void_type_node)
10889 chain = RECUR (chain);
10890 if (purpose == TREE_PURPOSE (t)
10891 && value == TREE_VALUE (t)
10892 && chain == TREE_CHAIN (t))
10894 return tree_cons (purpose, value, chain);
10897 case COMPONENT_REF:
10903 object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
10904 args, complain, in_decl);
10905 /* Remember that there was a reference to this entity. */
10906 if (DECL_P (object))
10907 mark_used (object);
10908 object_type = TREE_TYPE (object);
10910 member = TREE_OPERAND (t, 1);
10911 if (BASELINK_P (member))
10912 member = tsubst_baselink (member,
10913 non_reference (TREE_TYPE (object)),
10914 args, complain, in_decl);
10916 member = tsubst_copy (member, args, complain, in_decl);
10917 if (member == error_mark_node)
10918 return error_mark_node;
10920 if (object_type && !CLASS_TYPE_P (object_type))
10922 if (TREE_CODE (member) == BIT_NOT_EXPR)
10923 return finish_pseudo_destructor_expr (object,
10926 else if (TREE_CODE (member) == SCOPE_REF
10927 && (TREE_CODE (TREE_OPERAND (member, 1)) == BIT_NOT_EXPR))
10928 return finish_pseudo_destructor_expr (object,
10932 else if (TREE_CODE (member) == SCOPE_REF
10933 && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
10938 /* Lookup the template functions now that we know what the
10940 tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
10941 args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
10942 member = lookup_qualified_name (TREE_OPERAND (member, 0), tmpl,
10943 /*is_type_p=*/false,
10944 /*complain=*/false);
10945 if (BASELINK_P (member))
10947 BASELINK_FUNCTIONS (member)
10948 = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
10950 member = (adjust_result_of_qualified_name_lookup
10951 (member, BINFO_TYPE (BASELINK_BINFO (member)),
10956 qualified_name_lookup_error (object_type, tmpl, member);
10957 return error_mark_node;
10960 else if (TREE_CODE (member) == SCOPE_REF
10961 && !CLASS_TYPE_P (TREE_OPERAND (member, 0))
10962 && TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL)
10964 if (complain & tf_error)
10966 if (TYPE_P (TREE_OPERAND (member, 0)))
10967 error ("%qT is not a class or namespace",
10968 TREE_OPERAND (member, 0));
10970 error ("%qD is not a class or namespace",
10971 TREE_OPERAND (member, 0));
10973 return error_mark_node;
10975 else if (TREE_CODE (member) == FIELD_DECL)
10976 return finish_non_static_data_member (member, object, NULL_TREE);
10978 return finish_class_member_access_expr (object, member,
10979 /*template_p=*/false);
10984 (RECUR (TREE_OPERAND (t, 0)));
10988 VEC(constructor_elt,gc) *n;
10989 constructor_elt *ce;
10990 unsigned HOST_WIDE_INT idx;
10991 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10992 bool process_index_p;
10994 bool need_copy_p = false;
10996 if (type == error_mark_node)
10997 return error_mark_node;
10999 /* digest_init will do the wrong thing if we let it. */
11000 if (type && TYPE_PTRMEMFUNC_P (type))
11003 /* We do not want to process the index of aggregate
11004 initializers as they are identifier nodes which will be
11005 looked up by digest_init. */
11006 process_index_p = !(type && IS_AGGR_TYPE (type));
11008 n = VEC_copy (constructor_elt, gc, CONSTRUCTOR_ELTS (t));
11009 newlen = VEC_length (constructor_elt, n);
11010 for (idx = 0; VEC_iterate (constructor_elt, n, idx, ce); idx++)
11012 if (ce->index && process_index_p)
11013 ce->index = RECUR (ce->index);
11015 if (PACK_EXPANSION_P (ce->value))
11017 /* Substitute into the pack expansion. */
11018 ce->value = tsubst_pack_expansion (ce->value, args, complain,
11021 if (ce->value == error_mark_node)
11023 else if (TREE_VEC_LENGTH (ce->value) == 1)
11024 /* Just move the argument into place. */
11025 ce->value = TREE_VEC_ELT (ce->value, 0);
11028 /* Update the length of the final CONSTRUCTOR
11029 arguments vector, and note that we will need to
11031 newlen = newlen + TREE_VEC_LENGTH (ce->value) - 1;
11032 need_copy_p = true;
11036 ce->value = RECUR (ce->value);
11041 VEC(constructor_elt,gc) *old_n = n;
11043 n = VEC_alloc (constructor_elt, gc, newlen);
11044 for (idx = 0; VEC_iterate (constructor_elt, old_n, idx, ce);
11047 if (TREE_CODE (ce->value) == TREE_VEC)
11049 int i, len = TREE_VEC_LENGTH (ce->value);
11050 for (i = 0; i < len; ++i)
11051 CONSTRUCTOR_APPEND_ELT (n, 0,
11052 TREE_VEC_ELT (ce->value, i));
11055 CONSTRUCTOR_APPEND_ELT (n, 0, ce->value);
11059 if (TREE_HAS_CONSTRUCTOR (t))
11060 return finish_compound_literal (type, n);
11062 return build_constructor (NULL_TREE, n);
11067 tree operand_0 = RECUR (TREE_OPERAND (t, 0));
11068 if (TYPE_P (operand_0))
11069 return get_typeid (operand_0);
11070 return build_typeid (operand_0);
11080 tree r = tsubst_copy (t, args, complain, in_decl);
11082 if (TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
11083 /* If the original type was a reference, we'll be wrapped in
11084 the appropriate INDIRECT_REF. */
11085 r = convert_from_reference (r);
11090 return build_x_va_arg (RECUR (TREE_OPERAND (t, 0)),
11091 tsubst_copy (TREE_TYPE (t), args, complain,
11094 case OFFSETOF_EXPR:
11095 return finish_offsetof (RECUR (TREE_OPERAND (t, 0)));
11099 tree type1 = tsubst_copy (TRAIT_EXPR_TYPE1 (t), args,
11100 complain, in_decl);
11102 tree type2 = TRAIT_EXPR_TYPE2 (t);
11104 type2 = tsubst_copy (type2, args, complain, in_decl);
11106 return finish_trait_expr (TRAIT_EXPR_KIND (t), type1, type2);
11111 tree old_stmt_expr = cur_stmt_expr;
11112 tree stmt_expr = begin_stmt_expr ();
11114 cur_stmt_expr = stmt_expr;
11115 tsubst_expr (STMT_EXPR_STMT (t), args, complain, in_decl,
11116 integral_constant_expression_p);
11117 stmt_expr = finish_stmt_expr (stmt_expr, false);
11118 cur_stmt_expr = old_stmt_expr;
11124 t = tsubst_copy (t, args, complain, in_decl);
11125 /* As in finish_id_expression, we resolve enumeration constants
11126 to their underlying values. */
11127 if (TREE_CODE (t) == CONST_DECL)
11129 used_types_insert (TREE_TYPE (t));
11130 return DECL_INITIAL (t);
11135 /* Handle Objective-C++ constructs, if appropriate. */
11138 = objcp_tsubst_copy_and_build (t, args, complain,
11139 in_decl, /*function_p=*/false);
11143 return tsubst_copy (t, args, complain, in_decl);
11149 /* Verify that the instantiated ARGS are valid. For type arguments,
11150 make sure that the type's linkage is ok. For non-type arguments,
11151 make sure they are constants if they are integral or enumerations.
11152 Emit an error under control of COMPLAIN, and return TRUE on error. */
11155 check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain)
11157 int ix, len = DECL_NTPARMS (tmpl);
11158 bool result = false;
11160 for (ix = 0; ix != len; ix++)
11162 tree t = TREE_VEC_ELT (args, ix);
11166 /* [basic.link]: A name with no linkage (notably, the name
11167 of a class or enumeration declared in a local scope)
11168 shall not be used to declare an entity with linkage.
11169 This implies that names with no linkage cannot be used as
11170 template arguments. */
11171 tree nt = no_linkage_check (t, /*relaxed_p=*/false);
11175 /* DR 488 makes use of a type with no linkage cause
11176 type deduction to fail. */
11177 if (complain & tf_error)
11179 if (TYPE_ANONYMOUS_P (nt))
11180 error ("%qT is/uses anonymous type", t);
11182 error ("template argument for %qD uses local type %qT",
11187 /* In order to avoid all sorts of complications, we do not
11188 allow variably-modified types as template arguments. */
11189 else if (variably_modified_type_p (t, NULL_TREE))
11191 if (complain & tf_error)
11192 error ("%qT is a variably modified type", t);
11196 /* A non-type argument of integral or enumerated type must be a
11198 else if (TREE_TYPE (t)
11199 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t))
11200 && !TREE_CONSTANT (t))
11202 if (complain & tf_error)
11203 error ("integral expression %qE is not constant", t);
11207 if (result && (complain & tf_error))
11208 error (" trying to instantiate %qD", tmpl);
11212 /* Instantiate the indicated variable or function template TMPL with
11213 the template arguments in TARG_PTR. */
11216 instantiate_template (tree tmpl, tree targ_ptr, tsubst_flags_t complain)
11221 HOST_WIDE_INT saved_processing_template_decl;
11223 if (tmpl == error_mark_node)
11224 return error_mark_node;
11226 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
11228 /* If this function is a clone, handle it specially. */
11229 if (DECL_CLONED_FUNCTION_P (tmpl))
11234 spec = instantiate_template (DECL_CLONED_FUNCTION (tmpl), targ_ptr,
11236 if (spec == error_mark_node)
11237 return error_mark_node;
11239 /* Look for the clone. */
11240 FOR_EACH_CLONE (clone, spec)
11241 if (DECL_NAME (clone) == DECL_NAME (tmpl))
11243 /* We should always have found the clone by now. */
11244 gcc_unreachable ();
11248 /* Check to see if we already have this specialization. */
11249 spec = retrieve_specialization (tmpl, targ_ptr,
11250 /*class_specializations_p=*/false);
11251 if (spec != NULL_TREE)
11254 gen_tmpl = most_general_template (tmpl);
11255 if (tmpl != gen_tmpl)
11257 /* The TMPL is a partial instantiation. To get a full set of
11258 arguments we must add the arguments used to perform the
11259 partial instantiation. */
11260 targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl),
11263 /* Check to see if we already have this specialization. */
11264 spec = retrieve_specialization (gen_tmpl, targ_ptr,
11265 /*class_specializations_p=*/false);
11266 if (spec != NULL_TREE)
11270 if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr),
11272 return error_mark_node;
11274 /* We are building a FUNCTION_DECL, during which the access of its
11275 parameters and return types have to be checked. However this
11276 FUNCTION_DECL which is the desired context for access checking
11277 is not built yet. We solve this chicken-and-egg problem by
11278 deferring all checks until we have the FUNCTION_DECL. */
11279 push_deferring_access_checks (dk_deferred);
11281 /* Although PROCESSING_TEMPLATE_DECL may be true at this point
11282 (because, for example, we have encountered a non-dependent
11283 function call in the body of a template function and must now
11284 determine which of several overloaded functions will be called),
11285 within the instantiation itself we are not processing a
11287 saved_processing_template_decl = processing_template_decl;
11288 processing_template_decl = 0;
11289 /* Substitute template parameters to obtain the specialization. */
11290 fndecl = tsubst (DECL_TEMPLATE_RESULT (gen_tmpl),
11291 targ_ptr, complain, gen_tmpl);
11292 processing_template_decl = saved_processing_template_decl;
11293 if (fndecl == error_mark_node)
11294 return error_mark_node;
11296 /* Now we know the specialization, compute access previously
11298 push_access_scope (fndecl);
11299 perform_deferred_access_checks ();
11300 pop_access_scope (fndecl);
11301 pop_deferring_access_checks ();
11303 /* The DECL_TI_TEMPLATE should always be the immediate parent
11304 template, not the most general template. */
11305 DECL_TI_TEMPLATE (fndecl) = tmpl;
11307 /* If we've just instantiated the main entry point for a function,
11308 instantiate all the alternate entry points as well. We do this
11309 by cloning the instantiation of the main entry point, not by
11310 instantiating the template clones. */
11311 if (TREE_CHAIN (gen_tmpl) && DECL_CLONED_FUNCTION_P (TREE_CHAIN (gen_tmpl)))
11312 clone_function_decl (fndecl, /*update_method_vec_p=*/0);
11317 /* The FN is a TEMPLATE_DECL for a function. The ARGS are the
11318 arguments that are being used when calling it. TARGS is a vector
11319 into which the deduced template arguments are placed.
11321 Return zero for success, 2 for an incomplete match that doesn't resolve
11322 all the types, and 1 for complete failure. An error message will be
11323 printed only for an incomplete match.
11325 If FN is a conversion operator, or we are trying to produce a specific
11326 specialization, RETURN_TYPE is the return type desired.
11328 The EXPLICIT_TARGS are explicit template arguments provided via a
11331 The parameter STRICT is one of:
11334 We are deducing arguments for a function call, as in
11335 [temp.deduct.call].
11338 We are deducing arguments for a conversion function, as in
11339 [temp.deduct.conv].
11342 We are deducing arguments when doing an explicit instantiation
11343 as in [temp.explicit], when determining an explicit specialization
11344 as in [temp.expl.spec], or when taking the address of a function
11345 template, as in [temp.deduct.funcaddr]. */
11348 fn_type_unification (tree fn,
11349 tree explicit_targs,
11353 unification_kind_t strict,
11359 bool incomplete_argument_packs_p = false;
11361 gcc_assert (TREE_CODE (fn) == TEMPLATE_DECL);
11363 fntype = TREE_TYPE (fn);
11364 if (explicit_targs)
11368 The specified template arguments must match the template
11369 parameters in kind (i.e., type, nontype, template), and there
11370 must not be more arguments than there are parameters;
11371 otherwise type deduction fails.
11373 Nontype arguments must match the types of the corresponding
11374 nontype template parameters, or must be convertible to the
11375 types of the corresponding nontype parameters as specified in
11376 _temp.arg.nontype_, otherwise type deduction fails.
11378 All references in the function type of the function template
11379 to the corresponding template parameters are replaced by the
11380 specified template argument values. If a substitution in a
11381 template parameter or in the function type of the function
11382 template results in an invalid type, type deduction fails. */
11383 tree tparms = DECL_INNERMOST_TEMPLATE_PARMS (fn);
11384 int i, len = TREE_VEC_LENGTH (tparms);
11385 tree converted_args;
11386 bool incomplete = false;
11388 if (explicit_targs == error_mark_node)
11392 = (coerce_template_parms (tparms, explicit_targs, NULL_TREE, tf_none,
11393 /*require_all_args=*/false,
11394 /*use_default_args=*/false));
11395 if (converted_args == error_mark_node)
11398 /* Substitute the explicit args into the function type. This is
11399 necessary so that, for instance, explicitly declared function
11400 arguments can match null pointed constants. If we were given
11401 an incomplete set of explicit args, we must not do semantic
11402 processing during substitution as we could create partial
11404 for (i = 0; i < len; i++)
11406 tree parm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
11407 bool parameter_pack = false;
11409 /* Dig out the actual parm. */
11410 if (TREE_CODE (parm) == TYPE_DECL
11411 || TREE_CODE (parm) == TEMPLATE_DECL)
11413 parm = TREE_TYPE (parm);
11414 parameter_pack = TEMPLATE_TYPE_PARAMETER_PACK (parm);
11416 else if (TREE_CODE (parm) == PARM_DECL)
11418 parm = DECL_INITIAL (parm);
11419 parameter_pack = TEMPLATE_PARM_PARAMETER_PACK (parm);
11422 if (parameter_pack)
11426 template_parm_level_and_index (parm, &level, &idx);
11428 /* Mark the argument pack as "incomplete". We could
11429 still deduce more arguments during unification. */
11430 targ = TMPL_ARG (converted_args, level, idx);
11433 ARGUMENT_PACK_INCOMPLETE_P(targ) = 1;
11434 ARGUMENT_PACK_EXPLICIT_ARGS (targ)
11435 = ARGUMENT_PACK_ARGS (targ);
11438 /* We have some incomplete argument packs. */
11439 incomplete_argument_packs_p = true;
11443 if (incomplete_argument_packs_p)
11444 /* Any substitution is guaranteed to be incomplete if there
11445 are incomplete argument packs, because we can still deduce
11449 incomplete = NUM_TMPL_ARGS (explicit_targs) != NUM_TMPL_ARGS (targs);
11451 processing_template_decl += incomplete;
11452 fntype = tsubst (fntype, converted_args, tf_none, NULL_TREE);
11453 processing_template_decl -= incomplete;
11455 if (fntype == error_mark_node)
11458 /* Place the explicitly specified arguments in TARGS. */
11459 for (i = NUM_TMPL_ARGS (converted_args); i--;)
11460 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i);
11463 /* Never do unification on the 'this' parameter. */
11464 parms = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (fntype));
11468 parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms);
11469 args = tree_cons (NULL_TREE, return_type, args);
11472 /* We allow incomplete unification without an error message here
11473 because the standard doesn't seem to explicitly prohibit it. Our
11474 callers must be ready to deal with unification failures in any
11476 result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
11477 targs, parms, args, /*subr=*/0,
11480 if (result == 0 && incomplete_argument_packs_p)
11482 int i, len = NUM_TMPL_ARGS (targs);
11484 /* Clear the "incomplete" flags on all argument packs. */
11485 for (i = 0; i < len; i++)
11487 tree arg = TREE_VEC_ELT (targs, i);
11488 if (ARGUMENT_PACK_P (arg))
11490 ARGUMENT_PACK_INCOMPLETE_P (arg) = 0;
11491 ARGUMENT_PACK_EXPLICIT_ARGS (arg) = NULL_TREE;
11497 /* All is well so far. Now, check:
11501 When all template arguments have been deduced, all uses of
11502 template parameters in nondeduced contexts are replaced with
11503 the corresponding deduced argument values. If the
11504 substitution results in an invalid type, as described above,
11505 type deduction fails. */
11506 if (tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE)
11507 == error_mark_node)
11513 /* Adjust types before performing type deduction, as described in
11514 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
11515 sections are symmetric. PARM is the type of a function parameter
11516 or the return type of the conversion function. ARG is the type of
11517 the argument passed to the call, or the type of the value
11518 initialized with the result of the conversion function.
11519 ARG_EXPR is the original argument expression, which may be null. */
11522 maybe_adjust_types_for_deduction (unification_kind_t strict,
11536 /* Swap PARM and ARG throughout the remainder of this
11537 function; the handling is precisely symmetric since PARM
11538 will initialize ARG rather than vice versa. */
11546 /* There is nothing to do in this case. */
11550 gcc_unreachable ();
11553 if (TREE_CODE (*parm) != REFERENCE_TYPE)
11555 /* [temp.deduct.call]
11557 If P is not a reference type:
11559 --If A is an array type, the pointer type produced by the
11560 array-to-pointer standard conversion (_conv.array_) is
11561 used in place of A for type deduction; otherwise,
11563 --If A is a function type, the pointer type produced by
11564 the function-to-pointer standard conversion
11565 (_conv.func_) is used in place of A for type deduction;
11568 --If A is a cv-qualified type, the top level
11569 cv-qualifiers of A's type are ignored for type
11571 if (TREE_CODE (*arg) == ARRAY_TYPE)
11572 *arg = build_pointer_type (TREE_TYPE (*arg));
11573 else if (TREE_CODE (*arg) == FUNCTION_TYPE)
11574 *arg = build_pointer_type (*arg);
11576 *arg = TYPE_MAIN_VARIANT (*arg);
11579 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
11580 of the form T&&, where T is a template parameter, and the argument
11581 is an lvalue, T is deduced as A& */
11582 if (TREE_CODE (*parm) == REFERENCE_TYPE
11583 && TYPE_REF_IS_RVALUE (*parm)
11584 && TREE_CODE (TREE_TYPE (*parm)) == TEMPLATE_TYPE_PARM
11585 && cp_type_quals (TREE_TYPE (*parm)) == TYPE_UNQUALIFIED
11586 && arg_expr && real_lvalue_p (arg_expr))
11587 *arg = build_reference_type (*arg);
11589 /* [temp.deduct.call]
11591 If P is a cv-qualified type, the top level cv-qualifiers
11592 of P's type are ignored for type deduction. If P is a
11593 reference type, the type referred to by P is used for
11595 *parm = TYPE_MAIN_VARIANT (*parm);
11596 if (TREE_CODE (*parm) == REFERENCE_TYPE)
11598 *parm = TREE_TYPE (*parm);
11599 result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
11602 /* DR 322. For conversion deduction, remove a reference type on parm
11603 too (which has been swapped into ARG). */
11604 if (strict == DEDUCE_CONV && TREE_CODE (*arg) == REFERENCE_TYPE)
11605 *arg = TREE_TYPE (*arg);
11610 /* Most parms like fn_type_unification.
11612 If SUBR is 1, we're being called recursively (to unify the
11613 arguments of a function or method parameter of a function
11617 type_unification_real (tree tparms,
11622 unification_kind_t strict,
11625 tree parm, arg, arg_expr;
11627 int ntparms = TREE_VEC_LENGTH (tparms);
11629 int saw_undeduced = 0;
11632 gcc_assert (TREE_CODE (tparms) == TREE_VEC);
11633 gcc_assert (xparms == NULL_TREE || TREE_CODE (xparms) == TREE_LIST);
11634 gcc_assert (!xargs || TREE_CODE (xargs) == TREE_LIST);
11635 gcc_assert (ntparms > 0);
11640 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL | UNIFY_ALLOW_MORE_CV_QUAL
11641 | UNIFY_ALLOW_DERIVED);
11645 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
11649 sub_strict = UNIFY_ALLOW_NONE;
11653 gcc_unreachable ();
11660 while (parms && parms != void_list_node
11661 && args && args != void_list_node)
11663 if (TREE_CODE (TREE_VALUE (parms)) == TYPE_PACK_EXPANSION)
11666 parm = TREE_VALUE (parms);
11667 parms = TREE_CHAIN (parms);
11668 arg = TREE_VALUE (args);
11669 args = TREE_CHAIN (args);
11672 if (arg == error_mark_node)
11674 if (arg == unknown_type_node)
11675 /* We can't deduce anything from this, but we might get all the
11676 template args from other function args. */
11679 /* Conversions will be performed on a function argument that
11680 corresponds with a function parameter that contains only
11681 non-deducible template parameters and explicitly specified
11682 template parameters. */
11683 if (!uses_template_parms (parm))
11688 type = TREE_TYPE (arg);
11692 if (same_type_p (parm, type))
11694 if (strict != DEDUCE_EXACT
11695 && can_convert_arg (parm, type, TYPE_P (arg) ? NULL_TREE : arg,
11704 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
11705 if (type_unknown_p (arg))
11707 /* [temp.deduct.type]
11709 A template-argument can be deduced from a pointer to
11710 function or pointer to member function argument if
11711 the set of overloaded functions does not contain
11712 function templates and at most one of a set of
11713 overloaded functions provides a unique match. */
11714 if (resolve_overloaded_unification
11715 (tparms, targs, parm, arg, strict, sub_strict))
11721 arg = unlowered_expr_type (arg);
11722 if (arg == error_mark_node)
11727 int arg_strict = sub_strict;
11730 arg_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg,
11733 if (unify (tparms, targs, parm, arg, arg_strict))
11740 && parms != void_list_node
11741 && TREE_CODE (TREE_VALUE (parms)) == TYPE_PACK_EXPANSION)
11743 /* Unify the remaining arguments with the pack expansion type. */
11745 tree parmvec = make_tree_vec (1);
11749 /* Count the number of arguments that remain. */
11750 for (t = args; t && t != void_list_node; t = TREE_CHAIN (t))
11753 /* Allocate a TREE_VEC and copy in all of the arguments */
11754 argvec = make_tree_vec (len);
11755 for (i = 0; args && args != void_list_node; args = TREE_CHAIN (args))
11757 TREE_VEC_ELT (argvec, i) = TREE_VALUE (args);
11761 /* Copy the parameter into parmvec. */
11762 TREE_VEC_ELT (parmvec, 0) = TREE_VALUE (parms);
11763 if (unify_pack_expansion (tparms, targs, parmvec, argvec, strict,
11764 /*call_args_p=*/true, /*subr=*/subr))
11767 /* Advance to the end of the list of parameters. */
11768 parms = TREE_CHAIN (parms);
11771 /* Fail if we've reached the end of the parm list, and more args
11772 are present, and the parm list isn't variadic. */
11773 if (args && args != void_list_node && parms == void_list_node)
11775 /* Fail if parms are left and they don't have default values. */
11776 if (parms && parms != void_list_node
11777 && TREE_PURPOSE (parms) == NULL_TREE)
11781 for (i = 0; i < ntparms; i++)
11782 if (!TREE_VEC_ELT (targs, i))
11786 if (TREE_VEC_ELT (tparms, i) == error_mark_node)
11789 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
11791 /* If this is an undeduced nontype parameter that depends on
11792 a type parameter, try another pass; its type may have been
11793 deduced from a later argument than the one from which
11794 this parameter can be deduced. */
11795 if (TREE_CODE (tparm) == PARM_DECL
11796 && uses_template_parms (TREE_TYPE (tparm))
11797 && !saw_undeduced++)
11800 /* Core issue #226 (C++0x) [temp.deduct]:
11802 If a template argument has not been deduced, its
11803 default template argument, if any, is used.
11805 When we are in C++98 mode, TREE_PURPOSE will either
11806 be NULL_TREE or ERROR_MARK_NODE, so we do not need
11807 to explicitly check cxx_dialect here. */
11808 if (TREE_PURPOSE (TREE_VEC_ELT (tparms, i)))
11810 tree arg = tsubst (TREE_PURPOSE (TREE_VEC_ELT (tparms, i)),
11811 targs, tf_none, NULL_TREE);
11812 if (arg == error_mark_node)
11816 TREE_VEC_ELT (targs, i) = arg;
11821 /* If the type parameter is a parameter pack, then it will
11822 be deduced to an empty parameter pack. */
11823 if (template_parameter_pack_p (tparm))
11827 if (TREE_CODE (tparm) == TEMPLATE_PARM_INDEX)
11829 arg = make_node (NONTYPE_ARGUMENT_PACK);
11830 TREE_TYPE (arg) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm));
11831 TREE_CONSTANT (arg) = 1;
11834 arg = make_node (TYPE_ARGUMENT_PACK);
11836 SET_ARGUMENT_PACK_ARGS (arg, make_tree_vec (0));
11838 TREE_VEC_ELT (targs, i) = arg;
11848 /* Subroutine of type_unification_real. Args are like the variables
11849 at the call site. ARG is an overloaded function (or template-id);
11850 we try deducing template args from each of the overloads, and if
11851 only one succeeds, we go with that. Modifies TARGS and returns
11852 true on success. */
11855 resolve_overloaded_unification (tree tparms,
11859 unification_kind_t strict,
11862 tree tempargs = copy_node (targs);
11866 if (TREE_CODE (arg) == ADDR_EXPR)
11868 arg = TREE_OPERAND (arg, 0);
11874 if (TREE_CODE (arg) == COMPONENT_REF)
11875 /* Handle `&x' where `x' is some static or non-static member
11877 arg = TREE_OPERAND (arg, 1);
11879 if (TREE_CODE (arg) == OFFSET_REF)
11880 arg = TREE_OPERAND (arg, 1);
11882 /* Strip baselink information. */
11883 if (BASELINK_P (arg))
11884 arg = BASELINK_FUNCTIONS (arg);
11886 if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
11888 /* If we got some explicit template args, we need to plug them into
11889 the affected templates before we try to unify, in case the
11890 explicit args will completely resolve the templates in question. */
11892 tree expl_subargs = TREE_OPERAND (arg, 1);
11893 arg = TREE_OPERAND (arg, 0);
11895 for (; arg; arg = OVL_NEXT (arg))
11897 tree fn = OVL_CURRENT (arg);
11898 tree subargs, elem;
11900 if (TREE_CODE (fn) != TEMPLATE_DECL)
11903 subargs = get_bindings (fn, DECL_TEMPLATE_RESULT (fn),
11904 expl_subargs, /*check_ret=*/false);
11907 elem = tsubst (TREE_TYPE (fn), subargs, tf_none, NULL_TREE);
11908 good += try_one_overload (tparms, targs, tempargs, parm,
11909 elem, strict, sub_strict, addr_p);
11913 else if (TREE_CODE (arg) != OVERLOAD
11914 && TREE_CODE (arg) != FUNCTION_DECL)
11915 /* If ARG is, for example, "(0, &f)" then its type will be unknown
11916 -- but the deduction does not succeed because the expression is
11917 not just the function on its own. */
11920 for (; arg; arg = OVL_NEXT (arg))
11921 good += try_one_overload (tparms, targs, tempargs, parm,
11922 TREE_TYPE (OVL_CURRENT (arg)),
11923 strict, sub_strict, addr_p);
11925 /* [temp.deduct.type] A template-argument can be deduced from a pointer
11926 to function or pointer to member function argument if the set of
11927 overloaded functions does not contain function templates and at most
11928 one of a set of overloaded functions provides a unique match.
11930 So if we found multiple possibilities, we return success but don't
11931 deduce anything. */
11935 int i = TREE_VEC_LENGTH (targs);
11937 if (TREE_VEC_ELT (tempargs, i))
11938 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i);
11946 /* Subroutine of resolve_overloaded_unification; does deduction for a single
11947 overload. Fills TARGS with any deduced arguments, or error_mark_node if
11948 different overloads deduce different arguments for a given parm.
11949 ADDR_P is true if the expression for which deduction is being
11950 performed was of the form "& fn" rather than simply "fn".
11952 Returns 1 on success. */
11955 try_one_overload (tree tparms,
11960 unification_kind_t strict,
11968 /* [temp.deduct.type] A template-argument can be deduced from a pointer
11969 to function or pointer to member function argument if the set of
11970 overloaded functions does not contain function templates and at most
11971 one of a set of overloaded functions provides a unique match.
11973 So if this is a template, just return success. */
11975 if (uses_template_parms (arg))
11978 if (TREE_CODE (arg) == METHOD_TYPE)
11979 arg = build_ptrmemfunc_type (build_pointer_type (arg));
11981 arg = build_pointer_type (arg);
11983 sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg, NULL);
11985 /* We don't copy orig_targs for this because if we have already deduced
11986 some template args from previous args, unify would complain when we
11987 try to deduce a template parameter for the same argument, even though
11988 there isn't really a conflict. */
11989 nargs = TREE_VEC_LENGTH (targs);
11990 tempargs = make_tree_vec (nargs);
11992 if (unify (tparms, tempargs, parm, arg, sub_strict) != 0)
11995 /* First make sure we didn't deduce anything that conflicts with
11996 explicitly specified args. */
11997 for (i = nargs; i--; )
11999 tree elt = TREE_VEC_ELT (tempargs, i);
12000 tree oldelt = TREE_VEC_ELT (orig_targs, i);
12004 else if (uses_template_parms (elt))
12005 /* Since we're unifying against ourselves, we will fill in
12006 template args used in the function parm list with our own
12007 template parms. Discard them. */
12008 TREE_VEC_ELT (tempargs, i) = NULL_TREE;
12009 else if (oldelt && !template_args_equal (oldelt, elt))
12013 for (i = nargs; i--; )
12015 tree elt = TREE_VEC_ELT (tempargs, i);
12018 TREE_VEC_ELT (targs, i) = elt;
12024 /* PARM is a template class (perhaps with unbound template
12025 parameters). ARG is a fully instantiated type. If ARG can be
12026 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
12027 TARGS are as for unify. */
12030 try_class_unification (tree tparms, tree targs, tree parm, tree arg)
12032 tree copy_of_targs;
12034 if (!CLASSTYPE_TEMPLATE_INFO (arg)
12035 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg))
12036 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm))))
12039 /* We need to make a new template argument vector for the call to
12040 unify. If we used TARGS, we'd clutter it up with the result of
12041 the attempted unification, even if this class didn't work out.
12042 We also don't want to commit ourselves to all the unifications
12043 we've already done, since unification is supposed to be done on
12044 an argument-by-argument basis. In other words, consider the
12045 following pathological case:
12047 template <int I, int J, int K>
12050 template <int I, int J>
12051 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
12053 template <int I, int J, int K>
12054 void f(S<I, J, K>, S<I, I, I>);
12063 Now, by the time we consider the unification involving `s2', we
12064 already know that we must have `f<0, 0, 0>'. But, even though
12065 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
12066 because there are two ways to unify base classes of S<0, 1, 2>
12067 with S<I, I, I>. If we kept the already deduced knowledge, we
12068 would reject the possibility I=1. */
12069 copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs));
12071 /* If unification failed, we're done. */
12072 if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm),
12073 CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE))
12079 /* Given a template type PARM and a class type ARG, find the unique
12080 base type in ARG that is an instance of PARM. We do not examine
12081 ARG itself; only its base-classes. If there is not exactly one
12082 appropriate base class, return NULL_TREE. PARM may be the type of
12083 a partial specialization, as well as a plain template type. Used
12087 get_template_base (tree tparms, tree targs, tree parm, tree arg)
12089 tree rval = NULL_TREE;
12092 gcc_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg)));
12094 binfo = TYPE_BINFO (complete_type (arg));
12096 /* The type could not be completed. */
12099 /* Walk in inheritance graph order. The search order is not
12100 important, and this avoids multiple walks of virtual bases. */
12101 for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo))
12103 tree r = try_class_unification (tparms, targs, parm, BINFO_TYPE (binfo));
12107 /* If there is more than one satisfactory baseclass, then:
12111 If they yield more than one possible deduced A, the type
12115 if (rval && !same_type_p (r, rval))
12125 /* Returns the level of DECL, which declares a template parameter. */
12128 template_decl_level (tree decl)
12130 switch (TREE_CODE (decl))
12133 case TEMPLATE_DECL:
12134 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl));
12137 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
12140 gcc_unreachable ();
12145 /* Decide whether ARG can be unified with PARM, considering only the
12146 cv-qualifiers of each type, given STRICT as documented for unify.
12147 Returns nonzero iff the unification is OK on that basis. */
12150 check_cv_quals_for_unify (int strict, tree arg, tree parm)
12152 int arg_quals = cp_type_quals (arg);
12153 int parm_quals = cp_type_quals (parm);
12155 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
12156 && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
12158 /* Although a CVR qualifier is ignored when being applied to a
12159 substituted template parameter ([8.3.2]/1 for example), that
12160 does not apply during deduction [14.8.2.4]/1, (even though
12161 that is not explicitly mentioned, [14.8.2.4]/9 indicates
12162 this). Except when we're allowing additional CV qualifiers
12163 at the outer level [14.8.2.1]/3,1st bullet. */
12164 if ((TREE_CODE (arg) == REFERENCE_TYPE
12165 || TREE_CODE (arg) == FUNCTION_TYPE
12166 || TREE_CODE (arg) == METHOD_TYPE)
12167 && (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)))
12170 if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
12171 && (parm_quals & TYPE_QUAL_RESTRICT))
12175 if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
12176 && (arg_quals & parm_quals) != parm_quals)
12179 if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL))
12180 && (parm_quals & arg_quals) != arg_quals)
12186 /* Determines the LEVEL and INDEX for the template parameter PARM. */
12188 template_parm_level_and_index (tree parm, int* level, int* index)
12190 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
12191 || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
12192 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
12194 *index = TEMPLATE_TYPE_IDX (parm);
12195 *level = TEMPLATE_TYPE_LEVEL (parm);
12199 *index = TEMPLATE_PARM_IDX (parm);
12200 *level = TEMPLATE_PARM_LEVEL (parm);
12204 /* Unifies the remaining arguments in PACKED_ARGS with the pack
12205 expansion at the end of PACKED_PARMS. Returns 0 if the type
12206 deduction succeeds, 1 otherwise. STRICT is the same as in
12207 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
12208 call argument list. We'll need to adjust the arguments to make them
12209 types. SUBR tells us if this is from a recursive call to
12210 type_unification_real. */
12212 unify_pack_expansion (tree tparms, tree targs, tree packed_parms,
12213 tree packed_args, int strict, bool call_args_p,
12217 = TREE_VEC_ELT (packed_parms, TREE_VEC_LENGTH (packed_parms) - 1);
12218 tree pattern = PACK_EXPANSION_PATTERN (parm);
12219 tree pack, packs = NULL_TREE;
12220 int i, start = TREE_VEC_LENGTH (packed_parms) - 1;
12221 int len = TREE_VEC_LENGTH (packed_args);
12223 /* Determine the parameter packs we will be deducing from the
12224 pattern, and record their current deductions. */
12225 for (pack = PACK_EXPANSION_PARAMETER_PACKS (parm);
12226 pack; pack = TREE_CHAIN (pack))
12228 tree parm_pack = TREE_VALUE (pack);
12231 /* Determine the index and level of this parameter pack. */
12232 template_parm_level_and_index (parm_pack, &level, &idx);
12234 /* Keep track of the parameter packs and their corresponding
12236 packs = tree_cons (parm_pack, TMPL_ARG (targs, level, idx), packs);
12237 TREE_TYPE (packs) = make_tree_vec (len - start);
12240 /* Loop through all of the arguments that have not yet been
12241 unified and unify each with the pattern. */
12242 for (i = start; i < len; i++)
12244 tree parm = pattern;
12246 /* For each parameter pack, clear out the deduced value so that
12247 we can deduce it again. */
12248 for (pack = packs; pack; pack = TREE_CHAIN (pack))
12251 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12253 TMPL_ARG (targs, level, idx) = NULL_TREE;
12256 /* Unify the pattern with the current argument. */
12258 tree arg = TREE_VEC_ELT (packed_args, i);
12259 int arg_strict = strict;
12260 bool skip_arg_p = false;
12266 /* This mirrors what we do in type_unification_real. */
12270 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL
12271 | UNIFY_ALLOW_MORE_CV_QUAL
12272 | UNIFY_ALLOW_DERIVED);
12276 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
12280 sub_strict = UNIFY_ALLOW_NONE;
12284 gcc_unreachable ();
12289 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
12290 if (type_unknown_p (arg))
12292 /* [temp.deduct.type] A template-argument can be
12293 deduced from a pointer to function or pointer
12294 to member function argument if the set of
12295 overloaded functions does not contain function
12296 templates and at most one of a set of
12297 overloaded functions provides a unique
12300 if (resolve_overloaded_unification
12301 (tparms, targs, parm, arg, strict, sub_strict)
12309 arg = TREE_TYPE (arg);
12310 if (arg == error_mark_node)
12315 arg_strict = sub_strict;
12319 maybe_adjust_types_for_deduction (strict, &parm, &arg, NULL);
12324 if (unify (tparms, targs, parm, arg, arg_strict))
12329 /* For each parameter pack, collect the deduced value. */
12330 for (pack = packs; pack; pack = TREE_CHAIN (pack))
12333 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12335 TREE_VEC_ELT (TREE_TYPE (pack), i - start) =
12336 TMPL_ARG (targs, level, idx);
12340 /* Verify that the results of unification with the parameter packs
12341 produce results consistent with what we've seen before, and make
12342 the deduced argument packs available. */
12343 for (pack = packs; pack; pack = TREE_CHAIN (pack))
12345 tree old_pack = TREE_VALUE (pack);
12346 tree new_args = TREE_TYPE (pack);
12348 if (old_pack && ARGUMENT_PACK_INCOMPLETE_P (old_pack))
12350 /* Prepend the explicit arguments onto NEW_ARGS. */
12351 tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
12352 tree old_args = new_args;
12353 int i, explicit_len = TREE_VEC_LENGTH (explicit_args);
12354 int len = explicit_len + TREE_VEC_LENGTH (old_args);
12356 /* Copy the explicit arguments. */
12357 new_args = make_tree_vec (len);
12358 for (i = 0; i < explicit_len; i++)
12359 TREE_VEC_ELT (new_args, i) = TREE_VEC_ELT (explicit_args, i);
12361 /* Copy the deduced arguments. */
12362 for (; i < len; i++)
12363 TREE_VEC_ELT (new_args, i) =
12364 TREE_VEC_ELT (old_args, i - explicit_len);
12372 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12374 /* Build the deduced *_ARGUMENT_PACK. */
12375 if (TREE_CODE (TREE_PURPOSE (pack)) == TEMPLATE_PARM_INDEX)
12377 result = make_node (NONTYPE_ARGUMENT_PACK);
12378 TREE_TYPE (result) =
12379 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack)));
12380 TREE_CONSTANT (result) = 1;
12383 result = make_node (TYPE_ARGUMENT_PACK);
12385 SET_ARGUMENT_PACK_ARGS (result, new_args);
12387 /* Note the deduced argument packs for this parameter
12389 TMPL_ARG (targs, level, idx) = result;
12391 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack)
12392 && (ARGUMENT_PACK_ARGS (old_pack)
12393 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack)))
12395 /* We only had the explicitly-provided arguments before, but
12396 now we have a complete set of arguments. */
12398 tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
12399 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12401 /* Keep the original deduced argument pack. */
12402 TMPL_ARG (targs, level, idx) = old_pack;
12404 SET_ARGUMENT_PACK_ARGS (old_pack, new_args);
12405 ARGUMENT_PACK_INCOMPLETE_P (old_pack) = 1;
12406 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack) = explicit_args;
12408 else if (!comp_template_args (ARGUMENT_PACK_ARGS (old_pack),
12410 /* Inconsistent unification of this parameter pack. */
12416 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12418 /* Keep the original deduced argument pack. */
12419 TMPL_ARG (targs, level, idx) = old_pack;
12426 /* Deduce the value of template parameters. TPARMS is the (innermost)
12427 set of template parameters to a template. TARGS is the bindings
12428 for those template parameters, as determined thus far; TARGS may
12429 include template arguments for outer levels of template parameters
12430 as well. PARM is a parameter to a template function, or a
12431 subcomponent of that parameter; ARG is the corresponding argument.
12432 This function attempts to match PARM with ARG in a manner
12433 consistent with the existing assignments in TARGS. If more values
12434 are deduced, then TARGS is updated.
12436 Returns 0 if the type deduction succeeds, 1 otherwise. The
12437 parameter STRICT is a bitwise or of the following flags:
12440 Require an exact match between PARM and ARG.
12441 UNIFY_ALLOW_MORE_CV_QUAL:
12442 Allow the deduced ARG to be more cv-qualified (by qualification
12443 conversion) than ARG.
12444 UNIFY_ALLOW_LESS_CV_QUAL:
12445 Allow the deduced ARG to be less cv-qualified than ARG.
12446 UNIFY_ALLOW_DERIVED:
12447 Allow the deduced ARG to be a template base class of ARG,
12448 or a pointer to a template base class of the type pointed to by
12450 UNIFY_ALLOW_INTEGER:
12451 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
12452 case for more information.
12453 UNIFY_ALLOW_OUTER_LEVEL:
12454 This is the outermost level of a deduction. Used to determine validity
12455 of qualification conversions. A valid qualification conversion must
12456 have const qualified pointers leading up to the inner type which
12457 requires additional CV quals, except at the outer level, where const
12458 is not required [conv.qual]. It would be normal to set this flag in
12459 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
12460 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
12461 This is the outermost level of a deduction, and PARM can be more CV
12462 qualified at this point.
12463 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
12464 This is the outermost level of a deduction, and PARM can be less CV
12465 qualified at this point. */
12468 unify (tree tparms, tree targs, tree parm, tree arg, int strict)
12473 int strict_in = strict;
12475 /* I don't think this will do the right thing with respect to types.
12476 But the only case I've seen it in so far has been array bounds, where
12477 signedness is the only information lost, and I think that will be
12479 while (TREE_CODE (parm) == NOP_EXPR)
12480 parm = TREE_OPERAND (parm, 0);
12482 if (arg == error_mark_node)
12484 if (arg == unknown_type_node)
12485 /* We can't deduce anything from this, but we might get all the
12486 template args from other function args. */
12489 /* If PARM uses template parameters, then we can't bail out here,
12490 even if ARG == PARM, since we won't record unifications for the
12491 template parameters. We might need them if we're trying to
12492 figure out which of two things is more specialized. */
12493 if (arg == parm && !uses_template_parms (parm))
12496 /* Immediately reject some pairs that won't unify because of
12497 cv-qualification mismatches. */
12498 if (TREE_CODE (arg) == TREE_CODE (parm)
12500 /* It is the elements of the array which hold the cv quals of an array
12501 type, and the elements might be template type parms. We'll check
12502 when we recurse. */
12503 && TREE_CODE (arg) != ARRAY_TYPE
12504 /* We check the cv-qualifiers when unifying with template type
12505 parameters below. We want to allow ARG `const T' to unify with
12506 PARM `T' for example, when computing which of two templates
12507 is more specialized, for example. */
12508 && TREE_CODE (arg) != TEMPLATE_TYPE_PARM
12509 && !check_cv_quals_for_unify (strict_in, arg, parm))
12512 if (!(strict & UNIFY_ALLOW_OUTER_LEVEL)
12513 && TYPE_P (parm) && !CP_TYPE_CONST_P (parm))
12514 strict &= ~UNIFY_ALLOW_MORE_CV_QUAL;
12515 strict &= ~UNIFY_ALLOW_OUTER_LEVEL;
12516 strict &= ~UNIFY_ALLOW_DERIVED;
12517 strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
12518 strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL;
12520 switch (TREE_CODE (parm))
12522 case TYPENAME_TYPE:
12524 case UNBOUND_CLASS_TEMPLATE:
12525 /* In a type which contains a nested-name-specifier, template
12526 argument values cannot be deduced for template parameters used
12527 within the nested-name-specifier. */
12530 case TEMPLATE_TYPE_PARM:
12531 case TEMPLATE_TEMPLATE_PARM:
12532 case BOUND_TEMPLATE_TEMPLATE_PARM:
12533 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
12534 if (tparm == error_mark_node)
12537 if (TEMPLATE_TYPE_LEVEL (parm)
12538 != template_decl_level (tparm))
12539 /* The PARM is not one we're trying to unify. Just check
12540 to see if it matches ARG. */
12541 return (TREE_CODE (arg) == TREE_CODE (parm)
12542 && same_type_p (parm, arg)) ? 0 : 1;
12543 idx = TEMPLATE_TYPE_IDX (parm);
12544 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
12545 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx));
12547 /* Check for mixed types and values. */
12548 if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
12549 && TREE_CODE (tparm) != TYPE_DECL)
12550 || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
12551 && TREE_CODE (tparm) != TEMPLATE_DECL))
12554 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
12556 /* ARG must be constructed from a template class or a template
12557 template parameter. */
12558 if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM
12559 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg))
12563 tree parmvec = TYPE_TI_ARGS (parm);
12564 tree argvec = INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg));
12566 = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_TI_TEMPLATE (arg));
12569 /* The resolution to DR150 makes clear that default
12570 arguments for an N-argument may not be used to bind T
12571 to a template template parameter with fewer than N
12572 parameters. It is not safe to permit the binding of
12573 default arguments as an extension, as that may change
12574 the meaning of a conforming program. Consider:
12576 struct Dense { static const unsigned int dim = 1; };
12578 template <template <typename> class View,
12580 void operator+(float, View<Block> const&);
12582 template <typename Block,
12583 unsigned int Dim = Block::dim>
12584 struct Lvalue_proxy { operator float() const; };
12588 Lvalue_proxy<Dense> p;
12593 Here, if Lvalue_proxy is permitted to bind to View, then
12594 the global operator+ will be used; if they are not, the
12595 Lvalue_proxy will be converted to float. */
12596 if (coerce_template_parms (argtmplvec, parmvec,
12597 TYPE_TI_TEMPLATE (parm),
12599 /*require_all_args=*/true,
12600 /*use_default_args=*/false)
12601 == error_mark_node)
12604 /* Deduce arguments T, i from TT<T> or TT<i>.
12605 We check each element of PARMVEC and ARGVEC individually
12606 rather than the whole TREE_VEC since they can have
12607 different number of elements. */
12609 for (i = 0; i < TREE_VEC_LENGTH (parmvec); ++i)
12611 if (unify (tparms, targs,
12612 TREE_VEC_ELT (parmvec, i),
12613 TREE_VEC_ELT (argvec, i),
12618 arg = TYPE_TI_TEMPLATE (arg);
12620 /* Fall through to deduce template name. */
12623 if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
12624 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
12626 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
12628 /* Simple cases: Value already set, does match or doesn't. */
12629 if (targ != NULL_TREE && template_args_equal (targ, arg))
12636 /* If PARM is `const T' and ARG is only `int', we don't have
12637 a match unless we are allowing additional qualification.
12638 If ARG is `const int' and PARM is just `T' that's OK;
12639 that binds `const int' to `T'. */
12640 if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL,
12644 /* Consider the case where ARG is `const volatile int' and
12645 PARM is `const T'. Then, T should be `volatile int'. */
12646 arg = cp_build_qualified_type_real
12647 (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
12648 if (arg == error_mark_node)
12651 /* Simple cases: Value already set, does match or doesn't. */
12652 if (targ != NULL_TREE && same_type_p (targ, arg))
12657 /* Make sure that ARG is not a variable-sized array. (Note
12658 that were talking about variable-sized arrays (like
12659 `int[n]'), rather than arrays of unknown size (like
12660 `int[]').) We'll get very confused by such a type since
12661 the bound of the array will not be computable in an
12662 instantiation. Besides, such types are not allowed in
12663 ISO C++, so we can do as we please here. */
12664 if (variably_modified_type_p (arg, NULL_TREE))
12668 /* If ARG is a parameter pack or an expansion, we cannot unify
12669 against it unless PARM is also a parameter pack. */
12670 if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
12671 && !template_parameter_pack_p (parm))
12674 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
12677 case TEMPLATE_PARM_INDEX:
12678 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
12679 if (tparm == error_mark_node)
12682 if (TEMPLATE_PARM_LEVEL (parm)
12683 != template_decl_level (tparm))
12684 /* The PARM is not one we're trying to unify. Just check
12685 to see if it matches ARG. */
12686 return !(TREE_CODE (arg) == TREE_CODE (parm)
12687 && cp_tree_equal (parm, arg));
12689 idx = TEMPLATE_PARM_IDX (parm);
12690 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
12693 return !cp_tree_equal (targ, arg);
12695 /* [temp.deduct.type] If, in the declaration of a function template
12696 with a non-type template-parameter, the non-type
12697 template-parameter is used in an expression in the function
12698 parameter-list and, if the corresponding template-argument is
12699 deduced, the template-argument type shall match the type of the
12700 template-parameter exactly, except that a template-argument
12701 deduced from an array bound may be of any integral type.
12702 The non-type parameter might use already deduced type parameters. */
12703 tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE);
12704 if (!TREE_TYPE (arg))
12705 /* Template-parameter dependent expression. Just accept it for now.
12706 It will later be processed in convert_template_argument. */
12708 else if (same_type_p (TREE_TYPE (arg), tparm))
12710 else if ((strict & UNIFY_ALLOW_INTEGER)
12711 && (TREE_CODE (tparm) == INTEGER_TYPE
12712 || TREE_CODE (tparm) == BOOLEAN_TYPE))
12713 /* Convert the ARG to the type of PARM; the deduced non-type
12714 template argument must exactly match the types of the
12715 corresponding parameter. */
12716 arg = fold (build_nop (TREE_TYPE (parm), arg));
12717 else if (uses_template_parms (tparm))
12718 /* We haven't deduced the type of this parameter yet. Try again
12724 /* If ARG is a parameter pack or an expansion, we cannot unify
12725 against it unless PARM is also a parameter pack. */
12726 if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
12727 && !TEMPLATE_PARM_PARAMETER_PACK (parm))
12730 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
12735 /* A pointer-to-member constant can be unified only with
12736 another constant. */
12737 if (TREE_CODE (arg) != PTRMEM_CST)
12740 /* Just unify the class member. It would be useless (and possibly
12741 wrong, depending on the strict flags) to unify also
12742 PTRMEM_CST_CLASS, because we want to be sure that both parm and
12743 arg refer to the same variable, even if through different
12744 classes. For instance:
12746 struct A { int x; };
12749 Unification of &A::x and &B::x must succeed. */
12750 return unify (tparms, targs, PTRMEM_CST_MEMBER (parm),
12751 PTRMEM_CST_MEMBER (arg), strict);
12756 if (TREE_CODE (arg) != POINTER_TYPE)
12759 /* [temp.deduct.call]
12761 A can be another pointer or pointer to member type that can
12762 be converted to the deduced A via a qualification
12763 conversion (_conv.qual_).
12765 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
12766 This will allow for additional cv-qualification of the
12767 pointed-to types if appropriate. */
12769 if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
12770 /* The derived-to-base conversion only persists through one
12771 level of pointers. */
12772 strict |= (strict_in & UNIFY_ALLOW_DERIVED);
12774 return unify (tparms, targs, TREE_TYPE (parm),
12775 TREE_TYPE (arg), strict);
12778 case REFERENCE_TYPE:
12779 if (TREE_CODE (arg) != REFERENCE_TYPE)
12781 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
12782 strict & UNIFY_ALLOW_MORE_CV_QUAL);
12785 if (TREE_CODE (arg) != ARRAY_TYPE)
12787 if ((TYPE_DOMAIN (parm) == NULL_TREE)
12788 != (TYPE_DOMAIN (arg) == NULL_TREE))
12790 if (TYPE_DOMAIN (parm) != NULL_TREE)
12797 /* Our representation of array types uses "N - 1" as the
12798 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
12799 not an integer constant. We cannot unify arbitrarily
12800 complex expressions, so we eliminate the MINUS_EXPRs
12802 parm_max = TYPE_MAX_VALUE (TYPE_DOMAIN (parm));
12803 parm_cst = TREE_CODE (parm_max) == INTEGER_CST;
12806 gcc_assert (TREE_CODE (parm_max) == MINUS_EXPR);
12807 parm_max = TREE_OPERAND (parm_max, 0);
12809 arg_max = TYPE_MAX_VALUE (TYPE_DOMAIN (arg));
12810 arg_cst = TREE_CODE (arg_max) == INTEGER_CST;
12813 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
12814 trying to unify the type of a variable with the type
12815 of a template parameter. For example:
12817 template <unsigned int N>
12818 void f (char (&) [N]);
12825 Here, the type of the ARG will be "int [g(i)]", and
12826 may be a SAVE_EXPR, etc. */
12827 if (TREE_CODE (arg_max) != MINUS_EXPR)
12829 arg_max = TREE_OPERAND (arg_max, 0);
12832 /* If only one of the bounds used a MINUS_EXPR, compensate
12833 by adding one to the other bound. */
12834 if (parm_cst && !arg_cst)
12835 parm_max = fold_build2 (PLUS_EXPR,
12839 else if (arg_cst && !parm_cst)
12840 arg_max = fold_build2 (PLUS_EXPR,
12845 if (unify (tparms, targs, parm_max, arg_max, UNIFY_ALLOW_INTEGER))
12848 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
12849 strict & UNIFY_ALLOW_MORE_CV_QUAL);
12856 case ENUMERAL_TYPE:
12858 if (TREE_CODE (arg) != TREE_CODE (parm))
12861 /* We have already checked cv-qualification at the top of the
12863 if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
12866 /* As far as unification is concerned, this wins. Later checks
12867 will invalidate it if necessary. */
12870 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
12871 /* Type INTEGER_CST can come from ordinary constant template args. */
12873 while (TREE_CODE (arg) == NOP_EXPR)
12874 arg = TREE_OPERAND (arg, 0);
12876 if (TREE_CODE (arg) != INTEGER_CST)
12878 return !tree_int_cst_equal (parm, arg);
12883 if (TREE_CODE (arg) != TREE_VEC)
12885 if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
12887 for (i = 0; i < TREE_VEC_LENGTH (parm); ++i)
12888 if (unify (tparms, targs,
12889 TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
12897 if (TREE_CODE (arg) != TREE_CODE (parm))
12900 if (TYPE_PTRMEMFUNC_P (parm))
12902 if (!TYPE_PTRMEMFUNC_P (arg))
12905 return unify (tparms, targs,
12906 TYPE_PTRMEMFUNC_FN_TYPE (parm),
12907 TYPE_PTRMEMFUNC_FN_TYPE (arg),
12911 if (CLASSTYPE_TEMPLATE_INFO (parm))
12913 tree t = NULL_TREE;
12915 if (strict_in & UNIFY_ALLOW_DERIVED)
12917 /* First, we try to unify the PARM and ARG directly. */
12918 t = try_class_unification (tparms, targs,
12923 /* Fallback to the special case allowed in
12924 [temp.deduct.call]:
12926 If P is a class, and P has the form
12927 template-id, then A can be a derived class of
12928 the deduced A. Likewise, if P is a pointer to
12929 a class of the form template-id, A can be a
12930 pointer to a derived class pointed to by the
12932 t = get_template_base (tparms, targs, parm, arg);
12938 else if (CLASSTYPE_TEMPLATE_INFO (arg)
12939 && (CLASSTYPE_TI_TEMPLATE (parm)
12940 == CLASSTYPE_TI_TEMPLATE (arg)))
12941 /* Perhaps PARM is something like S<U> and ARG is S<int>.
12942 Then, we should unify `int' and `U'. */
12945 /* There's no chance of unification succeeding. */
12948 return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
12949 CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE);
12951 else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
12956 case FUNCTION_TYPE:
12957 if (TREE_CODE (arg) != TREE_CODE (parm))
12960 /* CV qualifications for methods can never be deduced, they must
12961 match exactly. We need to check them explicitly here,
12962 because type_unification_real treats them as any other
12963 cvqualified parameter. */
12964 if (TREE_CODE (parm) == METHOD_TYPE
12965 && (!check_cv_quals_for_unify
12967 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (arg))),
12968 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (parm))))))
12971 if (unify (tparms, targs, TREE_TYPE (parm),
12972 TREE_TYPE (arg), UNIFY_ALLOW_NONE))
12974 return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
12975 TYPE_ARG_TYPES (arg), 1, DEDUCE_EXACT,
12979 /* Unify a pointer to member with a pointer to member function, which
12980 deduces the type of the member as a function type. */
12981 if (TYPE_PTRMEMFUNC_P (arg))
12985 cp_cv_quals cv_quals;
12987 /* Check top-level cv qualifiers */
12988 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE, arg, parm))
12991 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
12992 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg), UNIFY_ALLOW_NONE))
12995 /* Determine the type of the function we are unifying against. */
12996 method_type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (arg));
12998 build_function_type (TREE_TYPE (method_type),
12999 TREE_CHAIN (TYPE_ARG_TYPES (method_type)));
13001 /* Extract the cv-qualifiers of the member function from the
13002 implicit object parameter and place them on the function
13003 type to be restored later. */
13005 cp_type_quals(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (method_type))));
13006 fntype = build_qualified_type (fntype, cv_quals);
13007 return unify (tparms, targs, TREE_TYPE (parm), fntype, strict);
13010 if (TREE_CODE (arg) != OFFSET_TYPE)
13012 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
13013 TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE))
13015 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
13019 if (DECL_TEMPLATE_PARM_P (parm))
13020 return unify (tparms, targs, DECL_INITIAL (parm), arg, strict);
13021 if (arg != integral_constant_value (parm))
13026 case TEMPLATE_DECL:
13027 /* Matched cases are handled by the ARG == PARM test above. */
13030 case TYPE_ARGUMENT_PACK:
13031 case NONTYPE_ARGUMENT_PACK:
13033 tree packed_parms = ARGUMENT_PACK_ARGS (parm);
13034 tree packed_args = ARGUMENT_PACK_ARGS (arg);
13035 int i, len = TREE_VEC_LENGTH (packed_parms);
13036 int argslen = TREE_VEC_LENGTH (packed_args);
13037 int parm_variadic_p = 0;
13039 /* Check if the parameters end in a pack, making them variadic. */
13041 && PACK_EXPANSION_P (TREE_VEC_ELT (packed_parms, len - 1)))
13042 parm_variadic_p = 1;
13044 /* If we don't have enough arguments to satisfy the parameters
13045 (not counting the pack expression at the end), or we have
13046 too many arguments for a parameter list that doesn't end in
13047 a pack expression, we can't unify. */
13048 if (argslen < (len - parm_variadic_p)
13049 || (argslen > len && !parm_variadic_p))
13052 /* Unify all of the parameters that precede the (optional)
13053 pack expression. */
13054 for (i = 0; i < len - parm_variadic_p; ++i)
13056 if (unify (tparms, targs, TREE_VEC_ELT (packed_parms, i),
13057 TREE_VEC_ELT (packed_args, i), strict))
13061 if (parm_variadic_p)
13062 return unify_pack_expansion (tparms, targs,
13063 packed_parms, packed_args,
13064 strict, /*call_args_p=*/false,
13072 case DECLTYPE_TYPE:
13073 /* Cannot deduce anything from TYPEOF_TYPE or DECLTYPE_TYPE
13078 gcc_assert (EXPR_P (parm));
13080 /* We must be looking at an expression. This can happen with
13084 void foo(S<I>, S<I + 2>);
13086 This is a "nondeduced context":
13090 The nondeduced contexts are:
13092 --A type that is a template-id in which one or more of
13093 the template-arguments is an expression that references
13094 a template-parameter.
13096 In these cases, we assume deduction succeeded, but don't
13097 actually infer any unifications. */
13099 if (!uses_template_parms (parm)
13100 && !template_args_equal (parm, arg))
13107 /* Note that DECL can be defined in this translation unit, if
13111 mark_definable (tree decl)
13114 DECL_NOT_REALLY_EXTERN (decl) = 1;
13115 FOR_EACH_CLONE (clone, decl)
13116 DECL_NOT_REALLY_EXTERN (clone) = 1;
13119 /* Called if RESULT is explicitly instantiated, or is a member of an
13120 explicitly instantiated class. */
13123 mark_decl_instantiated (tree result, int extern_p)
13125 SET_DECL_EXPLICIT_INSTANTIATION (result);
13127 /* If this entity has already been written out, it's too late to
13128 make any modifications. */
13129 if (TREE_ASM_WRITTEN (result))
13132 if (TREE_CODE (result) != FUNCTION_DECL)
13133 /* The TREE_PUBLIC flag for function declarations will have been
13134 set correctly by tsubst. */
13135 TREE_PUBLIC (result) = 1;
13137 /* This might have been set by an earlier implicit instantiation. */
13138 DECL_COMDAT (result) = 0;
13141 DECL_NOT_REALLY_EXTERN (result) = 0;
13144 mark_definable (result);
13145 /* Always make artificials weak. */
13146 if (DECL_ARTIFICIAL (result) && flag_weak)
13147 comdat_linkage (result);
13148 /* For WIN32 we also want to put explicit instantiations in
13149 linkonce sections. */
13150 else if (TREE_PUBLIC (result))
13151 maybe_make_one_only (result);
13154 /* If EXTERN_P, then this function will not be emitted -- unless
13155 followed by an explicit instantiation, at which point its linkage
13156 will be adjusted. If !EXTERN_P, then this function will be
13157 emitted here. In neither circumstance do we want
13158 import_export_decl to adjust the linkage. */
13159 DECL_INTERFACE_KNOWN (result) = 1;
13162 /* Given two function templates PAT1 and PAT2, return:
13164 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
13165 -1 if PAT2 is more specialized than PAT1.
13166 0 if neither is more specialized.
13168 LEN indicates the number of parameters we should consider
13169 (defaulted parameters should not be considered).
13171 The 1998 std underspecified function template partial ordering, and
13172 DR214 addresses the issue. We take pairs of arguments, one from
13173 each of the templates, and deduce them against each other. One of
13174 the templates will be more specialized if all the *other*
13175 template's arguments deduce against its arguments and at least one
13176 of its arguments *does* *not* deduce against the other template's
13177 corresponding argument. Deduction is done as for class templates.
13178 The arguments used in deduction have reference and top level cv
13179 qualifiers removed. Iff both arguments were originally reference
13180 types *and* deduction succeeds in both directions, the template
13181 with the more cv-qualified argument wins for that pairing (if
13182 neither is more cv-qualified, they both are equal). Unlike regular
13183 deduction, after all the arguments have been deduced in this way,
13184 we do *not* verify the deduced template argument values can be
13185 substituted into non-deduced contexts, nor do we have to verify
13186 that all template arguments have been deduced. */
13189 more_specialized_fn (tree pat1, tree pat2, int len)
13191 tree decl1 = DECL_TEMPLATE_RESULT (pat1);
13192 tree decl2 = DECL_TEMPLATE_RESULT (pat2);
13193 tree targs1 = make_tree_vec (DECL_NTPARMS (pat1));
13194 tree targs2 = make_tree_vec (DECL_NTPARMS (pat2));
13195 tree tparms1 = DECL_INNERMOST_TEMPLATE_PARMS (pat1);
13196 tree tparms2 = DECL_INNERMOST_TEMPLATE_PARMS (pat2);
13197 tree args1 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
13198 tree args2 = TYPE_ARG_TYPES (TREE_TYPE (decl2));
13202 /* Remove the this parameter from non-static member functions. If
13203 one is a non-static member function and the other is not a static
13204 member function, remove the first parameter from that function
13205 also. This situation occurs for operator functions where we
13206 locate both a member function (with this pointer) and non-member
13207 operator (with explicit first operand). */
13208 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1))
13210 len--; /* LEN is the number of significant arguments for DECL1 */
13211 args1 = TREE_CHAIN (args1);
13212 if (!DECL_STATIC_FUNCTION_P (decl2))
13213 args2 = TREE_CHAIN (args2);
13215 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2))
13217 args2 = TREE_CHAIN (args2);
13218 if (!DECL_STATIC_FUNCTION_P (decl1))
13221 args1 = TREE_CHAIN (args1);
13225 /* If only one is a conversion operator, they are unordered. */
13226 if (DECL_CONV_FN_P (decl1) != DECL_CONV_FN_P (decl2))
13229 /* Consider the return type for a conversion function */
13230 if (DECL_CONV_FN_P (decl1))
13232 args1 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl1)), args1);
13233 args2 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl2)), args2);
13237 processing_template_decl++;
13241 tree arg1 = TREE_VALUE (args1);
13242 tree arg2 = TREE_VALUE (args2);
13243 int deduce1, deduce2;
13247 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
13248 && TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
13250 /* When both arguments are pack expansions, we need only
13251 unify the patterns themselves. */
13252 arg1 = PACK_EXPANSION_PATTERN (arg1);
13253 arg2 = PACK_EXPANSION_PATTERN (arg2);
13255 /* This is the last comparison we need to do. */
13259 if (TREE_CODE (arg1) == REFERENCE_TYPE)
13261 arg1 = TREE_TYPE (arg1);
13262 quals1 = cp_type_quals (arg1);
13265 if (TREE_CODE (arg2) == REFERENCE_TYPE)
13267 arg2 = TREE_TYPE (arg2);
13268 quals2 = cp_type_quals (arg2);
13271 if ((quals1 < 0) != (quals2 < 0))
13273 /* Only of the args is a reference, see if we should apply
13274 array/function pointer decay to it. This is not part of
13275 DR214, but is, IMHO, consistent with the deduction rules
13276 for the function call itself, and with our earlier
13277 implementation of the underspecified partial ordering
13278 rules. (nathan). */
13281 switch (TREE_CODE (arg1))
13284 arg1 = TREE_TYPE (arg1);
13286 case FUNCTION_TYPE:
13287 arg1 = build_pointer_type (arg1);
13296 switch (TREE_CODE (arg2))
13299 arg2 = TREE_TYPE (arg2);
13301 case FUNCTION_TYPE:
13302 arg2 = build_pointer_type (arg2);
13311 arg1 = TYPE_MAIN_VARIANT (arg1);
13312 arg2 = TYPE_MAIN_VARIANT (arg2);
13314 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION)
13316 int i, len2 = list_length (args2);
13317 tree parmvec = make_tree_vec (1);
13318 tree argvec = make_tree_vec (len2);
13321 /* Setup the parameter vector, which contains only ARG1. */
13322 TREE_VEC_ELT (parmvec, 0) = arg1;
13324 /* Setup the argument vector, which contains the remaining
13326 for (i = 0; i < len2; i++, ta = TREE_CHAIN (ta))
13327 TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
13329 deduce1 = !unify_pack_expansion (tparms1, targs1, parmvec,
13330 argvec, UNIFY_ALLOW_NONE,
13331 /*call_args_p=*/false,
13334 /* We cannot deduce in the other direction, because ARG1 is
13335 a pack expansion but ARG2 is not. */
13338 else if (TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
13340 int i, len1 = list_length (args1);
13341 tree parmvec = make_tree_vec (1);
13342 tree argvec = make_tree_vec (len1);
13345 /* Setup the parameter vector, which contains only ARG1. */
13346 TREE_VEC_ELT (parmvec, 0) = arg2;
13348 /* Setup the argument vector, which contains the remaining
13350 for (i = 0; i < len1; i++, ta = TREE_CHAIN (ta))
13351 TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
13353 deduce2 = !unify_pack_expansion (tparms2, targs2, parmvec,
13354 argvec, UNIFY_ALLOW_NONE,
13355 /*call_args_p=*/false,
13358 /* We cannot deduce in the other direction, because ARG2 is
13359 a pack expansion but ARG1 is not.*/
13365 /* The normal case, where neither argument is a pack
13367 deduce1 = !unify (tparms1, targs1, arg1, arg2, UNIFY_ALLOW_NONE);
13368 deduce2 = !unify (tparms2, targs2, arg2, arg1, UNIFY_ALLOW_NONE);
13375 if (better1 < 0 && better2 < 0)
13376 /* We've failed to deduce something in either direction.
13377 These must be unordered. */
13380 if (deduce1 && deduce2 && quals1 >= 0 && quals2 >= 0)
13382 /* Deduces in both directions, see if quals can
13383 disambiguate. Pretend the worse one failed to deduce. */
13384 if ((quals1 & quals2) == quals2)
13386 if ((quals1 & quals2) == quals1)
13389 if (deduce1 && !deduce2 && !better2)
13391 if (deduce2 && !deduce1 && !better1)
13394 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
13395 || TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
13396 /* We have already processed all of the arguments in our
13397 handing of the pack expansion type. */
13400 args1 = TREE_CHAIN (args1);
13401 args2 = TREE_CHAIN (args2);
13404 processing_template_decl--;
13406 /* All things being equal, if the next argument is a pack expansion
13407 for one function but not for the other, prefer the
13408 non-variadic function. */
13409 if ((better1 > 0) - (better2 > 0) == 0
13410 && args1 && TREE_VALUE (args1)
13411 && args2 && TREE_VALUE (args2))
13413 if (TREE_CODE (TREE_VALUE (args1)) == TYPE_PACK_EXPANSION)
13414 return TREE_CODE (TREE_VALUE (args2)) == TYPE_PACK_EXPANSION ? 0 : -1;
13415 else if (TREE_CODE (TREE_VALUE (args2)) == TYPE_PACK_EXPANSION)
13419 return (better1 > 0) - (better2 > 0);
13422 /* Determine which of two partial specializations is more specialized.
13424 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
13425 to the first partial specialization. The TREE_VALUE is the
13426 innermost set of template parameters for the partial
13427 specialization. PAT2 is similar, but for the second template.
13429 Return 1 if the first partial specialization is more specialized;
13430 -1 if the second is more specialized; 0 if neither is more
13433 See [temp.class.order] for information about determining which of
13434 two templates is more specialized. */
13437 more_specialized_class (tree pat1, tree pat2)
13442 bool any_deductions = false;
13444 tmpl1 = TREE_TYPE (pat1);
13445 tmpl2 = TREE_TYPE (pat2);
13447 /* Just like what happens for functions, if we are ordering between
13448 different class template specializations, we may encounter dependent
13449 types in the arguments, and we need our dependency check functions
13450 to behave correctly. */
13451 ++processing_template_decl;
13452 targs = get_class_bindings (TREE_VALUE (pat1),
13453 CLASSTYPE_TI_ARGS (tmpl1),
13454 CLASSTYPE_TI_ARGS (tmpl2));
13458 any_deductions = true;
13461 targs = get_class_bindings (TREE_VALUE (pat2),
13462 CLASSTYPE_TI_ARGS (tmpl2),
13463 CLASSTYPE_TI_ARGS (tmpl1));
13467 any_deductions = true;
13469 --processing_template_decl;
13471 /* In the case of a tie where at least one of the class templates
13472 has a parameter pack at the end, the template with the most
13473 non-packed parameters wins. */
13476 && (template_args_variadic_p (TREE_PURPOSE (pat1))
13477 || template_args_variadic_p (TREE_PURPOSE (pat2))))
13479 tree args1 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1));
13480 tree args2 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2));
13481 int len1 = TREE_VEC_LENGTH (args1);
13482 int len2 = TREE_VEC_LENGTH (args2);
13484 /* We don't count the pack expansion at the end. */
13485 if (template_args_variadic_p (TREE_PURPOSE (pat1)))
13487 if (template_args_variadic_p (TREE_PURPOSE (pat2)))
13492 else if (len1 < len2)
13499 /* Return the template arguments that will produce the function signature
13500 DECL from the function template FN, with the explicit template
13501 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
13502 also match. Return NULL_TREE if no satisfactory arguments could be
13506 get_bindings (tree fn, tree decl, tree explicit_args, bool check_rettype)
13508 int ntparms = DECL_NTPARMS (fn);
13509 tree targs = make_tree_vec (ntparms);
13511 tree decl_arg_types;
13513 /* Substitute the explicit template arguments into the type of DECL.
13514 The call to fn_type_unification will handle substitution into the
13516 decl_type = TREE_TYPE (decl);
13517 if (explicit_args && uses_template_parms (decl_type))
13520 tree converted_args;
13522 if (DECL_TEMPLATE_INFO (decl))
13523 tmpl = DECL_TI_TEMPLATE (decl);
13525 /* We can get here for some invalid specializations. */
13529 = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
13530 explicit_args, NULL_TREE,
13532 /*require_all_args=*/false,
13533 /*use_default_args=*/false);
13534 if (converted_args == error_mark_node)
13537 decl_type = tsubst (decl_type, converted_args, tf_none, NULL_TREE);
13538 if (decl_type == error_mark_node)
13542 /* Never do unification on the 'this' parameter. */
13543 decl_arg_types = skip_artificial_parms_for (decl,
13544 TYPE_ARG_TYPES (decl_type));
13546 if (fn_type_unification (fn, explicit_args, targs,
13548 (check_rettype || DECL_CONV_FN_P (fn)
13549 ? TREE_TYPE (decl_type) : NULL_TREE),
13550 DEDUCE_EXACT, LOOKUP_NORMAL))
13556 /* Return the innermost template arguments that, when applied to a
13557 template specialization whose innermost template parameters are
13558 TPARMS, and whose specialization arguments are PARMS, yield the
13561 For example, suppose we have:
13563 template <class T, class U> struct S {};
13564 template <class T> struct S<T*, int> {};
13566 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
13567 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
13568 int}. The resulting vector will be {double}, indicating that `T'
13569 is bound to `double'. */
13572 get_class_bindings (tree tparms, tree spec_args, tree args)
13574 int i, ntparms = TREE_VEC_LENGTH (tparms);
13576 tree innermost_deduced_args;
13578 innermost_deduced_args = make_tree_vec (ntparms);
13579 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
13581 deduced_args = copy_node (args);
13582 SET_TMPL_ARGS_LEVEL (deduced_args,
13583 TMPL_ARGS_DEPTH (deduced_args),
13584 innermost_deduced_args);
13587 deduced_args = innermost_deduced_args;
13589 if (unify (tparms, deduced_args,
13590 INNERMOST_TEMPLATE_ARGS (spec_args),
13591 INNERMOST_TEMPLATE_ARGS (args),
13595 for (i = 0; i < ntparms; ++i)
13596 if (! TREE_VEC_ELT (innermost_deduced_args, i))
13599 /* Verify that nondeduced template arguments agree with the type
13600 obtained from argument deduction.
13604 struct A { typedef int X; };
13605 template <class T, class U> struct C {};
13606 template <class T> struct C<T, typename T::X> {};
13608 Then with the instantiation `C<A, int>', we can deduce that
13609 `T' is `A' but unify () does not check whether `typename T::X'
13611 spec_args = tsubst (spec_args, deduced_args, tf_none, NULL_TREE);
13612 if (spec_args == error_mark_node
13613 /* We only need to check the innermost arguments; the other
13614 arguments will always agree. */
13615 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args),
13616 INNERMOST_TEMPLATE_ARGS (args)))
13619 return deduced_args;
13622 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
13623 Return the TREE_LIST node with the most specialized template, if
13624 any. If there is no most specialized template, the error_mark_node
13627 Note that this function does not look at, or modify, the
13628 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
13629 returned is one of the elements of INSTANTIATIONS, callers may
13630 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
13631 and retrieve it from the value returned. */
13634 most_specialized_instantiation (tree templates)
13638 ++processing_template_decl;
13641 for (fn = TREE_CHAIN (templates); fn; fn = TREE_CHAIN (fn))
13645 if (get_bindings (TREE_VALUE (champ),
13646 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
13647 NULL_TREE, /*check_ret=*/false))
13650 if (get_bindings (TREE_VALUE (fn),
13651 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
13652 NULL_TREE, /*check_ret=*/false))
13659 /* Equally specialized, move to next function. If there
13660 is no next function, nothing's most specialized. */
13661 fn = TREE_CHAIN (fn);
13669 /* Now verify that champ is better than everything earlier in the
13670 instantiation list. */
13671 for (fn = templates; fn != champ; fn = TREE_CHAIN (fn))
13672 if (get_bindings (TREE_VALUE (champ),
13673 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
13674 NULL_TREE, /*check_ret=*/false)
13675 || !get_bindings (TREE_VALUE (fn),
13676 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
13677 NULL_TREE, /*check_ret=*/false))
13683 processing_template_decl--;
13686 return error_mark_node;
13691 /* If DECL is a specialization of some template, return the most
13692 general such template. Otherwise, returns NULL_TREE.
13694 For example, given:
13696 template <class T> struct S { template <class U> void f(U); };
13698 if TMPL is `template <class U> void S<int>::f(U)' this will return
13699 the full template. This function will not trace past partial
13700 specializations, however. For example, given in addition:
13702 template <class T> struct S<T*> { template <class U> void f(U); };
13704 if TMPL is `template <class U> void S<int*>::f(U)' this will return
13705 `template <class T> template <class U> S<T*>::f(U)'. */
13708 most_general_template (tree decl)
13710 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
13711 an immediate specialization. */
13712 if (TREE_CODE (decl) == FUNCTION_DECL)
13714 if (DECL_TEMPLATE_INFO (decl)) {
13715 decl = DECL_TI_TEMPLATE (decl);
13717 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
13718 template friend. */
13719 if (TREE_CODE (decl) != TEMPLATE_DECL)
13725 /* Look for more and more general templates. */
13726 while (DECL_TEMPLATE_INFO (decl))
13728 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
13729 (See cp-tree.h for details.) */
13730 if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
13733 if (CLASS_TYPE_P (TREE_TYPE (decl))
13734 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
13737 /* Stop if we run into an explicitly specialized class template. */
13738 if (!DECL_NAMESPACE_SCOPE_P (decl)
13739 && DECL_CONTEXT (decl)
13740 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl)))
13743 decl = DECL_TI_TEMPLATE (decl);
13749 /* Return the most specialized of the class template partial
13750 specializations of TMPL which can produce TYPE, a specialization of
13751 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
13752 a _TYPE node corresponding to the partial specialization, while the
13753 TREE_PURPOSE is the set of template arguments that must be
13754 substituted into the TREE_TYPE in order to generate TYPE.
13756 If the choice of partial specialization is ambiguous, a diagnostic
13757 is issued, and the error_mark_node is returned. If there are no
13758 partial specializations of TMPL matching TYPE, then NULL_TREE is
13762 most_specialized_class (tree type, tree tmpl)
13764 tree list = NULL_TREE;
13770 tree outer_args = NULL_TREE;
13772 tmpl = most_general_template (tmpl);
13773 args = CLASSTYPE_TI_ARGS (type);
13775 /* For determining which partial specialization to use, only the
13776 innermost args are interesting. */
13777 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
13779 outer_args = strip_innermost_template_args (args, 1);
13780 args = INNERMOST_TEMPLATE_ARGS (args);
13783 for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t))
13785 tree partial_spec_args;
13787 tree parms = TREE_VALUE (t);
13789 partial_spec_args = CLASSTYPE_TI_ARGS (TREE_TYPE (t));
13794 ++processing_template_decl;
13796 /* Discard the outer levels of args, and then substitute in the
13797 template args from the enclosing class. */
13798 partial_spec_args = INNERMOST_TEMPLATE_ARGS (partial_spec_args);
13799 partial_spec_args = tsubst_template_args
13800 (partial_spec_args, outer_args, tf_none, NULL_TREE);
13802 /* PARMS already refers to just the innermost parms, but the
13803 template parms in partial_spec_args had their levels lowered
13804 by tsubst, so we need to do the same for the parm list. We
13805 can't just tsubst the TREE_VEC itself, as tsubst wants to
13806 treat a TREE_VEC as an argument vector. */
13807 parms = copy_node (parms);
13808 for (i = TREE_VEC_LENGTH (parms) - 1; i >= 0; --i)
13809 TREE_VEC_ELT (parms, i) =
13810 tsubst (TREE_VEC_ELT (parms, i), outer_args, tf_none, NULL_TREE);
13812 --processing_template_decl;
13814 spec_args = get_class_bindings (parms,
13820 spec_args = add_to_template_args (outer_args, spec_args);
13821 list = tree_cons (spec_args, TREE_VALUE (t), list);
13822 TREE_TYPE (list) = TREE_TYPE (t);
13829 ambiguous_p = false;
13832 t = TREE_CHAIN (t);
13833 for (; t; t = TREE_CHAIN (t))
13835 fate = more_specialized_class (champ, t);
13842 t = TREE_CHAIN (t);
13845 ambiguous_p = true;
13854 for (t = list; t && t != champ; t = TREE_CHAIN (t))
13856 fate = more_specialized_class (champ, t);
13859 ambiguous_p = true;
13866 const char *str = "candidates are:";
13867 error ("ambiguous class template instantiation for %q#T", type);
13868 for (t = list; t; t = TREE_CHAIN (t))
13870 error ("%s %+#T", str, TREE_TYPE (t));
13873 return error_mark_node;
13879 /* Explicitly instantiate DECL. */
13882 do_decl_instantiation (tree decl, tree storage)
13884 tree result = NULL_TREE;
13887 if (!decl || decl == error_mark_node)
13888 /* An error occurred, for which grokdeclarator has already issued
13889 an appropriate message. */
13891 else if (! DECL_LANG_SPECIFIC (decl))
13893 error ("explicit instantiation of non-template %q#D", decl);
13896 else if (TREE_CODE (decl) == VAR_DECL)
13898 /* There is an asymmetry here in the way VAR_DECLs and
13899 FUNCTION_DECLs are handled by grokdeclarator. In the case of
13900 the latter, the DECL we get back will be marked as a
13901 template instantiation, and the appropriate
13902 DECL_TEMPLATE_INFO will be set up. This does not happen for
13903 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
13904 should handle VAR_DECLs as it currently handles
13906 if (!DECL_CLASS_SCOPE_P (decl))
13908 error ("%qD is not a static data member of a class template", decl);
13911 result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false);
13912 if (!result || TREE_CODE (result) != VAR_DECL)
13914 error ("no matching template for %qD found", decl);
13917 if (!same_type_p (TREE_TYPE (result), TREE_TYPE (decl)))
13919 error ("type %qT for explicit instantiation %qD does not match "
13920 "declared type %qT", TREE_TYPE (result), decl,
13925 else if (TREE_CODE (decl) != FUNCTION_DECL)
13927 error ("explicit instantiation of %q#D", decl);
13933 /* Check for various error cases. Note that if the explicit
13934 instantiation is valid the RESULT will currently be marked as an
13935 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
13936 until we get here. */
13938 if (DECL_TEMPLATE_SPECIALIZATION (result))
13940 /* DR 259 [temp.spec].
13942 Both an explicit instantiation and a declaration of an explicit
13943 specialization shall not appear in a program unless the explicit
13944 instantiation follows a declaration of the explicit specialization.
13946 For a given set of template parameters, if an explicit
13947 instantiation of a template appears after a declaration of an
13948 explicit specialization for that template, the explicit
13949 instantiation has no effect. */
13952 else if (DECL_EXPLICIT_INSTANTIATION (result))
13956 No program shall explicitly instantiate any template more
13959 We check DECL_NOT_REALLY_EXTERN so as not to complain when
13960 the first instantiation was `extern' and the second is not,
13961 and EXTERN_P for the opposite case. */
13962 if (DECL_NOT_REALLY_EXTERN (result) && !extern_p)
13963 pedwarn ("duplicate explicit instantiation of %q#D", result);
13964 /* If an "extern" explicit instantiation follows an ordinary
13965 explicit instantiation, the template is instantiated. */
13969 else if (!DECL_IMPLICIT_INSTANTIATION (result))
13971 error ("no matching template for %qD found", result);
13974 else if (!DECL_TEMPLATE_INFO (result))
13976 pedwarn ("explicit instantiation of non-template %q#D", result);
13980 if (storage == NULL_TREE)
13982 else if (storage == ridpointers[(int) RID_EXTERN])
13984 if (pedantic && !in_system_header)
13985 pedwarn ("ISO C++ forbids the use of %<extern%> on explicit "
13990 error ("storage class %qD applied to template instantiation", storage);
13992 check_explicit_instantiation_namespace (result);
13993 mark_decl_instantiated (result, extern_p);
13995 instantiate_decl (result, /*defer_ok=*/1,
13996 /*expl_inst_class_mem_p=*/false);
14000 mark_class_instantiated (tree t, int extern_p)
14002 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
14003 SET_CLASSTYPE_INTERFACE_KNOWN (t);
14004 CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
14005 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
14008 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
14009 rest_of_type_compilation (t, 1);
14013 /* Called from do_type_instantiation through binding_table_foreach to
14014 do recursive instantiation for the type bound in ENTRY. */
14016 bt_instantiate_type_proc (binding_entry entry, void *data)
14018 tree storage = *(tree *) data;
14020 if (IS_AGGR_TYPE (entry->type)
14021 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type)))
14022 do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0);
14025 /* Called from do_type_instantiation to instantiate a member
14026 (a member function or a static member variable) of an
14027 explicitly instantiated class template. */
14029 instantiate_class_member (tree decl, int extern_p)
14031 mark_decl_instantiated (decl, extern_p);
14033 instantiate_decl (decl, /*defer_ok=*/1,
14034 /*expl_inst_class_mem_p=*/true);
14037 /* Perform an explicit instantiation of template class T. STORAGE, if
14038 non-null, is the RID for extern, inline or static. COMPLAIN is
14039 nonzero if this is called from the parser, zero if called recursively,
14040 since the standard is unclear (as detailed below). */
14043 do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
14048 int previous_instantiation_extern_p = 0;
14050 if (TREE_CODE (t) == TYPE_DECL)
14053 if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t))
14055 error ("explicit instantiation of non-template type %qT", t);
14061 if (!COMPLETE_TYPE_P (t))
14063 if (complain & tf_error)
14064 error ("explicit instantiation of %q#T before definition of template",
14069 if (storage != NULL_TREE)
14071 if (pedantic && !in_system_header)
14072 pedwarn("ISO C++ forbids the use of %qE on explicit instantiations",
14075 if (storage == ridpointers[(int) RID_INLINE])
14077 else if (storage == ridpointers[(int) RID_EXTERN])
14079 else if (storage == ridpointers[(int) RID_STATIC])
14083 error ("storage class %qD applied to template instantiation",
14089 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
14091 /* DR 259 [temp.spec].
14093 Both an explicit instantiation and a declaration of an explicit
14094 specialization shall not appear in a program unless the explicit
14095 instantiation follows a declaration of the explicit specialization.
14097 For a given set of template parameters, if an explicit
14098 instantiation of a template appears after a declaration of an
14099 explicit specialization for that template, the explicit
14100 instantiation has no effect. */
14103 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t))
14107 No program shall explicitly instantiate any template more
14110 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
14111 instantiation was `extern'. If EXTERN_P then the second is.
14112 These cases are OK. */
14113 previous_instantiation_extern_p = CLASSTYPE_INTERFACE_ONLY (t);
14115 if (!previous_instantiation_extern_p && !extern_p
14116 && (complain & tf_error))
14117 pedwarn ("duplicate explicit instantiation of %q#T", t);
14119 /* If we've already instantiated the template, just return now. */
14120 if (!CLASSTYPE_INTERFACE_ONLY (t))
14124 check_explicit_instantiation_namespace (TYPE_NAME (t));
14125 mark_class_instantiated (t, extern_p);
14133 /* In contrast to implicit instantiation, where only the
14134 declarations, and not the definitions, of members are
14135 instantiated, we have here:
14139 The explicit instantiation of a class template specialization
14140 implies the instantiation of all of its members not
14141 previously explicitly specialized in the translation unit
14142 containing the explicit instantiation.
14144 Of course, we can't instantiate member template classes, since
14145 we don't have any arguments for them. Note that the standard
14146 is unclear on whether the instantiation of the members are
14147 *explicit* instantiations or not. However, the most natural
14148 interpretation is that it should be an explicit instantiation. */
14151 for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp))
14152 if (TREE_CODE (tmp) == FUNCTION_DECL
14153 && DECL_TEMPLATE_INSTANTIATION (tmp))
14154 instantiate_class_member (tmp, extern_p);
14156 for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp))
14157 if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp))
14158 instantiate_class_member (tmp, extern_p);
14160 if (CLASSTYPE_NESTED_UTDS (t))
14161 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t),
14162 bt_instantiate_type_proc, &storage);
14166 /* Given a function DECL, which is a specialization of TMPL, modify
14167 DECL to be a re-instantiation of TMPL with the same template
14168 arguments. TMPL should be the template into which tsubst'ing
14169 should occur for DECL, not the most general template.
14171 One reason for doing this is a scenario like this:
14174 void f(const T&, int i);
14176 void g() { f(3, 7); }
14179 void f(const T& t, const int i) { }
14181 Note that when the template is first instantiated, with
14182 instantiate_template, the resulting DECL will have no name for the
14183 first parameter, and the wrong type for the second. So, when we go
14184 to instantiate the DECL, we regenerate it. */
14187 regenerate_decl_from_template (tree decl, tree tmpl)
14189 /* The arguments used to instantiate DECL, from the most general
14194 args = DECL_TI_ARGS (decl);
14195 code_pattern = DECL_TEMPLATE_RESULT (tmpl);
14197 /* Make sure that we can see identifiers, and compute access
14199 push_access_scope (decl);
14201 if (TREE_CODE (decl) == FUNCTION_DECL)
14209 args_depth = TMPL_ARGS_DEPTH (args);
14210 parms_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
14211 if (args_depth > parms_depth)
14212 args = get_innermost_template_args (args, parms_depth);
14214 specs = tsubst_exception_specification (TREE_TYPE (code_pattern),
14215 args, tf_error, NULL_TREE);
14217 TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl),
14220 /* Merge parameter declarations. */
14221 decl_parm = skip_artificial_parms_for (decl,
14222 DECL_ARGUMENTS (decl));
14224 = skip_artificial_parms_for (code_pattern,
14225 DECL_ARGUMENTS (code_pattern));
14226 while (decl_parm && !FUNCTION_PARAMETER_PACK_P (pattern_parm))
14231 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
14232 DECL_NAME (decl_parm) = DECL_NAME (pattern_parm);
14233 parm_type = tsubst (TREE_TYPE (pattern_parm), args, tf_error,
14235 parm_type = type_decays_to (parm_type);
14236 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
14237 TREE_TYPE (decl_parm) = parm_type;
14238 attributes = DECL_ATTRIBUTES (pattern_parm);
14239 if (DECL_ATTRIBUTES (decl_parm) != attributes)
14241 DECL_ATTRIBUTES (decl_parm) = attributes;
14242 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
14244 decl_parm = TREE_CHAIN (decl_parm);
14245 pattern_parm = TREE_CHAIN (pattern_parm);
14247 /* Merge any parameters that match with the function parameter
14249 if (pattern_parm && FUNCTION_PARAMETER_PACK_P (pattern_parm))
14252 tree expanded_types;
14253 /* Expand the TYPE_PACK_EXPANSION that provides the types for
14254 the parameters in this function parameter pack. */
14255 expanded_types = tsubst_pack_expansion (TREE_TYPE (pattern_parm),
14256 args, tf_error, NULL_TREE);
14257 len = TREE_VEC_LENGTH (expanded_types);
14258 for (i = 0; i < len; i++)
14263 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
14264 /* Rename the parameter to include the index. */
14265 DECL_NAME (decl_parm) =
14266 make_ith_pack_parameter_name (DECL_NAME (pattern_parm), i);
14267 parm_type = TREE_VEC_ELT (expanded_types, i);
14268 parm_type = type_decays_to (parm_type);
14269 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
14270 TREE_TYPE (decl_parm) = parm_type;
14271 attributes = DECL_ATTRIBUTES (pattern_parm);
14272 if (DECL_ATTRIBUTES (decl_parm) != attributes)
14274 DECL_ATTRIBUTES (decl_parm) = attributes;
14275 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
14277 decl_parm = TREE_CHAIN (decl_parm);
14280 /* Merge additional specifiers from the CODE_PATTERN. */
14281 if (DECL_DECLARED_INLINE_P (code_pattern)
14282 && !DECL_DECLARED_INLINE_P (decl))
14283 DECL_DECLARED_INLINE_P (decl) = 1;
14284 if (DECL_INLINE (code_pattern) && !DECL_INLINE (decl))
14285 DECL_INLINE (decl) = 1;
14287 else if (TREE_CODE (decl) == VAR_DECL)
14288 DECL_INITIAL (decl) =
14289 tsubst_expr (DECL_INITIAL (code_pattern), args,
14290 tf_error, DECL_TI_TEMPLATE (decl),
14291 /*integral_constant_expression_p=*/false);
14293 gcc_unreachable ();
14295 pop_access_scope (decl);
14298 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
14299 substituted to get DECL. */
14302 template_for_substitution (tree decl)
14304 tree tmpl = DECL_TI_TEMPLATE (decl);
14306 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
14307 for the instantiation. This is not always the most general
14308 template. Consider, for example:
14311 struct S { template <class U> void f();
14312 template <> void f<int>(); };
14314 and an instantiation of S<double>::f<int>. We want TD to be the
14315 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
14316 while (/* An instantiation cannot have a definition, so we need a
14317 more general template. */
14318 DECL_TEMPLATE_INSTANTIATION (tmpl)
14319 /* We must also deal with friend templates. Given:
14321 template <class T> struct S {
14322 template <class U> friend void f() {};
14325 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
14326 so far as the language is concerned, but that's still
14327 where we get the pattern for the instantiation from. On
14328 other hand, if the definition comes outside the class, say:
14330 template <class T> struct S {
14331 template <class U> friend void f();
14333 template <class U> friend void f() {}
14335 we don't need to look any further. That's what the check for
14336 DECL_INITIAL is for. */
14337 || (TREE_CODE (decl) == FUNCTION_DECL
14338 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl)
14339 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl))))
14341 /* The present template, TD, should not be a definition. If it
14342 were a definition, we should be using it! Note that we
14343 cannot restructure the loop to just keep going until we find
14344 a template with a definition, since that might go too far if
14345 a specialization was declared, but not defined. */
14346 gcc_assert (TREE_CODE (decl) != VAR_DECL
14347 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl)));
14349 /* Fetch the more general template. */
14350 tmpl = DECL_TI_TEMPLATE (tmpl);
14356 /* Produce the definition of D, a _DECL generated from a template. If
14357 DEFER_OK is nonzero, then we don't have to actually do the
14358 instantiation now; we just have to do it sometime. Normally it is
14359 an error if this is an explicit instantiation but D is undefined.
14360 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
14361 explicitly instantiated class template. */
14364 instantiate_decl (tree d, int defer_ok,
14365 bool expl_inst_class_mem_p)
14367 tree tmpl = DECL_TI_TEMPLATE (d);
14374 bool pattern_defined;
14376 location_t saved_loc = input_location;
14377 int saved_in_system_header = in_system_header;
14380 /* This function should only be used to instantiate templates for
14381 functions and static member variables. */
14382 gcc_assert (TREE_CODE (d) == FUNCTION_DECL
14383 || TREE_CODE (d) == VAR_DECL);
14385 /* Variables are never deferred; if instantiation is required, they
14386 are instantiated right away. That allows for better code in the
14387 case that an expression refers to the value of the variable --
14388 if the variable has a constant value the referring expression can
14389 take advantage of that fact. */
14390 if (TREE_CODE (d) == VAR_DECL)
14393 /* Don't instantiate cloned functions. Instead, instantiate the
14394 functions they cloned. */
14395 if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d))
14396 d = DECL_CLONED_FUNCTION (d);
14398 if (DECL_TEMPLATE_INSTANTIATED (d))
14399 /* D has already been instantiated. It might seem reasonable to
14400 check whether or not D is an explicit instantiation, and, if so,
14401 stop here. But when an explicit instantiation is deferred
14402 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
14403 is set, even though we still need to do the instantiation. */
14406 /* If we already have a specialization of this declaration, then
14407 there's no reason to instantiate it. Note that
14408 retrieve_specialization gives us both instantiations and
14409 specializations, so we must explicitly check
14410 DECL_TEMPLATE_SPECIALIZATION. */
14411 gen_tmpl = most_general_template (tmpl);
14412 gen_args = DECL_TI_ARGS (d);
14413 spec = retrieve_specialization (gen_tmpl, gen_args,
14414 /*class_specializations_p=*/false);
14415 if (spec != NULL_TREE && DECL_TEMPLATE_SPECIALIZATION (spec))
14418 /* This needs to happen before any tsubsting. */
14419 if (! push_tinst_level (d))
14422 timevar_push (TV_PARSE);
14424 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
14425 for the instantiation. */
14426 td = template_for_substitution (d);
14427 code_pattern = DECL_TEMPLATE_RESULT (td);
14429 /* We should never be trying to instantiate a member of a class
14430 template or partial specialization. */
14431 gcc_assert (d != code_pattern);
14433 if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d))
14434 || DECL_TEMPLATE_SPECIALIZATION (td))
14435 /* In the case of a friend template whose definition is provided
14436 outside the class, we may have too many arguments. Drop the
14437 ones we don't need. The same is true for specializations. */
14438 args = get_innermost_template_args
14439 (gen_args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td)));
14443 if (TREE_CODE (d) == FUNCTION_DECL)
14444 pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE);
14446 pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
14448 /* We may be in the middle of deferred access check. Disable it now. */
14449 push_deferring_access_checks (dk_no_deferred);
14451 /* Unless an explicit instantiation directive has already determined
14452 the linkage of D, remember that a definition is available for
14454 if (pattern_defined
14455 && !DECL_INTERFACE_KNOWN (d)
14456 && !DECL_NOT_REALLY_EXTERN (d))
14457 mark_definable (d);
14459 input_location = DECL_SOURCE_LOCATION (d);
14460 in_system_header = DECL_IN_SYSTEM_HEADER (d);
14462 /* If D is a member of an explicitly instantiated class template,
14463 and no definition is available, treat it like an implicit
14465 if (!pattern_defined && expl_inst_class_mem_p
14466 && DECL_EXPLICIT_INSTANTIATION (d))
14468 DECL_NOT_REALLY_EXTERN (d) = 0;
14469 DECL_INTERFACE_KNOWN (d) = 0;
14470 SET_DECL_IMPLICIT_INSTANTIATION (d);
14475 /* Recheck the substitutions to obtain any warning messages
14476 about ignoring cv qualifiers. */
14477 tree gen = DECL_TEMPLATE_RESULT (gen_tmpl);
14478 tree type = TREE_TYPE (gen);
14480 /* Make sure that we can see identifiers, and compute access
14481 correctly. D is already the target FUNCTION_DECL with the
14483 push_access_scope (d);
14485 if (TREE_CODE (gen) == FUNCTION_DECL)
14487 tsubst (DECL_ARGUMENTS (gen), gen_args, tf_warning_or_error, d);
14488 tsubst_exception_specification (type, gen_args, tf_warning_or_error,
14490 /* Don't simply tsubst the function type, as that will give
14491 duplicate warnings about poor parameter qualifications.
14492 The function arguments are the same as the decl_arguments
14493 without the top level cv qualifiers. */
14494 type = TREE_TYPE (type);
14496 tsubst (type, gen_args, tf_warning_or_error, d);
14498 pop_access_scope (d);
14501 /* Check to see whether we know that this template will be
14502 instantiated in some other file, as with "extern template"
14504 external_p = (DECL_INTERFACE_KNOWN (d) && DECL_REALLY_EXTERN (d));
14505 /* In general, we do not instantiate such templates... */
14507 /* ... but we instantiate inline functions so that we can inline
14509 && ! (TREE_CODE (d) == FUNCTION_DECL && DECL_INLINE (d))
14510 /* ... we instantiate static data members whose values are
14511 needed in integral constant expressions. */
14512 && ! (TREE_CODE (d) == VAR_DECL
14513 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (d)))
14515 /* Defer all other templates, unless we have been explicitly
14516 forbidden from doing so. */
14517 if (/* If there is no definition, we cannot instantiate the
14520 /* If it's OK to postpone instantiation, do so. */
14522 /* If this is a static data member that will be defined
14523 elsewhere, we don't want to instantiate the entire data
14524 member, but we do want to instantiate the initializer so that
14525 we can substitute that elsewhere. */
14526 || (external_p && TREE_CODE (d) == VAR_DECL))
14528 /* The definition of the static data member is now required so
14529 we must substitute the initializer. */
14530 if (TREE_CODE (d) == VAR_DECL
14531 && !DECL_INITIAL (d)
14532 && DECL_INITIAL (code_pattern))
14537 ns = decl_namespace_context (d);
14538 push_nested_namespace (ns);
14539 push_nested_class (DECL_CONTEXT (d));
14540 init = tsubst_expr (DECL_INITIAL (code_pattern),
14542 tf_warning_or_error, NULL_TREE,
14543 /*integral_constant_expression_p=*/false);
14544 cp_finish_decl (d, init, /*init_const_expr_p=*/false,
14545 /*asmspec_tree=*/NULL_TREE,
14546 LOOKUP_ONLYCONVERTING);
14547 pop_nested_class ();
14548 pop_nested_namespace (ns);
14551 /* We restore the source position here because it's used by
14552 add_pending_template. */
14553 input_location = saved_loc;
14555 if (at_eof && !pattern_defined
14556 && DECL_EXPLICIT_INSTANTIATION (d))
14559 The definition of a non-exported function template, a
14560 non-exported member function template, or a non-exported
14561 member function or static data member of a class template
14562 shall be present in every translation unit in which it is
14563 explicitly instantiated. */
14565 ("explicit instantiation of %qD but no definition available", d);
14567 /* ??? Historically, we have instantiated inline functions, even
14568 when marked as "extern template". */
14569 if (!(external_p && TREE_CODE (d) == VAR_DECL))
14570 add_pending_template (d);
14573 /* Tell the repository that D is available in this translation unit
14574 -- and see if it is supposed to be instantiated here. */
14575 if (TREE_PUBLIC (d) && !DECL_REALLY_EXTERN (d) && !repo_emit_p (d))
14577 /* In a PCH file, despite the fact that the repository hasn't
14578 requested instantiation in the PCH it is still possible that
14579 an instantiation will be required in a file that includes the
14582 add_pending_template (d);
14583 /* Instantiate inline functions so that the inliner can do its
14584 job, even though we'll not be emitting a copy of this
14586 if (!(TREE_CODE (d) == FUNCTION_DECL
14587 && flag_inline_trees
14588 && DECL_DECLARED_INLINE_P (d)))
14592 need_push = !cfun || !global_bindings_p ();
14594 push_to_top_level ();
14596 /* Mark D as instantiated so that recursive calls to
14597 instantiate_decl do not try to instantiate it again. */
14598 DECL_TEMPLATE_INSTANTIATED (d) = 1;
14600 /* Regenerate the declaration in case the template has been modified
14601 by a subsequent redeclaration. */
14602 regenerate_decl_from_template (d, td);
14604 /* We already set the file and line above. Reset them now in case
14605 they changed as a result of calling regenerate_decl_from_template. */
14606 input_location = DECL_SOURCE_LOCATION (d);
14608 if (TREE_CODE (d) == VAR_DECL)
14612 /* Clear out DECL_RTL; whatever was there before may not be right
14613 since we've reset the type of the declaration. */
14614 SET_DECL_RTL (d, NULL_RTX);
14615 DECL_IN_AGGR_P (d) = 0;
14617 /* The initializer is placed in DECL_INITIAL by
14618 regenerate_decl_from_template. Pull it out so that
14619 finish_decl can process it. */
14620 init = DECL_INITIAL (d);
14621 DECL_INITIAL (d) = NULL_TREE;
14622 DECL_INITIALIZED_P (d) = 0;
14624 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
14625 initializer. That function will defer actual emission until
14626 we have a chance to determine linkage. */
14627 DECL_EXTERNAL (d) = 0;
14629 /* Enter the scope of D so that access-checking works correctly. */
14630 push_nested_class (DECL_CONTEXT (d));
14631 finish_decl (d, init, NULL_TREE);
14632 pop_nested_class ();
14634 else if (TREE_CODE (d) == FUNCTION_DECL)
14636 htab_t saved_local_specializations;
14641 /* Save away the current list, in case we are instantiating one
14642 template from within the body of another. */
14643 saved_local_specializations = local_specializations;
14645 /* Set up the list of local specializations. */
14646 local_specializations = htab_create (37,
14647 hash_local_specialization,
14648 eq_local_specializations,
14651 /* Set up context. */
14652 start_preparsed_function (d, NULL_TREE, SF_PRE_PARSED);
14654 /* Create substitution entries for the parameters. */
14655 subst_decl = DECL_TEMPLATE_RESULT (template_for_substitution (d));
14656 tmpl_parm = DECL_ARGUMENTS (subst_decl);
14657 spec_parm = DECL_ARGUMENTS (d);
14658 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d))
14660 register_local_specialization (spec_parm, tmpl_parm);
14661 spec_parm = skip_artificial_parms_for (d, spec_parm);
14662 tmpl_parm = skip_artificial_parms_for (subst_decl, tmpl_parm);
14664 while (tmpl_parm && !FUNCTION_PARAMETER_PACK_P (tmpl_parm))
14666 register_local_specialization (spec_parm, tmpl_parm);
14667 tmpl_parm = TREE_CHAIN (tmpl_parm);
14668 spec_parm = TREE_CHAIN (spec_parm);
14670 if (tmpl_parm && FUNCTION_PARAMETER_PACK_P (tmpl_parm))
14672 /* Collect all of the extra "packed" parameters into an
14676 tree argpack = make_node (NONTYPE_ARGUMENT_PACK);
14677 tree argtypepack = make_node (TYPE_ARGUMENT_PACK);
14681 /* Count how many parameters remain. */
14682 for (t = spec_parm; t; t = TREE_CHAIN (t))
14685 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
14686 parmvec = make_tree_vec (len);
14687 parmtypevec = make_tree_vec (len);
14688 for(i = 0; i < len; i++, spec_parm = TREE_CHAIN (spec_parm))
14690 TREE_VEC_ELT (parmvec, i) = spec_parm;
14691 TREE_VEC_ELT (parmtypevec, i) = TREE_TYPE (spec_parm);
14694 /* Build the argument packs. */
14695 SET_ARGUMENT_PACK_ARGS (argpack, parmvec);
14696 SET_ARGUMENT_PACK_ARGS (argtypepack, parmtypevec);
14697 TREE_TYPE (argpack) = argtypepack;
14699 /* Register the (value) argument pack as a specialization of
14700 TMPL_PARM, then move on. */
14701 register_local_specialization (argpack, tmpl_parm);
14702 tmpl_parm = TREE_CHAIN (tmpl_parm);
14704 gcc_assert (!spec_parm);
14706 /* Substitute into the body of the function. */
14707 tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
14708 tf_warning_or_error, tmpl,
14709 /*integral_constant_expression_p=*/false);
14711 /* Set the current input_location to the end of the function
14712 so that finish_function knows where we are. */
14713 input_location = DECL_STRUCT_FUNCTION (code_pattern)->function_end_locus;
14715 /* We don't need the local specializations any more. */
14716 htab_delete (local_specializations);
14717 local_specializations = saved_local_specializations;
14719 /* Finish the function. */
14720 d = finish_function (0);
14721 expand_or_defer_fn (d);
14724 /* We're not deferring instantiation any more. */
14725 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
14728 pop_from_top_level ();
14731 input_location = saved_loc;
14732 in_system_header = saved_in_system_header;
14733 pop_deferring_access_checks ();
14734 pop_tinst_level ();
14736 timevar_pop (TV_PARSE);
14741 /* Run through the list of templates that we wish we could
14742 instantiate, and instantiate any we can. RETRIES is the
14743 number of times we retry pending template instantiation. */
14746 instantiate_pending_templates (int retries)
14749 location_t saved_loc = input_location;
14750 int saved_in_system_header = in_system_header;
14752 /* Instantiating templates may trigger vtable generation. This in turn
14753 may require further template instantiations. We place a limit here
14754 to avoid infinite loop. */
14755 if (pending_templates && retries >= max_tinst_depth)
14757 tree decl = pending_templates->tinst->decl;
14759 error ("template instantiation depth exceeds maximum of %d"
14760 " instantiating %q+D, possibly from virtual table generation"
14761 " (use -ftemplate-depth-NN to increase the maximum)",
14762 max_tinst_depth, decl);
14763 if (TREE_CODE (decl) == FUNCTION_DECL)
14764 /* Pretend that we defined it. */
14765 DECL_INITIAL (decl) = error_mark_node;
14771 struct pending_template **t = &pending_templates;
14772 struct pending_template *last = NULL;
14776 tree instantiation = reopen_tinst_level ((*t)->tinst);
14777 bool complete = false;
14779 if (TYPE_P (instantiation))
14783 if (!COMPLETE_TYPE_P (instantiation))
14785 instantiate_class_template (instantiation);
14786 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
14787 for (fn = TYPE_METHODS (instantiation);
14789 fn = TREE_CHAIN (fn))
14790 if (! DECL_ARTIFICIAL (fn))
14791 instantiate_decl (fn,
14793 /*expl_inst_class_mem_p=*/false);
14794 if (COMPLETE_TYPE_P (instantiation))
14798 complete = COMPLETE_TYPE_P (instantiation);
14802 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation)
14803 && !DECL_TEMPLATE_INSTANTIATED (instantiation))
14806 = instantiate_decl (instantiation,
14808 /*expl_inst_class_mem_p=*/false);
14809 if (DECL_TEMPLATE_INSTANTIATED (instantiation))
14813 complete = (DECL_TEMPLATE_SPECIALIZATION (instantiation)
14814 || DECL_TEMPLATE_INSTANTIATED (instantiation));
14818 /* If INSTANTIATION has been instantiated, then we don't
14819 need to consider it again in the future. */
14827 current_tinst_level = NULL;
14829 last_pending_template = last;
14831 while (reconsider);
14833 input_location = saved_loc;
14834 in_system_header = saved_in_system_header;
14837 /* Substitute ARGVEC into T, which is a list of initializers for
14838 either base class or a non-static data member. The TREE_PURPOSEs
14839 are DECLs, and the TREE_VALUEs are the initializer values. Used by
14840 instantiate_decl. */
14843 tsubst_initializer_list (tree t, tree argvec)
14845 tree inits = NULL_TREE;
14847 for (; t; t = TREE_CHAIN (t))
14851 tree expanded_bases = NULL_TREE;
14852 tree expanded_arguments = NULL_TREE;
14855 if (TREE_CODE (TREE_PURPOSE (t)) == TYPE_PACK_EXPANSION)
14860 /* Expand the base class expansion type into separate base
14862 expanded_bases = tsubst_pack_expansion (TREE_PURPOSE (t), argvec,
14863 tf_warning_or_error,
14865 if (expanded_bases == error_mark_node)
14868 /* We'll be building separate TREE_LISTs of arguments for
14870 len = TREE_VEC_LENGTH (expanded_bases);
14871 expanded_arguments = make_tree_vec (len);
14872 for (i = 0; i < len; i++)
14873 TREE_VEC_ELT (expanded_arguments, i) = NULL_TREE;
14875 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
14876 expand each argument in the TREE_VALUE of t. */
14877 expr = make_node (EXPR_PACK_EXPANSION);
14878 PACK_EXPANSION_PARAMETER_PACKS (expr) =
14879 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t));
14881 /* Substitute parameter packs into each argument in the
14883 in_base_initializer = 1;
14884 for (arg = TREE_VALUE (t); arg; arg = TREE_CHAIN (arg))
14886 tree expanded_exprs;
14888 /* Expand the argument. */
14889 SET_PACK_EXPANSION_PATTERN (expr, TREE_VALUE (arg));
14890 expanded_exprs = tsubst_pack_expansion (expr, argvec,
14891 tf_warning_or_error,
14894 /* Prepend each of the expanded expressions to the
14895 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
14896 for (i = 0; i < len; i++)
14898 TREE_VEC_ELT (expanded_arguments, i) =
14899 tree_cons (NULL_TREE, TREE_VEC_ELT (expanded_exprs, i),
14900 TREE_VEC_ELT (expanded_arguments, i));
14903 in_base_initializer = 0;
14905 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
14906 since we built them backwards. */
14907 for (i = 0; i < len; i++)
14909 TREE_VEC_ELT (expanded_arguments, i) =
14910 nreverse (TREE_VEC_ELT (expanded_arguments, i));
14914 for (i = 0; i < len; ++i)
14916 if (expanded_bases)
14918 decl = TREE_VEC_ELT (expanded_bases, i);
14919 decl = expand_member_init (decl);
14920 init = TREE_VEC_ELT (expanded_arguments, i);
14924 decl = tsubst_copy (TREE_PURPOSE (t), argvec,
14925 tf_warning_or_error, NULL_TREE);
14927 decl = expand_member_init (decl);
14928 if (decl && !DECL_P (decl))
14929 in_base_initializer = 1;
14931 init = tsubst_expr (TREE_VALUE (t), argvec,
14932 tf_warning_or_error, NULL_TREE,
14933 /*integral_constant_expression_p=*/false);
14934 in_base_initializer = 0;
14939 init = build_tree_list (decl, init);
14940 TREE_CHAIN (init) = inits;
14948 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
14951 set_current_access_from_decl (tree decl)
14953 if (TREE_PRIVATE (decl))
14954 current_access_specifier = access_private_node;
14955 else if (TREE_PROTECTED (decl))
14956 current_access_specifier = access_protected_node;
14958 current_access_specifier = access_public_node;
14961 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
14962 is the instantiation (which should have been created with
14963 start_enum) and ARGS are the template arguments to use. */
14966 tsubst_enum (tree tag, tree newtag, tree args)
14970 for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
14975 decl = TREE_VALUE (e);
14976 /* Note that in a template enum, the TREE_VALUE is the
14977 CONST_DECL, not the corresponding INTEGER_CST. */
14978 value = tsubst_expr (DECL_INITIAL (decl),
14979 args, tf_warning_or_error, NULL_TREE,
14980 /*integral_constant_expression_p=*/true);
14982 /* Give this enumeration constant the correct access. */
14983 set_current_access_from_decl (decl);
14985 /* Actually build the enumerator itself. */
14986 build_enumerator (DECL_NAME (decl), value, newtag);
14989 finish_enum (newtag);
14990 DECL_SOURCE_LOCATION (TYPE_NAME (newtag))
14991 = DECL_SOURCE_LOCATION (TYPE_NAME (tag));
14994 /* DECL is a FUNCTION_DECL that is a template specialization. Return
14995 its type -- but without substituting the innermost set of template
14996 arguments. So, innermost set of template parameters will appear in
15000 get_mostly_instantiated_function_type (tree decl)
15008 tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
15009 targs = DECL_TI_ARGS (decl);
15010 tparms = DECL_TEMPLATE_PARMS (tmpl);
15011 parm_depth = TMPL_PARMS_DEPTH (tparms);
15013 /* There should be as many levels of arguments as there are levels
15015 gcc_assert (parm_depth == TMPL_ARGS_DEPTH (targs));
15017 fn_type = TREE_TYPE (tmpl);
15019 if (parm_depth == 1)
15020 /* No substitution is necessary. */
15024 int i, save_access_control;
15027 /* Replace the innermost level of the TARGS with NULL_TREEs to
15028 let tsubst know not to substitute for those parameters. */
15029 partial_args = make_tree_vec (TREE_VEC_LENGTH (targs));
15030 for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i)
15031 SET_TMPL_ARGS_LEVEL (partial_args, i,
15032 TMPL_ARGS_LEVEL (targs, i));
15033 SET_TMPL_ARGS_LEVEL (partial_args,
15034 TMPL_ARGS_DEPTH (targs),
15035 make_tree_vec (DECL_NTPARMS (tmpl)));
15037 /* Disable access control as this function is used only during
15039 save_access_control = flag_access_control;
15040 flag_access_control = 0;
15042 ++processing_template_decl;
15043 /* Now, do the (partial) substitution to figure out the
15044 appropriate function type. */
15045 fn_type = tsubst (fn_type, partial_args, tf_error, NULL_TREE);
15046 --processing_template_decl;
15048 /* Substitute into the template parameters to obtain the real
15049 innermost set of parameters. This step is important if the
15050 innermost set of template parameters contains value
15051 parameters whose types depend on outer template parameters. */
15052 TREE_VEC_LENGTH (partial_args)--;
15053 tparms = tsubst_template_parms (tparms, partial_args, tf_error);
15055 flag_access_control = save_access_control;
15061 /* Return truthvalue if we're processing a template different from
15062 the last one involved in diagnostics. */
15064 problematic_instantiation_changed (void)
15066 return last_template_error_tick != tinst_level_tick;
15069 /* Remember current template involved in diagnostics. */
15071 record_last_problematic_instantiation (void)
15073 last_template_error_tick = tinst_level_tick;
15076 struct tinst_level *
15077 current_instantiation (void)
15079 return current_tinst_level;
15082 /* [temp.param] Check that template non-type parm TYPE is of an allowable
15083 type. Return zero for ok, nonzero for disallowed. Issue error and
15084 warning messages under control of COMPLAIN. */
15087 invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain)
15089 if (INTEGRAL_TYPE_P (type))
15091 else if (POINTER_TYPE_P (type))
15093 else if (TYPE_PTR_TO_MEMBER_P (type))
15095 else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
15097 else if (TREE_CODE (type) == TYPENAME_TYPE)
15100 if (complain & tf_error)
15101 error ("%q#T is not a valid type for a template constant parameter", type);
15105 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
15106 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
15109 dependent_type_p_r (tree type)
15115 A type is dependent if it is:
15117 -- a template parameter. Template template parameters are types
15118 for us (since TYPE_P holds true for them) so we handle
15120 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
15121 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
15123 /* -- a qualified-id with a nested-name-specifier which contains a
15124 class-name that names a dependent type or whose unqualified-id
15125 names a dependent type. */
15126 if (TREE_CODE (type) == TYPENAME_TYPE)
15128 /* -- a cv-qualified type where the cv-unqualified type is
15130 type = TYPE_MAIN_VARIANT (type);
15131 /* -- a compound type constructed from any dependent type. */
15132 if (TYPE_PTR_TO_MEMBER_P (type))
15133 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type))
15134 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
15136 else if (TREE_CODE (type) == POINTER_TYPE
15137 || TREE_CODE (type) == REFERENCE_TYPE)
15138 return dependent_type_p (TREE_TYPE (type));
15139 else if (TREE_CODE (type) == FUNCTION_TYPE
15140 || TREE_CODE (type) == METHOD_TYPE)
15144 if (dependent_type_p (TREE_TYPE (type)))
15146 for (arg_type = TYPE_ARG_TYPES (type);
15148 arg_type = TREE_CHAIN (arg_type))
15149 if (dependent_type_p (TREE_VALUE (arg_type)))
15153 /* -- an array type constructed from any dependent type or whose
15154 size is specified by a constant expression that is
15155 value-dependent. */
15156 if (TREE_CODE (type) == ARRAY_TYPE)
15158 if (TYPE_DOMAIN (type)
15159 && ((value_dependent_expression_p
15160 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
15161 || (type_dependent_expression_p
15162 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))))
15164 return dependent_type_p (TREE_TYPE (type));
15167 /* -- a template-id in which either the template name is a template
15169 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
15171 /* ... or any of the template arguments is a dependent type or
15172 an expression that is type-dependent or value-dependent. */
15173 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
15174 && (any_dependent_template_arguments_p
15175 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
15178 /* All TYPEOF_TYPEs and DECLTYPE_TYPEs are dependent; if the
15179 argument of the `typeof' expression is not type-dependent, then
15180 it should already been have resolved. */
15181 if (TREE_CODE (type) == TYPEOF_TYPE
15182 || TREE_CODE (type) == DECLTYPE_TYPE)
15185 /* A template argument pack is dependent if any of its packed
15187 if (TREE_CODE (type) == TYPE_ARGUMENT_PACK)
15189 tree args = ARGUMENT_PACK_ARGS (type);
15190 int i, len = TREE_VEC_LENGTH (args);
15191 for (i = 0; i < len; ++i)
15192 if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
15196 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
15197 be template parameters. */
15198 if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
15201 /* The standard does not specifically mention types that are local
15202 to template functions or local classes, but they should be
15203 considered dependent too. For example:
15205 template <int I> void f() {
15210 The size of `E' cannot be known until the value of `I' has been
15211 determined. Therefore, `E' must be considered dependent. */
15212 scope = TYPE_CONTEXT (type);
15213 if (scope && TYPE_P (scope))
15214 return dependent_type_p (scope);
15215 else if (scope && TREE_CODE (scope) == FUNCTION_DECL)
15216 return type_dependent_expression_p (scope);
15218 /* Other types are non-dependent. */
15222 /* Returns TRUE if TYPE is dependent, in the sense of
15223 [temp.dep.type]. */
15226 dependent_type_p (tree type)
15228 /* If there are no template parameters in scope, then there can't be
15229 any dependent types. */
15230 if (!processing_template_decl)
15232 /* If we are not processing a template, then nobody should be
15233 providing us with a dependent type. */
15235 gcc_assert (TREE_CODE (type) != TEMPLATE_TYPE_PARM);
15239 /* If the type is NULL, we have not computed a type for the entity
15240 in question; in that case, the type is dependent. */
15244 /* Erroneous types can be considered non-dependent. */
15245 if (type == error_mark_node)
15248 /* If we have not already computed the appropriate value for TYPE,
15250 if (!TYPE_DEPENDENT_P_VALID (type))
15252 TYPE_DEPENDENT_P (type) = dependent_type_p_r (type);
15253 TYPE_DEPENDENT_P_VALID (type) = 1;
15256 return TYPE_DEPENDENT_P (type);
15259 /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
15262 dependent_scope_ref_p (tree expression, bool criterion (tree))
15267 gcc_assert (TREE_CODE (expression) == SCOPE_REF);
15269 if (!TYPE_P (TREE_OPERAND (expression, 0)))
15272 scope = TREE_OPERAND (expression, 0);
15273 name = TREE_OPERAND (expression, 1);
15277 An id-expression is type-dependent if it contains a
15278 nested-name-specifier that contains a class-name that names a
15280 /* The suggested resolution to Core Issue 2 implies that if the
15281 qualifying type is the current class, then we must peek
15284 && currently_open_class (scope)
15285 && !criterion (name))
15287 if (dependent_type_p (scope))
15293 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
15294 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
15298 value_dependent_expression_p (tree expression)
15300 if (!processing_template_decl)
15303 /* A name declared with a dependent type. */
15304 if (DECL_P (expression) && type_dependent_expression_p (expression))
15307 switch (TREE_CODE (expression))
15309 case IDENTIFIER_NODE:
15310 /* A name that has not been looked up -- must be dependent. */
15313 case TEMPLATE_PARM_INDEX:
15314 /* A non-type template parm. */
15318 /* A non-type template parm. */
15319 if (DECL_TEMPLATE_PARM_P (expression))
15324 /* A constant with integral or enumeration type and is initialized
15325 with an expression that is value-dependent. */
15326 if (DECL_INITIAL (expression)
15327 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression))
15328 && value_dependent_expression_p (DECL_INITIAL (expression)))
15332 case DYNAMIC_CAST_EXPR:
15333 case STATIC_CAST_EXPR:
15334 case CONST_CAST_EXPR:
15335 case REINTERPRET_CAST_EXPR:
15337 /* These expressions are value-dependent if the type to which
15338 the cast occurs is dependent or the expression being casted
15339 is value-dependent. */
15341 tree type = TREE_TYPE (expression);
15343 if (dependent_type_p (type))
15346 /* A functional cast has a list of operands. */
15347 expression = TREE_OPERAND (expression, 0);
15350 /* If there are no operands, it must be an expression such
15351 as "int()". This should not happen for aggregate types
15352 because it would form non-constant expressions. */
15353 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
15358 if (TREE_CODE (expression) == TREE_LIST)
15359 return any_value_dependent_elements_p (expression);
15361 return value_dependent_expression_p (expression);
15366 /* A `sizeof' expression is value-dependent if the operand is
15367 type-dependent or is a pack expansion. */
15368 expression = TREE_OPERAND (expression, 0);
15369 if (PACK_EXPANSION_P (expression))
15371 else if (TYPE_P (expression))
15372 return dependent_type_p (expression);
15373 return type_dependent_expression_p (expression);
15376 return dependent_scope_ref_p (expression, value_dependent_expression_p);
15378 case COMPONENT_REF:
15379 return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
15380 || value_dependent_expression_p (TREE_OPERAND (expression, 1)));
15383 /* A CALL_EXPR may appear in a constant expression if it is a
15384 call to a builtin function, e.g., __builtin_constant_p. All
15385 such calls are value-dependent. */
15388 case NONTYPE_ARGUMENT_PACK:
15389 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
15390 is value-dependent. */
15392 tree values = ARGUMENT_PACK_ARGS (expression);
15393 int i, len = TREE_VEC_LENGTH (values);
15395 for (i = 0; i < len; ++i)
15396 if (value_dependent_expression_p (TREE_VEC_ELT (values, i)))
15404 tree type2 = TRAIT_EXPR_TYPE2 (expression);
15405 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression))
15406 || (type2 ? dependent_type_p (type2) : false));
15410 return ((value_dependent_expression_p (TREE_OPERAND (expression, 0)))
15411 || (value_dependent_expression_p (TREE_OPERAND (expression, 2))));
15414 /* A constant expression is value-dependent if any subexpression is
15415 value-dependent. */
15416 switch (TREE_CODE_CLASS (TREE_CODE (expression)))
15418 case tcc_reference:
15420 return (value_dependent_expression_p
15421 (TREE_OPERAND (expression, 0)));
15423 case tcc_comparison:
15425 return ((value_dependent_expression_p
15426 (TREE_OPERAND (expression, 0)))
15427 || (value_dependent_expression_p
15428 (TREE_OPERAND (expression, 1))));
15430 case tcc_expression:
15434 for (i = 0; i < TREE_OPERAND_LENGTH (expression); ++i)
15435 /* In some cases, some of the operands may be missing.
15436 (For example, in the case of PREDECREMENT_EXPR, the
15437 amount to increment by may be missing.) That doesn't
15438 make the expression dependent. */
15439 if (TREE_OPERAND (expression, i)
15440 && (value_dependent_expression_p
15441 (TREE_OPERAND (expression, i))))
15451 /* The expression is not value-dependent. */
15455 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
15456 [temp.dep.expr]. */
15459 type_dependent_expression_p (tree expression)
15461 if (!processing_template_decl)
15464 if (expression == error_mark_node)
15467 /* An unresolved name is always dependent. */
15468 if (TREE_CODE (expression) == IDENTIFIER_NODE
15469 || TREE_CODE (expression) == USING_DECL)
15472 /* Some expression forms are never type-dependent. */
15473 if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR
15474 || TREE_CODE (expression) == SIZEOF_EXPR
15475 || TREE_CODE (expression) == ALIGNOF_EXPR
15476 || TREE_CODE (expression) == TRAIT_EXPR
15477 || TREE_CODE (expression) == TYPEID_EXPR
15478 || TREE_CODE (expression) == DELETE_EXPR
15479 || TREE_CODE (expression) == VEC_DELETE_EXPR
15480 || TREE_CODE (expression) == THROW_EXPR)
15483 /* The types of these expressions depends only on the type to which
15484 the cast occurs. */
15485 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
15486 || TREE_CODE (expression) == STATIC_CAST_EXPR
15487 || TREE_CODE (expression) == CONST_CAST_EXPR
15488 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
15489 || TREE_CODE (expression) == CAST_EXPR)
15490 return dependent_type_p (TREE_TYPE (expression));
15492 /* The types of these expressions depends only on the type created
15493 by the expression. */
15494 if (TREE_CODE (expression) == NEW_EXPR
15495 || TREE_CODE (expression) == VEC_NEW_EXPR)
15497 /* For NEW_EXPR tree nodes created inside a template, either
15498 the object type itself or a TREE_LIST may appear as the
15500 tree type = TREE_OPERAND (expression, 1);
15501 if (TREE_CODE (type) == TREE_LIST)
15502 /* This is an array type. We need to check array dimensions
15504 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type)))
15505 || value_dependent_expression_p
15506 (TREE_OPERAND (TREE_VALUE (type), 1));
15508 return dependent_type_p (type);
15511 if (TREE_CODE (expression) == SCOPE_REF
15512 && dependent_scope_ref_p (expression,
15513 type_dependent_expression_p))
15516 if (TREE_CODE (expression) == FUNCTION_DECL
15517 && DECL_LANG_SPECIFIC (expression)
15518 && DECL_TEMPLATE_INFO (expression)
15519 && (any_dependent_template_arguments_p
15520 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
15523 if (TREE_CODE (expression) == TEMPLATE_DECL
15524 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression))
15527 if (TREE_CODE (expression) == STMT_EXPR)
15528 expression = stmt_expr_value_expr (expression);
15530 if (TREE_TYPE (expression) == unknown_type_node)
15532 if (TREE_CODE (expression) == ADDR_EXPR)
15533 return type_dependent_expression_p (TREE_OPERAND (expression, 0));
15534 if (TREE_CODE (expression) == COMPONENT_REF
15535 || TREE_CODE (expression) == OFFSET_REF)
15537 if (type_dependent_expression_p (TREE_OPERAND (expression, 0)))
15539 expression = TREE_OPERAND (expression, 1);
15540 if (TREE_CODE (expression) == IDENTIFIER_NODE)
15543 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
15544 if (TREE_CODE (expression) == SCOPE_REF)
15547 if (TREE_CODE (expression) == BASELINK)
15548 expression = BASELINK_FUNCTIONS (expression);
15550 if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
15552 if (any_dependent_template_arguments_p
15553 (TREE_OPERAND (expression, 1)))
15555 expression = TREE_OPERAND (expression, 0);
15557 gcc_assert (TREE_CODE (expression) == OVERLOAD
15558 || TREE_CODE (expression) == FUNCTION_DECL);
15562 if (type_dependent_expression_p (OVL_CURRENT (expression)))
15564 expression = OVL_NEXT (expression);
15569 gcc_assert (TREE_CODE (expression) != TYPE_DECL);
15571 return (dependent_type_p (TREE_TYPE (expression)));
15574 /* Returns TRUE if ARGS (a TREE_LIST of arguments to a function call)
15575 contains a type-dependent expression. */
15578 any_type_dependent_arguments_p (const_tree args)
15582 tree arg = TREE_VALUE (args);
15584 if (type_dependent_expression_p (arg))
15586 args = TREE_CHAIN (args);
15591 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
15592 expressions) contains any value-dependent expressions. */
15595 any_value_dependent_elements_p (const_tree list)
15597 for (; list; list = TREE_CHAIN (list))
15598 if (value_dependent_expression_p (TREE_VALUE (list)))
15604 /* Returns TRUE if the ARG (a template argument) is dependent. */
15607 dependent_template_arg_p (tree arg)
15609 if (!processing_template_decl)
15612 if (TREE_CODE (arg) == TEMPLATE_DECL
15613 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
15614 return dependent_template_p (arg);
15615 else if (ARGUMENT_PACK_P (arg))
15617 tree args = ARGUMENT_PACK_ARGS (arg);
15618 int i, len = TREE_VEC_LENGTH (args);
15619 for (i = 0; i < len; ++i)
15621 if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
15627 else if (TYPE_P (arg))
15628 return dependent_type_p (arg);
15630 return (type_dependent_expression_p (arg)
15631 || value_dependent_expression_p (arg));
15634 /* Returns true if ARGS (a collection of template arguments) contains
15635 any types that require structural equality testing. */
15638 any_template_arguments_need_structural_equality_p (tree args)
15645 if (args == error_mark_node)
15648 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
15650 tree level = TMPL_ARGS_LEVEL (args, i + 1);
15651 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
15653 tree arg = TREE_VEC_ELT (level, j);
15654 tree packed_args = NULL_TREE;
15657 if (ARGUMENT_PACK_P (arg))
15659 /* Look inside the argument pack. */
15660 packed_args = ARGUMENT_PACK_ARGS (arg);
15661 len = TREE_VEC_LENGTH (packed_args);
15664 for (k = 0; k < len; ++k)
15667 arg = TREE_VEC_ELT (packed_args, k);
15669 if (error_operand_p (arg))
15671 else if (TREE_CODE (arg) == TEMPLATE_DECL
15672 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
15674 else if (TYPE_P (arg) && TYPE_STRUCTURAL_EQUALITY_P (arg))
15676 else if (!TYPE_P (arg) && TREE_TYPE (arg)
15677 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg)))
15686 /* Returns true if ARGS (a collection of template arguments) contains
15687 any dependent arguments. */
15690 any_dependent_template_arguments_p (const_tree args)
15697 if (args == error_mark_node)
15700 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
15702 const_tree level = TMPL_ARGS_LEVEL (args, i + 1);
15703 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
15704 if (dependent_template_arg_p (TREE_VEC_ELT (level, j)))
15711 /* Returns TRUE if the template TMPL is dependent. */
15714 dependent_template_p (tree tmpl)
15716 if (TREE_CODE (tmpl) == OVERLOAD)
15720 if (dependent_template_p (OVL_FUNCTION (tmpl)))
15722 tmpl = OVL_CHAIN (tmpl);
15727 /* Template template parameters are dependent. */
15728 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
15729 || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
15731 /* So are names that have not been looked up. */
15732 if (TREE_CODE (tmpl) == SCOPE_REF
15733 || TREE_CODE (tmpl) == IDENTIFIER_NODE)
15735 /* So are member templates of dependent classes. */
15736 if (TYPE_P (CP_DECL_CONTEXT (tmpl)))
15737 return dependent_type_p (DECL_CONTEXT (tmpl));
15741 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
15744 dependent_template_id_p (tree tmpl, tree args)
15746 return (dependent_template_p (tmpl)
15747 || any_dependent_template_arguments_p (args));
15750 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
15751 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
15752 no such TYPE can be found. Note that this function peers inside
15753 uninstantiated templates and therefore should be used only in
15754 extremely limited situations. ONLY_CURRENT_P restricts this
15755 peering to the currently open classes hierarchy (which is required
15756 when comparing types). */
15759 resolve_typename_type (tree type, bool only_current_p)
15768 gcc_assert (TREE_CODE (type) == TYPENAME_TYPE);
15770 scope = TYPE_CONTEXT (type);
15771 name = TYPE_IDENTIFIER (type);
15773 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
15774 it first before we can figure out what NAME refers to. */
15775 if (TREE_CODE (scope) == TYPENAME_TYPE)
15776 scope = resolve_typename_type (scope, only_current_p);
15777 /* If we don't know what SCOPE refers to, then we cannot resolve the
15779 if (TREE_CODE (scope) == TYPENAME_TYPE)
15781 /* If the SCOPE is a template type parameter, we have no way of
15782 resolving the name. */
15783 if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
15785 /* If the SCOPE is not the current instantiation, there's no reason
15786 to look inside it. */
15787 if (only_current_p && !currently_open_class (scope))
15789 /* If SCOPE isn't the template itself, it will not have a valid
15790 TYPE_FIELDS list. */
15791 if (same_type_p (scope, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope)))
15792 /* scope is either the template itself or a compatible instantiation
15793 like X<T>, so look up the name in the original template. */
15794 scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope);
15796 /* scope is a partial instantiation, so we can't do the lookup or we
15797 will lose the template arguments. */
15799 /* Enter the SCOPE so that name lookup will be resolved as if we
15800 were in the class definition. In particular, SCOPE will no
15801 longer be considered a dependent type. */
15802 pushed_scope = push_scope (scope);
15803 /* Look up the declaration. */
15804 decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true);
15806 result = NULL_TREE;
15808 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
15809 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
15812 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE
15813 && TREE_CODE (decl) == TYPE_DECL)
15815 result = TREE_TYPE (decl);
15816 if (result == error_mark_node)
15817 result = NULL_TREE;
15819 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR
15820 && DECL_CLASS_TEMPLATE_P (decl))
15824 /* Obtain the template and the arguments. */
15825 tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0);
15826 args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1);
15827 /* Instantiate the template. */
15828 result = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE,
15829 /*entering_scope=*/0,
15830 tf_error | tf_user);
15831 if (result == error_mark_node)
15832 result = NULL_TREE;
15835 /* Leave the SCOPE. */
15837 pop_scope (pushed_scope);
15839 /* If we failed to resolve it, return the original typename. */
15843 /* If lookup found a typename type, resolve that too. */
15844 if (TREE_CODE (result) == TYPENAME_TYPE && !TYPENAME_IS_RESOLVING_P (result))
15846 /* Ill-formed programs can cause infinite recursion here, so we
15847 must catch that. */
15848 TYPENAME_IS_RESOLVING_P (type) = 1;
15849 result = resolve_typename_type (result, only_current_p);
15850 TYPENAME_IS_RESOLVING_P (type) = 0;
15853 /* Qualify the resulting type. */
15854 quals = cp_type_quals (type);
15856 result = cp_build_qualified_type (result, cp_type_quals (result) | quals);
15861 /* EXPR is an expression which is not type-dependent. Return a proxy
15862 for EXPR that can be used to compute the types of larger
15863 expressions containing EXPR. */
15866 build_non_dependent_expr (tree expr)
15870 /* Preserve null pointer constants so that the type of things like
15871 "p == 0" where "p" is a pointer can be determined. */
15872 if (null_ptr_cst_p (expr))
15874 /* Preserve OVERLOADs; the functions must be available to resolve
15877 if (TREE_CODE (inner_expr) == STMT_EXPR)
15878 inner_expr = stmt_expr_value_expr (inner_expr);
15879 if (TREE_CODE (inner_expr) == ADDR_EXPR)
15880 inner_expr = TREE_OPERAND (inner_expr, 0);
15881 if (TREE_CODE (inner_expr) == COMPONENT_REF)
15882 inner_expr = TREE_OPERAND (inner_expr, 1);
15883 if (is_overloaded_fn (inner_expr)
15884 || TREE_CODE (inner_expr) == OFFSET_REF)
15886 /* There is no need to return a proxy for a variable. */
15887 if (TREE_CODE (expr) == VAR_DECL)
15889 /* Preserve string constants; conversions from string constants to
15890 "char *" are allowed, even though normally a "const char *"
15891 cannot be used to initialize a "char *". */
15892 if (TREE_CODE (expr) == STRING_CST)
15894 /* Preserve arithmetic constants, as an optimization -- there is no
15895 reason to create a new node. */
15896 if (TREE_CODE (expr) == INTEGER_CST || TREE_CODE (expr) == REAL_CST)
15898 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
15899 There is at least one place where we want to know that a
15900 particular expression is a throw-expression: when checking a ?:
15901 expression, there are special rules if the second or third
15902 argument is a throw-expression. */
15903 if (TREE_CODE (expr) == THROW_EXPR)
15906 if (TREE_CODE (expr) == COND_EXPR)
15907 return build3 (COND_EXPR,
15909 TREE_OPERAND (expr, 0),
15910 (TREE_OPERAND (expr, 1)
15911 ? build_non_dependent_expr (TREE_OPERAND (expr, 1))
15912 : build_non_dependent_expr (TREE_OPERAND (expr, 0))),
15913 build_non_dependent_expr (TREE_OPERAND (expr, 2)));
15914 if (TREE_CODE (expr) == COMPOUND_EXPR
15915 && !COMPOUND_EXPR_OVERLOADED (expr))
15916 return build2 (COMPOUND_EXPR,
15918 TREE_OPERAND (expr, 0),
15919 build_non_dependent_expr (TREE_OPERAND (expr, 1)));
15921 /* If the type is unknown, it can't really be non-dependent */
15922 gcc_assert (TREE_TYPE (expr) != unknown_type_node);
15924 /* Otherwise, build a NON_DEPENDENT_EXPR.
15926 REFERENCE_TYPEs are not stripped for expressions in templates
15927 because doing so would play havoc with mangling. Consider, for
15930 template <typename T> void f<T& g>() { g(); }
15932 In the body of "f", the expression for "g" will have
15933 REFERENCE_TYPE, even though the standard says that it should
15934 not. The reason is that we must preserve the syntactic form of
15935 the expression so that mangling (say) "f<g>" inside the body of
15936 "f" works out correctly. Therefore, the REFERENCE_TYPE is
15938 return build1 (NON_DEPENDENT_EXPR, non_reference (TREE_TYPE (expr)), expr);
15941 /* ARGS is a TREE_LIST of expressions as arguments to a function call.
15942 Return a new TREE_LIST with the various arguments replaced with
15943 equivalent non-dependent expressions. */
15946 build_non_dependent_args (tree args)
15951 new_args = NULL_TREE;
15952 for (a = args; a; a = TREE_CHAIN (a))
15953 new_args = tree_cons (NULL_TREE,
15954 build_non_dependent_expr (TREE_VALUE (a)),
15956 return nreverse (new_args);
15959 #include "gt-cp-pt.h"