1 /* Handle parameterized types (templates) for GNU C++.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2007, 2008 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*, bool);
129 static tree expand_template_argument_pack (tree);
130 static tree build_template_parm_index (int, int, int, tree, tree);
131 static bool inline_needs_template_parms (tree);
132 static void push_inline_template_parms_recursive (tree, int);
133 static tree retrieve_local_specialization (tree);
134 static void register_local_specialization (tree, tree);
135 static tree reduce_template_parm_level (tree, tree, int, tree, tsubst_flags_t);
136 static int mark_template_parm (tree, void *);
137 static int template_parm_this_level_p (tree, void *);
138 static tree tsubst_friend_function (tree, tree);
139 static tree tsubst_friend_class (tree, tree);
140 static int can_complete_type_without_circularity (tree);
141 static tree get_bindings (tree, tree, tree, bool);
142 static int template_decl_level (tree);
143 static int check_cv_quals_for_unify (int, tree, tree);
144 static void template_parm_level_and_index (tree, int*, int*);
145 static int unify_pack_expansion (tree, tree, tree, tree, int, bool, bool);
146 static tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree);
147 static tree tsubst_template_args (tree, tree, tsubst_flags_t, tree);
148 static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
149 static void regenerate_decl_from_template (tree, tree);
150 static tree most_specialized_class (tree, tree);
151 static tree tsubst_aggr_type (tree, tree, tsubst_flags_t, tree, int);
152 static tree tsubst_arg_types (tree, tree, tsubst_flags_t, tree);
153 static tree tsubst_function_type (tree, tree, tsubst_flags_t, tree);
154 static bool check_specialization_scope (void);
155 static tree process_partial_specialization (tree);
156 static void set_current_access_from_decl (tree);
157 static tree get_template_base (tree, tree, tree, tree);
158 static tree try_class_unification (tree, tree, tree, tree);
159 static int coerce_template_template_parms (tree, tree, tsubst_flags_t,
161 static bool template_template_parm_bindings_ok_p (tree, tree);
162 static int template_args_equal (tree, tree);
163 static void tsubst_default_arguments (tree);
164 static tree for_each_template_parm_r (tree *, int *, void *);
165 static tree copy_default_args_to_explicit_spec_1 (tree, tree);
166 static void copy_default_args_to_explicit_spec (tree);
167 static int invalid_nontype_parm_type_p (tree, tsubst_flags_t);
168 static int eq_local_specializations (const void *, const void *);
169 static bool dependent_template_arg_p (tree);
170 static bool any_template_arguments_need_structural_equality_p (tree);
171 static bool dependent_type_p_r (tree);
172 static tree tsubst (tree, tree, tsubst_flags_t, tree);
173 static tree tsubst_expr (tree, tree, tsubst_flags_t, tree, bool);
174 static tree tsubst_copy (tree, tree, tsubst_flags_t, tree);
175 static tree tsubst_pack_expansion (tree, tree, tsubst_flags_t, tree);
177 /* Make the current scope suitable for access checking when we are
178 processing T. T can be FUNCTION_DECL for instantiated function
179 template, or VAR_DECL for static member variable (need by
180 instantiate_decl). */
183 push_access_scope (tree t)
185 gcc_assert (TREE_CODE (t) == FUNCTION_DECL
186 || TREE_CODE (t) == VAR_DECL);
188 if (DECL_FRIEND_CONTEXT (t))
189 push_nested_class (DECL_FRIEND_CONTEXT (t));
190 else if (DECL_CLASS_SCOPE_P (t))
191 push_nested_class (DECL_CONTEXT (t));
193 push_to_top_level ();
195 if (TREE_CODE (t) == FUNCTION_DECL)
197 saved_access_scope = tree_cons
198 (NULL_TREE, current_function_decl, saved_access_scope);
199 current_function_decl = t;
203 /* Restore the scope set up by push_access_scope. T is the node we
207 pop_access_scope (tree t)
209 if (TREE_CODE (t) == FUNCTION_DECL)
211 current_function_decl = TREE_VALUE (saved_access_scope);
212 saved_access_scope = TREE_CHAIN (saved_access_scope);
215 if (DECL_FRIEND_CONTEXT (t) || DECL_CLASS_SCOPE_P (t))
218 pop_from_top_level ();
221 /* Do any processing required when DECL (a member template
222 declaration) is finished. Returns the TEMPLATE_DECL corresponding
223 to DECL, unless it is a specialization, in which case the DECL
224 itself is returned. */
227 finish_member_template_decl (tree decl)
229 if (decl == error_mark_node)
230 return error_mark_node;
232 gcc_assert (DECL_P (decl));
234 if (TREE_CODE (decl) == TYPE_DECL)
238 type = TREE_TYPE (decl);
239 if (type == error_mark_node)
240 return error_mark_node;
241 if (MAYBE_CLASS_TYPE_P (type)
242 && CLASSTYPE_TEMPLATE_INFO (type)
243 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
245 tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
246 check_member_template (tmpl);
251 else if (TREE_CODE (decl) == FIELD_DECL)
252 error ("data member %qD cannot be a member template", decl);
253 else if (DECL_TEMPLATE_INFO (decl))
255 if (!DECL_TEMPLATE_SPECIALIZATION (decl))
257 check_member_template (DECL_TI_TEMPLATE (decl));
258 return DECL_TI_TEMPLATE (decl);
264 error ("invalid member template declaration %qD", decl);
266 return error_mark_node;
269 /* Return the template info node corresponding to T, whatever T is. */
272 get_template_info (tree t)
274 tree tinfo = NULL_TREE;
276 if (DECL_P (t) && DECL_LANG_SPECIFIC (t))
277 tinfo = DECL_TEMPLATE_INFO (t);
279 if (!tinfo && TREE_CODE (t) == TYPE_DECL)
282 if (TAGGED_TYPE_P (t))
283 tinfo = TYPE_TEMPLATE_INFO (t);
288 /* Returns the template nesting level of the indicated class TYPE.
298 A<T>::B<U> has depth two, while A<T> has depth one.
299 Both A<T>::B<int> and A<int>::B<U> have depth one, if
300 they are instantiations, not specializations.
302 This function is guaranteed to return 0 if passed NULL_TREE so
303 that, for example, `template_class_depth (current_class_type)' is
307 template_class_depth (tree type)
312 type && TREE_CODE (type) != NAMESPACE_DECL;
313 type = (TREE_CODE (type) == FUNCTION_DECL)
314 ? CP_DECL_CONTEXT (type) : TYPE_CONTEXT (type))
316 tree tinfo = get_template_info (type);
318 if (tinfo && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo))
319 && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo))))
326 /* Subroutine of maybe_begin_member_template_processing.
327 Returns true if processing DECL needs us to push template parms. */
330 inline_needs_template_parms (tree decl)
332 if (! DECL_TEMPLATE_INFO (decl))
335 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl)))
336 > (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl)));
339 /* Subroutine of maybe_begin_member_template_processing.
340 Push the template parms in PARMS, starting from LEVELS steps into the
341 chain, and ending at the beginning, since template parms are listed
345 push_inline_template_parms_recursive (tree parmlist, int levels)
347 tree parms = TREE_VALUE (parmlist);
351 push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1);
353 ++processing_template_decl;
354 current_template_parms
355 = tree_cons (size_int (processing_template_decl),
356 parms, current_template_parms);
357 TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1;
359 begin_scope (TREE_VEC_LENGTH (parms) ? sk_template_parms : sk_template_spec,
361 for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
363 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
365 if (parm == error_mark_node)
368 gcc_assert (DECL_P (parm));
370 switch (TREE_CODE (parm))
379 /* Make a CONST_DECL as is done in process_template_parm.
380 It is ugly that we recreate this here; the original
381 version built in process_template_parm is no longer
383 tree decl = build_decl (CONST_DECL, DECL_NAME (parm),
385 DECL_ARTIFICIAL (decl) = 1;
386 TREE_CONSTANT (decl) = 1;
387 TREE_INVARIANT (decl) = 1;
388 TREE_READONLY (decl) = 1;
389 DECL_INITIAL (decl) = DECL_INITIAL (parm);
390 SET_DECL_TEMPLATE_PARM_P (decl);
401 /* Restore the template parameter context for a member template or
402 a friend template defined in a class definition. */
405 maybe_begin_member_template_processing (tree decl)
410 if (inline_needs_template_parms (decl))
412 parms = DECL_TEMPLATE_PARMS (most_general_template (decl));
413 levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl;
415 if (DECL_TEMPLATE_SPECIALIZATION (decl))
418 parms = TREE_CHAIN (parms);
421 push_inline_template_parms_recursive (parms, levels);
424 /* Remember how many levels of template parameters we pushed so that
425 we can pop them later. */
426 VEC_safe_push (int, heap, inline_parm_levels, levels);
429 /* Undo the effects of maybe_begin_member_template_processing. */
432 maybe_end_member_template_processing (void)
437 if (VEC_length (int, inline_parm_levels) == 0)
440 last = VEC_pop (int, inline_parm_levels);
441 for (i = 0; i < last; ++i)
443 --processing_template_decl;
444 current_template_parms = TREE_CHAIN (current_template_parms);
449 /* Return a new template argument vector which contains all of ARGS,
450 but has as its innermost set of arguments the EXTRA_ARGS. */
453 add_to_template_args (tree args, tree extra_args)
460 extra_depth = TMPL_ARGS_DEPTH (extra_args);
461 new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth);
463 for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i)
464 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));
466 for (j = 1; j <= extra_depth; ++j, ++i)
467 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));
472 /* Like add_to_template_args, but only the outermost ARGS are added to
473 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
474 (EXTRA_ARGS) levels are added. This function is used to combine
475 the template arguments from a partial instantiation with the
476 template arguments used to attain the full instantiation from the
477 partial instantiation. */
480 add_outermost_template_args (tree args, tree extra_args)
484 /* If there are more levels of EXTRA_ARGS than there are ARGS,
485 something very fishy is going on. */
486 gcc_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args));
488 /* If *all* the new arguments will be the EXTRA_ARGS, just return
490 if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
493 /* For the moment, we make ARGS look like it contains fewer levels. */
494 TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);
496 new_args = add_to_template_args (args, extra_args);
498 /* Now, we restore ARGS to its full dimensions. */
499 TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);
504 /* Return the N levels of innermost template arguments from the ARGS. */
507 get_innermost_template_args (tree args, int n)
515 /* If N is 1, just return the innermost set of template arguments. */
517 return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args));
519 /* If we're not removing anything, just return the arguments we were
521 extra_levels = TMPL_ARGS_DEPTH (args) - n;
522 gcc_assert (extra_levels >= 0);
523 if (extra_levels == 0)
526 /* Make a new set of arguments, not containing the outer arguments. */
527 new_args = make_tree_vec (n);
528 for (i = 1; i <= n; ++i)
529 SET_TMPL_ARGS_LEVEL (new_args, i,
530 TMPL_ARGS_LEVEL (args, i + extra_levels));
535 /* The inverse of get_innermost_template_args: Return all but the innermost
536 EXTRA_LEVELS levels of template arguments from the ARGS. */
539 strip_innermost_template_args (tree args, int extra_levels)
542 int n = TMPL_ARGS_DEPTH (args) - extra_levels;
547 /* If N is 1, just return the outermost set of template arguments. */
549 return TMPL_ARGS_LEVEL (args, 1);
551 /* If we're not removing anything, just return the arguments we were
553 gcc_assert (extra_levels >= 0);
554 if (extra_levels == 0)
557 /* Make a new set of arguments, not containing the inner arguments. */
558 new_args = make_tree_vec (n);
559 for (i = 1; i <= n; ++i)
560 SET_TMPL_ARGS_LEVEL (new_args, i,
561 TMPL_ARGS_LEVEL (args, i));
566 /* We've got a template header coming up; push to a new level for storing
570 begin_template_parm_list (void)
572 /* We use a non-tag-transparent scope here, which causes pushtag to
573 put tags in this scope, rather than in the enclosing class or
574 namespace scope. This is the right thing, since we want
575 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
576 global template class, push_template_decl handles putting the
577 TEMPLATE_DECL into top-level scope. For a nested template class,
580 template <class T> struct S1 {
581 template <class T> struct S2 {};
584 pushtag contains special code to call pushdecl_with_scope on the
585 TEMPLATE_DECL for S2. */
586 begin_scope (sk_template_parms, NULL);
587 ++processing_template_decl;
588 ++processing_template_parmlist;
589 note_template_header (0);
592 /* This routine is called when a specialization is declared. If it is
593 invalid to declare a specialization here, an error is reported and
594 false is returned, otherwise this routine will return true. */
597 check_specialization_scope (void)
599 tree scope = current_scope ();
603 An explicit specialization shall be declared in the namespace of
604 which the template is a member, or, for member templates, in the
605 namespace of which the enclosing class or enclosing class
606 template is a member. An explicit specialization of a member
607 function, member class or static data member of a class template
608 shall be declared in the namespace of which the class template
610 if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
612 error ("explicit specialization in non-namespace scope %qD", scope);
618 In an explicit specialization declaration for a member of a class
619 template or a member template that appears in namespace scope,
620 the member template and some of its enclosing class templates may
621 remain unspecialized, except that the declaration shall not
622 explicitly specialize a class member template if its enclosing
623 class templates are not explicitly specialized as well. */
624 if (current_template_parms)
626 error ("enclosing class templates are not explicitly specialized");
633 /* We've just seen template <>. */
636 begin_specialization (void)
638 begin_scope (sk_template_spec, NULL);
639 note_template_header (1);
640 return check_specialization_scope ();
643 /* Called at then end of processing a declaration preceded by
647 end_specialization (void)
650 reset_specialization ();
653 /* Any template <>'s that we have seen thus far are not referring to a
654 function specialization. */
657 reset_specialization (void)
659 processing_specialization = 0;
660 template_header_count = 0;
663 /* We've just seen a template header. If SPECIALIZATION is nonzero,
664 it was of the form template <>. */
667 note_template_header (int specialization)
669 processing_specialization = specialization;
670 template_header_count++;
673 /* We're beginning an explicit instantiation. */
676 begin_explicit_instantiation (void)
678 gcc_assert (!processing_explicit_instantiation);
679 processing_explicit_instantiation = true;
684 end_explicit_instantiation (void)
686 gcc_assert (processing_explicit_instantiation);
687 processing_explicit_instantiation = false;
690 /* An explicit specialization or partial specialization TMPL is being
691 declared. Check that the namespace in which the specialization is
692 occurring is permissible. Returns false iff it is invalid to
693 specialize TMPL in the current namespace. */
696 check_specialization_namespace (tree tmpl)
698 tree tpl_ns = decl_namespace_context (tmpl);
702 An explicit specialization shall be declared in the namespace of
703 which the template is a member, or, for member templates, in the
704 namespace of which the enclosing class or enclosing class
705 template is a member. An explicit specialization of a member
706 function, member class or static data member of a class template
707 shall be declared in the namespace of which the class template is
709 if (is_associated_namespace (current_namespace, tpl_ns))
710 /* Same or super-using namespace. */
714 pedwarn ("specialization of %qD in different namespace", tmpl);
715 pedwarn (" from definition of %q+#D", tmpl);
720 /* SPEC is an explicit instantiation. Check that it is valid to
721 perform this explicit instantiation in the current namespace. */
724 check_explicit_instantiation_namespace (tree spec)
728 /* DR 275: An explicit instantiation shall appear in an enclosing
729 namespace of its template. */
730 ns = decl_namespace_context (spec);
731 if (!is_ancestor (current_namespace, ns))
732 pedwarn ("explicit instantiation of %qD in namespace %qD "
733 "(which does not enclose namespace %qD)",
734 spec, current_namespace, ns);
737 /* The TYPE is being declared. If it is a template type, that means it
738 is a partial specialization. Do appropriate error-checking. */
741 maybe_process_partial_specialization (tree type)
745 if (type == error_mark_node)
746 return error_mark_node;
748 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
750 error ("name of class shadows template template parameter %qD",
752 return error_mark_node;
755 context = TYPE_CONTEXT (type);
757 if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type))
759 /* This is for ordinary explicit specialization and partial
760 specialization of a template class such as:
762 template <> class C<int>;
766 template <class T> class C<T*>;
768 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
770 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
771 && !COMPLETE_TYPE_P (type))
773 check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type));
774 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
775 if (processing_template_decl)
776 push_template_decl (TYPE_MAIN_DECL (type));
778 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
779 error ("specialization of %qT after instantiation", type);
781 else if (CLASS_TYPE_P (type)
782 && !CLASSTYPE_USE_TEMPLATE (type)
783 && CLASSTYPE_TEMPLATE_INFO (type)
784 && context && CLASS_TYPE_P (context)
785 && CLASSTYPE_TEMPLATE_INFO (context))
787 /* This is for an explicit specialization of member class
788 template according to [temp.expl.spec/18]:
790 template <> template <class U> class C<int>::D;
792 The context `C<int>' must be an implicit instantiation.
793 Otherwise this is just a member class template declared
796 template <> class C<int> { template <class U> class D; };
797 template <> template <class U> class C<int>::D;
799 In the first case, `C<int>::D' is a specialization of `C<T>::D'
800 while in the second case, `C<int>::D' is a primary template
801 and `C<T>::D' may not exist. */
803 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context)
804 && !COMPLETE_TYPE_P (type))
808 if (current_namespace
809 != decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type)))
811 pedwarn ("specializing %q#T in different namespace", type);
812 pedwarn (" from definition of %q+#D",
813 CLASSTYPE_TI_TEMPLATE (type));
816 /* Check for invalid specialization after instantiation:
818 template <> template <> class C<int>::D<int>;
819 template <> template <class U> class C<int>::D; */
821 for (t = DECL_TEMPLATE_INSTANTIATIONS
822 (most_general_template (CLASSTYPE_TI_TEMPLATE (type)));
823 t; t = TREE_CHAIN (t))
824 if (TREE_VALUE (t) != type
825 && TYPE_CONTEXT (TREE_VALUE (t)) == context)
826 error ("specialization %qT after instantiation %qT",
827 type, TREE_VALUE (t));
829 /* Mark TYPE as a specialization. And as a result, we only
830 have one level of template argument for the innermost
832 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
833 CLASSTYPE_TI_ARGS (type)
834 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
837 else if (processing_specialization)
839 error ("explicit specialization of non-template %qT", type);
840 return error_mark_node;
846 /* Returns nonzero if we can optimize the retrieval of specializations
847 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
848 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
851 optimize_specialization_lookup_p (tree tmpl)
853 return (DECL_FUNCTION_TEMPLATE_P (tmpl)
854 && DECL_CLASS_SCOPE_P (tmpl)
855 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
857 && CLASS_TYPE_P (DECL_CONTEXT (tmpl))
858 /* The optimized lookup depends on the fact that the
859 template arguments for the member function template apply
860 purely to the containing class, which is not true if the
861 containing class is an explicit or partial
863 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl))
864 && !DECL_MEMBER_TEMPLATE_P (tmpl)
865 && !DECL_CONV_FN_P (tmpl)
866 /* It is possible to have a template that is not a member
867 template and is not a member of a template class:
869 template <typename T>
870 struct S { friend A::f(); };
872 Here, the friend function is a template, but the context does
873 not have template information. The optimized lookup relies
874 on having ARGS be the template arguments for both the class
875 and the function template. */
876 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl)));
879 /* Retrieve the specialization (in the sense of [temp.spec] - a
880 specialization is either an instantiation or an explicit
881 specialization) of TMPL for the given template ARGS. If there is
882 no such specialization, return NULL_TREE. The ARGS are a vector of
883 arguments, or a vector of vectors of arguments, in the case of
884 templates with more than one level of parameters.
886 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
887 then we search for a partial specialization matching ARGS. This
888 parameter is ignored if TMPL is not a class template. */
891 retrieve_specialization (tree tmpl, tree args,
892 bool class_specializations_p)
894 if (args == error_mark_node)
897 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
899 /* There should be as many levels of arguments as there are
900 levels of parameters. */
901 gcc_assert (TMPL_ARGS_DEPTH (args)
902 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)));
904 if (optimize_specialization_lookup_p (tmpl))
907 tree class_specialization;
908 VEC(tree,gc) *methods;
912 /* The template arguments actually apply to the containing
913 class. Find the class specialization with those
915 class_template = CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl));
917 = retrieve_specialization (class_template, args,
918 /*class_specializations_p=*/false);
919 if (!class_specialization)
921 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
922 for the specialization. */
923 idx = class_method_index_for_fn (class_specialization, tmpl);
926 /* Iterate through the methods with the indicated name, looking
927 for the one that has an instance of TMPL. */
928 methods = CLASSTYPE_METHOD_VEC (class_specialization);
929 for (fns = VEC_index (tree, methods, idx); fns; fns = OVL_NEXT (fns))
931 tree fn = OVL_CURRENT (fns);
932 if (DECL_TEMPLATE_INFO (fn) && DECL_TI_TEMPLATE (fn) == tmpl)
942 /* Class templates store their instantiations on the
943 DECL_TEMPLATE_INSTANTIATIONS list; other templates use the
944 DECL_TEMPLATE_SPECIALIZATIONS list. */
945 if (!class_specializations_p
946 && TREE_CODE (DECL_TEMPLATE_RESULT (tmpl)) == TYPE_DECL
947 && TAGGED_TYPE_P (TREE_TYPE (tmpl)))
948 sp = &DECL_TEMPLATE_INSTANTIATIONS (tmpl);
950 sp = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
952 /* Iterate through the list until we find a matching template. */
953 while (*sp != NULL_TREE)
957 if (comp_template_args (TREE_PURPOSE (spec), args))
959 /* Use the move-to-front heuristic to speed up future
963 *sp = TREE_CHAIN (*sp);
964 TREE_CHAIN (spec) = *head;
967 return TREE_VALUE (spec);
969 sp = &TREE_CHAIN (spec);
976 /* Like retrieve_specialization, but for local declarations. */
979 retrieve_local_specialization (tree tmpl)
983 if (local_specializations == NULL)
986 spec = (tree) htab_find_with_hash (local_specializations, tmpl,
987 htab_hash_pointer (tmpl));
988 return spec ? TREE_PURPOSE (spec) : NULL_TREE;
991 /* Returns nonzero iff DECL is a specialization of TMPL. */
994 is_specialization_of (tree decl, tree tmpl)
998 if (TREE_CODE (decl) == FUNCTION_DECL)
1002 t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
1008 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
1010 for (t = TREE_TYPE (decl);
1012 t = CLASSTYPE_USE_TEMPLATE (t)
1013 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
1014 if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl)))
1021 /* Returns nonzero iff DECL is a specialization of friend declaration
1022 FRIEND according to [temp.friend]. */
1025 is_specialization_of_friend (tree decl, tree friend)
1027 bool need_template = true;
1030 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
1031 || TREE_CODE (decl) == TYPE_DECL);
1033 /* For [temp.friend/6] when FRIEND is an ordinary member function
1034 of a template class, we want to check if DECL is a specialization
1036 if (TREE_CODE (friend) == FUNCTION_DECL
1037 && DECL_TEMPLATE_INFO (friend)
1038 && !DECL_USE_TEMPLATE (friend))
1040 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1041 friend = DECL_TI_TEMPLATE (friend);
1042 need_template = false;
1044 else if (TREE_CODE (friend) == TEMPLATE_DECL
1045 && !PRIMARY_TEMPLATE_P (friend))
1046 need_template = false;
1048 /* There is nothing to do if this is not a template friend. */
1049 if (TREE_CODE (friend) != TEMPLATE_DECL)
1052 if (is_specialization_of (decl, friend))
1056 A member of a class template may be declared to be a friend of a
1057 non-template class. In this case, the corresponding member of
1058 every specialization of the class template is a friend of the
1059 class granting friendship.
1061 For example, given a template friend declaration
1063 template <class T> friend void A<T>::f();
1065 the member function below is considered a friend
1067 template <> struct A<int> {
1071 For this type of template friend, TEMPLATE_DEPTH below will be
1072 nonzero. To determine if DECL is a friend of FRIEND, we first
1073 check if the enclosing class is a specialization of another. */
1075 template_depth = template_class_depth (DECL_CONTEXT (friend));
1077 && DECL_CLASS_SCOPE_P (decl)
1078 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)),
1079 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend))))
1081 /* Next, we check the members themselves. In order to handle
1082 a few tricky cases, such as when FRIEND's are
1084 template <class T> friend void A<T>::g(T t);
1085 template <class T> template <T t> friend void A<T>::h();
1089 void A<int>::g(int);
1090 template <int> void A<int>::h();
1092 we need to figure out ARGS, the template arguments from
1093 the context of DECL. This is required for template substitution
1094 of `T' in the function parameter of `g' and template parameter
1095 of `h' in the above examples. Here ARGS corresponds to `int'. */
1097 tree context = DECL_CONTEXT (decl);
1098 tree args = NULL_TREE;
1099 int current_depth = 0;
1101 while (current_depth < template_depth)
1103 if (CLASSTYPE_TEMPLATE_INFO (context))
1105 if (current_depth == 0)
1106 args = TYPE_TI_ARGS (context);
1108 args = add_to_template_args (TYPE_TI_ARGS (context), args);
1111 context = TYPE_CONTEXT (context);
1114 if (TREE_CODE (decl) == FUNCTION_DECL)
1119 tree friend_args_type;
1120 tree decl_args_type;
1122 /* Make sure that both DECL and FRIEND are templates or
1124 is_template = DECL_TEMPLATE_INFO (decl)
1125 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl));
1126 if (need_template ^ is_template)
1128 else if (is_template)
1130 /* If both are templates, check template parameter list. */
1132 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
1134 if (!comp_template_parms
1135 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)),
1139 decl_type = TREE_TYPE (DECL_TI_TEMPLATE (decl));
1142 decl_type = TREE_TYPE (decl);
1144 friend_type = tsubst_function_type (TREE_TYPE (friend), args,
1145 tf_none, NULL_TREE);
1146 if (friend_type == error_mark_node)
1149 /* Check if return types match. */
1150 if (!same_type_p (TREE_TYPE (decl_type), TREE_TYPE (friend_type)))
1153 /* Check if function parameter types match, ignoring the
1154 `this' parameter. */
1155 friend_args_type = TYPE_ARG_TYPES (friend_type);
1156 decl_args_type = TYPE_ARG_TYPES (decl_type);
1157 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend))
1158 friend_args_type = TREE_CHAIN (friend_args_type);
1159 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1160 decl_args_type = TREE_CHAIN (decl_args_type);
1162 return compparms (decl_args_type, friend_args_type);
1166 /* DECL is a TYPE_DECL */
1168 tree decl_type = TREE_TYPE (decl);
1170 /* Make sure that both DECL and FRIEND are templates or
1173 = CLASSTYPE_TEMPLATE_INFO (decl_type)
1174 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type));
1176 if (need_template ^ is_template)
1178 else if (is_template)
1181 /* If both are templates, check the name of the two
1182 TEMPLATE_DECL's first because is_friend didn't. */
1183 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type))
1184 != DECL_NAME (friend))
1187 /* Now check template parameter list. */
1189 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
1191 return comp_template_parms
1192 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type)),
1196 return (DECL_NAME (decl)
1197 == DECL_NAME (friend));
1203 /* Register the specialization SPEC as a specialization of TMPL with
1204 the indicated ARGS. IS_FRIEND indicates whether the specialization
1205 is actually just a friend declaration. Returns SPEC, or an
1206 equivalent prior declaration, if available. */
1209 register_specialization (tree spec, tree tmpl, tree args, bool is_friend)
1213 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
1215 if (TREE_CODE (spec) == FUNCTION_DECL
1216 && uses_template_parms (DECL_TI_ARGS (spec)))
1217 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1218 register it; we want the corresponding TEMPLATE_DECL instead.
1219 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1220 the more obvious `uses_template_parms (spec)' to avoid problems
1221 with default function arguments. In particular, given
1222 something like this:
1224 template <class T> void f(T t1, T t = T())
1226 the default argument expression is not substituted for in an
1227 instantiation unless and until it is actually needed. */
1230 fn = retrieve_specialization (tmpl, args,
1231 /*class_specializations_p=*/false);
1232 /* We can sometimes try to re-register a specialization that we've
1233 already got. In particular, regenerate_decl_from_template calls
1234 duplicate_decls which will update the specialization list. But,
1235 we'll still get called again here anyhow. It's more convenient
1236 to simply allow this than to try to prevent it. */
1239 else if (fn && DECL_TEMPLATE_SPECIALIZATION (spec))
1241 if (DECL_TEMPLATE_INSTANTIATION (fn))
1244 || DECL_EXPLICIT_INSTANTIATION (fn))
1246 error ("specialization of %qD after instantiation",
1248 return error_mark_node;
1253 /* This situation should occur only if the first
1254 specialization is an implicit instantiation, the
1255 second is an explicit specialization, and the
1256 implicit instantiation has not yet been used. That
1257 situation can occur if we have implicitly
1258 instantiated a member function and then specialized
1261 We can also wind up here if a friend declaration that
1262 looked like an instantiation turns out to be a
1265 template <class T> void foo(T);
1266 class S { friend void foo<>(int) };
1267 template <> void foo(int);
1269 We transform the existing DECL in place so that any
1270 pointers to it become pointers to the updated
1273 If there was a definition for the template, but not
1274 for the specialization, we want this to look as if
1275 there were no definition, and vice versa. */
1276 DECL_INITIAL (fn) = NULL_TREE;
1277 duplicate_decls (spec, fn, is_friend);
1278 /* The call to duplicate_decls will have applied
1281 An explicit specialization of a function template
1282 is inline only if it is explicitly declared to be,
1283 and independently of whether its function template
1286 to the primary function; now copy the inline bits to
1287 the various clones. */
1288 FOR_EACH_CLONE (clone, fn)
1290 DECL_DECLARED_INLINE_P (clone)
1291 = DECL_DECLARED_INLINE_P (fn);
1295 check_specialization_namespace (fn);
1300 else if (DECL_TEMPLATE_SPECIALIZATION (fn))
1302 if (!duplicate_decls (spec, fn, is_friend) && DECL_INITIAL (spec))
1303 /* Dup decl failed, but this is a new definition. Set the
1304 line number so any errors match this new
1306 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec);
1312 /* A specialization must be declared in the same namespace as the
1313 template it is specializing. */
1314 if (DECL_TEMPLATE_SPECIALIZATION (spec)
1315 && !check_specialization_namespace (tmpl))
1316 DECL_CONTEXT (spec) = FROB_CONTEXT (decl_namespace_context (tmpl));
1318 if (!optimize_specialization_lookup_p (tmpl))
1319 DECL_TEMPLATE_SPECIALIZATIONS (tmpl)
1320 = tree_cons (args, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl));
1325 /* Unregister the specialization SPEC as a specialization of TMPL.
1326 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1327 if the SPEC was listed as a specialization of TMPL. */
1330 reregister_specialization (tree spec, tree tmpl, tree new_spec)
1334 for (s = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
1336 s = &TREE_CHAIN (*s))
1337 if (TREE_VALUE (*s) == spec)
1340 *s = TREE_CHAIN (*s);
1342 TREE_VALUE (*s) = new_spec;
1349 /* Compare an entry in the local specializations hash table P1 (which
1350 is really a pointer to a TREE_LIST) with P2 (which is really a
1354 eq_local_specializations (const void *p1, const void *p2)
1356 return TREE_VALUE ((const_tree) p1) == (const_tree) p2;
1359 /* Hash P1, an entry in the local specializations table. */
1362 hash_local_specialization (const void* p1)
1364 return htab_hash_pointer (TREE_VALUE ((const_tree) p1));
1367 /* Like register_specialization, but for local declarations. We are
1368 registering SPEC, an instantiation of TMPL. */
1371 register_local_specialization (tree spec, tree tmpl)
1375 slot = htab_find_slot_with_hash (local_specializations, tmpl,
1376 htab_hash_pointer (tmpl), INSERT);
1377 *slot = build_tree_list (spec, tmpl);
1380 /* TYPE is a class type. Returns true if TYPE is an explicitly
1381 specialized class. */
1384 explicit_class_specialization_p (tree type)
1386 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
1388 return !uses_template_parms (CLASSTYPE_TI_ARGS (type));
1391 /* Print the list of candidate FNS in an error message. */
1394 print_candidates (tree fns)
1398 const char *str = "candidates are:";
1400 for (fn = fns; fn != NULL_TREE; fn = TREE_CHAIN (fn))
1404 for (f = TREE_VALUE (fn); f; f = OVL_NEXT (f))
1405 error ("%s %+#D", str, OVL_CURRENT (f));
1410 /* Returns the template (one of the functions given by TEMPLATE_ID)
1411 which can be specialized to match the indicated DECL with the
1412 explicit template args given in TEMPLATE_ID. The DECL may be
1413 NULL_TREE if none is available. In that case, the functions in
1414 TEMPLATE_ID are non-members.
1416 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1417 specialization of a member template.
1419 The TEMPLATE_COUNT is the number of references to qualifying
1420 template classes that appeared in the name of the function. See
1421 check_explicit_specialization for a more accurate description.
1423 TSK indicates what kind of template declaration (if any) is being
1424 declared. TSK_TEMPLATE indicates that the declaration given by
1425 DECL, though a FUNCTION_DECL, has template parameters, and is
1426 therefore a template function.
1428 The template args (those explicitly specified and those deduced)
1429 are output in a newly created vector *TARGS_OUT.
1431 If it is impossible to determine the result, an error message is
1432 issued. The error_mark_node is returned to indicate failure. */
1435 determine_specialization (tree template_id,
1438 int need_member_template,
1444 tree explicit_targs;
1445 tree candidates = NULL_TREE;
1446 /* A TREE_LIST of templates of which DECL may be a specialization.
1447 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1448 corresponding TREE_PURPOSE is the set of template arguments that,
1449 when used to instantiate the template, would produce a function
1450 with the signature of DECL. */
1451 tree templates = NULL_TREE;
1453 struct cp_binding_level *b;
1455 *targs_out = NULL_TREE;
1457 if (template_id == error_mark_node || decl == error_mark_node)
1458 return error_mark_node;
1460 fns = TREE_OPERAND (template_id, 0);
1461 explicit_targs = TREE_OPERAND (template_id, 1);
1463 if (fns == error_mark_node)
1464 return error_mark_node;
1466 /* Check for baselinks. */
1467 if (BASELINK_P (fns))
1468 fns = BASELINK_FUNCTIONS (fns);
1470 if (!is_overloaded_fn (fns))
1472 error ("%qD is not a function template", fns);
1473 return error_mark_node;
1476 /* Count the number of template headers specified for this
1479 for (b = current_binding_level;
1480 b->kind == sk_template_parms;
1484 for (; fns; fns = OVL_NEXT (fns))
1486 tree fn = OVL_CURRENT (fns);
1488 if (TREE_CODE (fn) == TEMPLATE_DECL)
1490 tree decl_arg_types;
1493 /* In case of explicit specialization, we need to check if
1494 the number of template headers appearing in the specialization
1495 is correct. This is usually done in check_explicit_specialization,
1496 but the check done there cannot be exhaustive when specializing
1497 member functions. Consider the following code:
1499 template <> void A<int>::f(int);
1500 template <> template <> void A<int>::f(int);
1502 Assuming that A<int> is not itself an explicit specialization
1503 already, the first line specializes "f" which is a non-template
1504 member function, whilst the second line specializes "f" which
1505 is a template member function. So both lines are syntactically
1506 correct, and check_explicit_specialization does not reject
1509 Here, we can do better, as we are matching the specialization
1510 against the declarations. We count the number of template
1511 headers, and we check if they match TEMPLATE_COUNT + 1
1512 (TEMPLATE_COUNT is the number of qualifying template classes,
1513 plus there must be another header for the member template
1516 Notice that if header_count is zero, this is not a
1517 specialization but rather a template instantiation, so there
1518 is no check we can perform here. */
1519 if (header_count && header_count != template_count + 1)
1522 /* Check that the number of template arguments at the
1523 innermost level for DECL is the same as for FN. */
1524 if (current_binding_level->kind == sk_template_parms
1525 && !current_binding_level->explicit_spec_p
1526 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn))
1527 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
1528 (current_template_parms))))
1531 /* DECL might be a specialization of FN. */
1532 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1533 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
1535 /* For a non-static member function, we need to make sure
1536 that the const qualification is the same. Since
1537 get_bindings does not try to merge the "this" parameter,
1538 we must do the comparison explicitly. */
1539 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1540 && !same_type_p (TREE_VALUE (fn_arg_types),
1541 TREE_VALUE (decl_arg_types)))
1544 /* Skip the "this" parameter and, for constructors of
1545 classes with virtual bases, the VTT parameter. A
1546 full specialization of a constructor will have a VTT
1547 parameter, but a template never will. */
1549 = skip_artificial_parms_for (decl, decl_arg_types);
1551 = skip_artificial_parms_for (fn, fn_arg_types);
1553 /* Check that the number of function parameters matches.
1555 template <class T> void f(int i = 0);
1556 template <> void f<int>();
1557 The specialization f<int> is invalid but is not caught
1558 by get_bindings below. */
1559 if (list_length (fn_arg_types) != list_length (decl_arg_types))
1562 /* Function templates cannot be specializations; there are
1563 no partial specializations of functions. Therefore, if
1564 the type of DECL does not match FN, there is no
1566 if (tsk == tsk_template)
1568 if (compparms (fn_arg_types, decl_arg_types))
1569 candidates = tree_cons (NULL_TREE, fn, candidates);
1573 /* See whether this function might be a specialization of this
1575 targs = get_bindings (fn, decl, explicit_targs, /*check_ret=*/true);
1578 /* We cannot deduce template arguments that when used to
1579 specialize TMPL will produce DECL. */
1582 /* Save this template, and the arguments deduced. */
1583 templates = tree_cons (targs, fn, templates);
1585 else if (need_member_template)
1586 /* FN is an ordinary member function, and we need a
1587 specialization of a member template. */
1589 else if (TREE_CODE (fn) != FUNCTION_DECL)
1590 /* We can get IDENTIFIER_NODEs here in certain erroneous
1593 else if (!DECL_FUNCTION_MEMBER_P (fn))
1594 /* This is just an ordinary non-member function. Nothing can
1595 be a specialization of that. */
1597 else if (DECL_ARTIFICIAL (fn))
1598 /* Cannot specialize functions that are created implicitly. */
1602 tree decl_arg_types;
1604 /* This is an ordinary member function. However, since
1605 we're here, we can assume it's enclosing class is a
1606 template class. For example,
1608 template <typename T> struct S { void f(); };
1609 template <> void S<int>::f() {}
1611 Here, S<int>::f is a non-template, but S<int> is a
1612 template class. If FN has the same type as DECL, we
1613 might be in business. */
1615 if (!DECL_TEMPLATE_INFO (fn))
1616 /* Its enclosing class is an explicit specialization
1617 of a template class. This is not a candidate. */
1620 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
1621 TREE_TYPE (TREE_TYPE (fn))))
1622 /* The return types differ. */
1625 /* Adjust the type of DECL in case FN is a static member. */
1626 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1627 if (DECL_STATIC_FUNCTION_P (fn)
1628 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1629 decl_arg_types = TREE_CHAIN (decl_arg_types);
1631 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1634 candidates = tree_cons (NULL_TREE, fn, candidates);
1638 if (templates && TREE_CHAIN (templates))
1644 It is possible for a specialization with a given function
1645 signature to be instantiated from more than one function
1646 template. In such cases, explicit specification of the
1647 template arguments must be used to uniquely identify the
1648 function template specialization being specialized.
1650 Note that here, there's no suggestion that we're supposed to
1651 determine which of the candidate templates is most
1652 specialized. However, we, also have:
1656 Partial ordering of overloaded function template
1657 declarations is used in the following contexts to select
1658 the function template to which a function template
1659 specialization refers:
1661 -- when an explicit specialization refers to a function
1664 So, we do use the partial ordering rules, at least for now.
1665 This extension can only serve to make invalid programs valid,
1666 so it's safe. And, there is strong anecdotal evidence that
1667 the committee intended the partial ordering rules to apply;
1668 the EDG front end has that behavior, and John Spicer claims
1669 that the committee simply forgot to delete the wording in
1670 [temp.expl.spec]. */
1671 tree tmpl = most_specialized_instantiation (templates);
1672 if (tmpl != error_mark_node)
1675 TREE_CHAIN (templates) = NULL_TREE;
1679 if (templates == NULL_TREE && candidates == NULL_TREE)
1681 error ("template-id %qD for %q+D does not match any template "
1682 "declaration", template_id, decl);
1683 return error_mark_node;
1685 else if ((templates && TREE_CHAIN (templates))
1686 || (candidates && TREE_CHAIN (candidates))
1687 || (templates && candidates))
1689 error ("ambiguous template specialization %qD for %q+D",
1691 chainon (candidates, templates);
1692 print_candidates (candidates);
1693 return error_mark_node;
1696 /* We have one, and exactly one, match. */
1699 tree fn = TREE_VALUE (candidates);
1700 /* DECL is a re-declaration of a template function. */
1701 if (TREE_CODE (fn) == TEMPLATE_DECL)
1703 /* It was a specialization of an ordinary member function in a
1705 *targs_out = copy_node (DECL_TI_ARGS (fn));
1706 return DECL_TI_TEMPLATE (fn);
1709 /* It was a specialization of a template. */
1710 targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates)));
1711 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs))
1713 *targs_out = copy_node (targs);
1714 SET_TMPL_ARGS_LEVEL (*targs_out,
1715 TMPL_ARGS_DEPTH (*targs_out),
1716 TREE_PURPOSE (templates));
1719 *targs_out = TREE_PURPOSE (templates);
1720 return TREE_VALUE (templates);
1723 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
1724 but with the default argument values filled in from those in the
1728 copy_default_args_to_explicit_spec_1 (tree spec_types,
1731 tree new_spec_types;
1736 if (spec_types == void_list_node)
1737 return void_list_node;
1739 /* Substitute into the rest of the list. */
1741 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
1742 TREE_CHAIN (tmpl_types));
1744 /* Add the default argument for this parameter. */
1745 return hash_tree_cons (TREE_PURPOSE (tmpl_types),
1746 TREE_VALUE (spec_types),
1750 /* DECL is an explicit specialization. Replicate default arguments
1751 from the template it specializes. (That way, code like:
1753 template <class T> void f(T = 3);
1754 template <> void f(double);
1757 works, as required.) An alternative approach would be to look up
1758 the correct default arguments at the call-site, but this approach
1759 is consistent with how implicit instantiations are handled. */
1762 copy_default_args_to_explicit_spec (tree decl)
1767 tree new_spec_types;
1771 tree object_type = NULL_TREE;
1772 tree in_charge = NULL_TREE;
1773 tree vtt = NULL_TREE;
1775 /* See if there's anything we need to do. */
1776 tmpl = DECL_TI_TEMPLATE (decl);
1777 tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
1778 for (t = tmpl_types; t; t = TREE_CHAIN (t))
1779 if (TREE_PURPOSE (t))
1784 old_type = TREE_TYPE (decl);
1785 spec_types = TYPE_ARG_TYPES (old_type);
1787 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1789 /* Remove the this pointer, but remember the object's type for
1791 object_type = TREE_TYPE (TREE_VALUE (spec_types));
1792 spec_types = TREE_CHAIN (spec_types);
1793 tmpl_types = TREE_CHAIN (tmpl_types);
1795 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
1797 /* DECL may contain more parameters than TMPL due to the extra
1798 in-charge parameter in constructors and destructors. */
1799 in_charge = spec_types;
1800 spec_types = TREE_CHAIN (spec_types);
1802 if (DECL_HAS_VTT_PARM_P (decl))
1805 spec_types = TREE_CHAIN (spec_types);
1809 /* Compute the merged default arguments. */
1811 copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);
1813 /* Compute the new FUNCTION_TYPE. */
1817 new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt),
1822 /* Put the in-charge parameter back. */
1823 new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
1824 TREE_VALUE (in_charge),
1827 new_type = build_method_type_directly (object_type,
1828 TREE_TYPE (old_type),
1832 new_type = build_function_type (TREE_TYPE (old_type),
1834 new_type = cp_build_type_attribute_variant (new_type,
1835 TYPE_ATTRIBUTES (old_type));
1836 new_type = build_exception_variant (new_type,
1837 TYPE_RAISES_EXCEPTIONS (old_type));
1838 TREE_TYPE (decl) = new_type;
1841 /* Check to see if the function just declared, as indicated in
1842 DECLARATOR, and in DECL, is a specialization of a function
1843 template. We may also discover that the declaration is an explicit
1844 instantiation at this point.
1846 Returns DECL, or an equivalent declaration that should be used
1847 instead if all goes well. Issues an error message if something is
1848 amiss. Returns error_mark_node if the error is not easily
1851 FLAGS is a bitmask consisting of the following flags:
1853 2: The function has a definition.
1854 4: The function is a friend.
1856 The TEMPLATE_COUNT is the number of references to qualifying
1857 template classes that appeared in the name of the function. For
1860 template <class T> struct S { void f(); };
1863 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1864 classes are not counted in the TEMPLATE_COUNT, so that in
1866 template <class T> struct S {};
1867 template <> struct S<int> { void f(); }
1868 template <> void S<int>::f();
1870 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1871 invalid; there should be no template <>.)
1873 If the function is a specialization, it is marked as such via
1874 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1875 is set up correctly, and it is added to the list of specializations
1876 for that template. */
1879 check_explicit_specialization (tree declarator,
1884 int have_def = flags & 2;
1885 int is_friend = flags & 4;
1886 int specialization = 0;
1887 int explicit_instantiation = 0;
1888 int member_specialization = 0;
1889 tree ctype = DECL_CLASS_CONTEXT (decl);
1890 tree dname = DECL_NAME (decl);
1895 if (!processing_specialization)
1898 tsk = tsk_excessive_parms;
1901 tsk = current_tmpl_spec_kind (template_count);
1906 if (processing_specialization)
1909 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1911 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1914 /* This could be something like:
1916 template <class T> void f(T);
1917 class S { friend void f<>(int); } */
1921 /* This case handles bogus declarations like template <>
1922 template <class T> void f<int>(); */
1924 error ("template-id %qD in declaration of primary template",
1931 case tsk_invalid_member_spec:
1932 /* The error has already been reported in
1933 check_specialization_scope. */
1934 return error_mark_node;
1936 case tsk_invalid_expl_inst:
1937 error ("template parameter list used in explicit instantiation");
1943 error ("definition provided for explicit instantiation");
1945 explicit_instantiation = 1;
1948 case tsk_excessive_parms:
1949 case tsk_insufficient_parms:
1950 if (tsk == tsk_excessive_parms)
1951 error ("too many template parameter lists in declaration of %qD",
1953 else if (template_header_count)
1954 error("too few template parameter lists in declaration of %qD", decl);
1956 error("explicit specialization of %qD must be introduced by "
1957 "%<template <>%>", decl);
1961 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1963 member_specialization = 1;
1969 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1971 /* This case handles bogus declarations like template <>
1972 template <class T> void f<int>(); */
1974 if (uses_template_parms (declarator))
1975 error ("function template partial specialization %qD "
1976 "is not allowed", declarator);
1978 error ("template-id %qD in declaration of primary template",
1983 if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
1984 /* This is a specialization of a member template, without
1985 specialization the containing class. Something like:
1987 template <class T> struct S {
1988 template <class U> void f (U);
1990 template <> template <class U> void S<int>::f(U) {}
1992 That's a specialization -- but of the entire template. */
2000 if (specialization || member_specialization)
2002 tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
2003 for (; t; t = TREE_CHAIN (t))
2004 if (TREE_PURPOSE (t))
2007 ("default argument specified in explicit specialization");
2012 if (specialization || member_specialization || explicit_instantiation)
2014 tree tmpl = NULL_TREE;
2015 tree targs = NULL_TREE;
2017 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2018 if (TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
2022 gcc_assert (TREE_CODE (declarator) == IDENTIFIER_NODE);
2027 /* If there is no class context, the explicit instantiation
2028 must be at namespace scope. */
2029 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl));
2031 /* Find the namespace binding, using the declaration
2033 fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
2035 if (fns == error_mark_node || !is_overloaded_fn (fns))
2037 error ("%qD is not a template function", dname);
2038 fns = error_mark_node;
2042 tree fn = OVL_CURRENT (fns);
2043 if (!is_associated_namespace (CP_DECL_CONTEXT (decl),
2044 CP_DECL_CONTEXT (fn)))
2045 error ("%qD is not declared in %qD",
2046 decl, current_namespace);
2050 declarator = lookup_template_function (fns, NULL_TREE);
2053 if (declarator == error_mark_node)
2054 return error_mark_node;
2056 if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
2058 if (!explicit_instantiation)
2059 /* A specialization in class scope. This is invalid,
2060 but the error will already have been flagged by
2061 check_specialization_scope. */
2062 return error_mark_node;
2065 /* It's not valid to write an explicit instantiation in
2068 class C { template void f(); }
2070 This case is caught by the parser. However, on
2073 template class C { void f(); };
2075 (which is invalid) we can get here. The error will be
2082 else if (ctype != NULL_TREE
2083 && (TREE_CODE (TREE_OPERAND (declarator, 0)) ==
2086 /* Find the list of functions in ctype that have the same
2087 name as the declared function. */
2088 tree name = TREE_OPERAND (declarator, 0);
2089 tree fns = NULL_TREE;
2092 if (constructor_name_p (name, ctype))
2094 int is_constructor = DECL_CONSTRUCTOR_P (decl);
2096 if (is_constructor ? !TYPE_HAS_USER_CONSTRUCTOR (ctype)
2097 : !CLASSTYPE_DESTRUCTORS (ctype))
2099 /* From [temp.expl.spec]:
2101 If such an explicit specialization for the member
2102 of a class template names an implicitly-declared
2103 special member function (clause _special_), the
2104 program is ill-formed.
2106 Similar language is found in [temp.explicit]. */
2107 error ("specialization of implicitly-declared special member function");
2108 return error_mark_node;
2111 name = is_constructor ? ctor_identifier : dtor_identifier;
2114 if (!DECL_CONV_FN_P (decl))
2116 idx = lookup_fnfields_1 (ctype, name);
2118 fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (ctype), idx);
2122 VEC(tree,gc) *methods;
2125 /* For a type-conversion operator, we cannot do a
2126 name-based lookup. We might be looking for `operator
2127 int' which will be a specialization of `operator T'.
2128 So, we find *all* the conversion operators, and then
2129 select from them. */
2132 methods = CLASSTYPE_METHOD_VEC (ctype);
2134 for (idx = CLASSTYPE_FIRST_CONVERSION_SLOT;
2135 VEC_iterate (tree, methods, idx, ovl);
2138 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl)))
2139 /* There are no more conversion functions. */
2142 /* Glue all these conversion functions together
2143 with those we already have. */
2144 for (; ovl; ovl = OVL_NEXT (ovl))
2145 fns = ovl_cons (OVL_CURRENT (ovl), fns);
2149 if (fns == NULL_TREE)
2151 error ("no member function %qD declared in %qT", name, ctype);
2152 return error_mark_node;
2155 TREE_OPERAND (declarator, 0) = fns;
2158 /* Figure out what exactly is being specialized at this point.
2159 Note that for an explicit instantiation, even one for a
2160 member function, we cannot tell apriori whether the
2161 instantiation is for a member template, or just a member
2162 function of a template class. Even if a member template is
2163 being instantiated, the member template arguments may be
2164 elided if they can be deduced from the rest of the
2166 tmpl = determine_specialization (declarator, decl,
2168 member_specialization,
2172 if (!tmpl || tmpl == error_mark_node)
2173 /* We couldn't figure out what this declaration was
2175 return error_mark_node;
2178 tree gen_tmpl = most_general_template (tmpl);
2180 if (explicit_instantiation)
2182 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2183 is done by do_decl_instantiation later. */
2185 int arg_depth = TMPL_ARGS_DEPTH (targs);
2186 int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
2188 if (arg_depth > parm_depth)
2190 /* If TMPL is not the most general template (for
2191 example, if TMPL is a friend template that is
2192 injected into namespace scope), then there will
2193 be too many levels of TARGS. Remove some of them
2198 new_targs = make_tree_vec (parm_depth);
2199 for (i = arg_depth - parm_depth; i < arg_depth; ++i)
2200 TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
2201 = TREE_VEC_ELT (targs, i);
2205 return instantiate_template (tmpl, targs, tf_error);
2208 /* If we thought that the DECL was a member function, but it
2209 turns out to be specializing a static member function,
2210 make DECL a static member function as well. */
2211 if (DECL_STATIC_FUNCTION_P (tmpl)
2212 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2213 revert_static_member_fn (decl);
2215 /* If this is a specialization of a member template of a
2216 template class, we want to return the TEMPLATE_DECL, not
2217 the specialization of it. */
2218 if (tsk == tsk_template)
2220 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
2221 DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl)) = NULL_TREE;
2224 DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
2225 DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (tmpl))
2226 = DECL_SOURCE_LOCATION (decl);
2227 /* We want to use the argument list specified in the
2228 definition, not in the original declaration. */
2229 DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (tmpl))
2230 = DECL_ARGUMENTS (decl);
2235 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2236 DECL_TEMPLATE_INFO (decl) = tree_cons (tmpl, targs, NULL_TREE);
2238 /* Inherit default function arguments from the template
2239 DECL is specializing. */
2240 copy_default_args_to_explicit_spec (decl);
2242 /* This specialization has the same protection as the
2243 template it specializes. */
2244 TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
2245 TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
2247 /* 7.1.1-1 [dcl.stc]
2249 A storage-class-specifier shall not be specified in an
2250 explicit specialization...
2252 The parser rejects these, so unless action is taken here,
2253 explicit function specializations will always appear with
2256 The action recommended by the C++ CWG in response to C++
2257 defect report 605 is to make the storage class and linkage
2258 of the explicit specialization match the templated function:
2260 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2262 if (tsk == tsk_expl_spec && DECL_FUNCTION_TEMPLATE_P (gen_tmpl))
2264 tree tmpl_func = DECL_TEMPLATE_RESULT (gen_tmpl);
2265 gcc_assert (TREE_CODE (tmpl_func) == FUNCTION_DECL);
2267 /* This specialization has the same linkage and visibility as
2268 the function template it specializes. */
2269 TREE_PUBLIC (decl) = TREE_PUBLIC (tmpl_func);
2270 if (! TREE_PUBLIC (decl))
2272 DECL_INTERFACE_KNOWN (decl) = 1;
2273 DECL_NOT_REALLY_EXTERN (decl) = 1;
2275 DECL_THIS_STATIC (decl) = DECL_THIS_STATIC (tmpl_func);
2276 if (DECL_VISIBILITY_SPECIFIED (tmpl_func))
2278 DECL_VISIBILITY_SPECIFIED (decl) = 1;
2279 DECL_VISIBILITY (decl) = DECL_VISIBILITY (tmpl_func);
2283 /* If DECL is a friend declaration, declared using an
2284 unqualified name, the namespace associated with DECL may
2285 have been set incorrectly. For example, in:
2287 template <typename T> void f(T);
2289 struct S { friend void f<int>(int); }
2292 we will have set the DECL_CONTEXT for the friend
2293 declaration to N, rather than to the global namespace. */
2294 if (DECL_NAMESPACE_SCOPE_P (decl))
2295 DECL_CONTEXT (decl) = DECL_CONTEXT (tmpl);
2297 if (is_friend && !have_def)
2298 /* This is not really a declaration of a specialization.
2299 It's just the name of an instantiation. But, it's not
2300 a request for an instantiation, either. */
2301 SET_DECL_IMPLICIT_INSTANTIATION (decl);
2302 else if (DECL_CONSTRUCTOR_P (decl) || DECL_DESTRUCTOR_P (decl))
2303 /* This is indeed a specialization. In case of constructors
2304 and destructors, we need in-charge and not-in-charge
2305 versions in V3 ABI. */
2306 clone_function_decl (decl, /*update_method_vec_p=*/0);
2308 /* Register this specialization so that we can find it
2310 decl = register_specialization (decl, gen_tmpl, targs, is_friend);
2317 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2318 parameters. These are represented in the same format used for
2319 DECL_TEMPLATE_PARMS. */
2322 comp_template_parms (const_tree parms1, const_tree parms2)
2327 if (parms1 == parms2)
2330 for (p1 = parms1, p2 = parms2;
2331 p1 != NULL_TREE && p2 != NULL_TREE;
2332 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2))
2334 tree t1 = TREE_VALUE (p1);
2335 tree t2 = TREE_VALUE (p2);
2338 gcc_assert (TREE_CODE (t1) == TREE_VEC);
2339 gcc_assert (TREE_CODE (t2) == TREE_VEC);
2341 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
2344 for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
2346 tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
2347 tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
2349 /* If either of the template parameters are invalid, assume
2350 they match for the sake of error recovery. */
2351 if (parm1 == error_mark_node || parm2 == error_mark_node)
2354 if (TREE_CODE (parm1) != TREE_CODE (parm2))
2357 if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM
2358 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1)
2359 == TEMPLATE_TYPE_PARAMETER_PACK (parm2)))
2361 else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
2366 if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
2367 /* One set of parameters has more parameters lists than the
2374 /* Determine whether PARM is a parameter pack. */
2376 template_parameter_pack_p (const_tree parm)
2378 /* Determine if we have a non-type template parameter pack. */
2379 if (TREE_CODE (parm) == PARM_DECL)
2380 return (DECL_TEMPLATE_PARM_P (parm)
2381 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)));
2383 /* If this is a list of template parameters, we could get a
2384 TYPE_DECL or a TEMPLATE_DECL. */
2385 if (TREE_CODE (parm) == TYPE_DECL || TREE_CODE (parm) == TEMPLATE_DECL)
2386 parm = TREE_TYPE (parm);
2388 return ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
2389 || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM)
2390 && TEMPLATE_TYPE_PARAMETER_PACK (parm));
2393 /* Determine whether ARGS describes a variadic template args list,
2394 i.e., one that is terminated by a template argument pack. */
2396 template_args_variadic_p (tree args)
2401 if (args == NULL_TREE)
2404 args = INNERMOST_TEMPLATE_ARGS (args);
2405 nargs = TREE_VEC_LENGTH (args);
2410 last_parm = TREE_VEC_ELT (args, nargs - 1);
2412 return ARGUMENT_PACK_P (last_parm);
2415 /* Generate a new name for the parameter pack name NAME (an
2416 IDENTIFIER_NODE) that incorporates its */
2418 make_ith_pack_parameter_name (tree name, int i)
2420 /* Munge the name to include the parameter index. */
2424 sprintf(numbuf, "%i", i);
2425 newname = (char*)alloca (IDENTIFIER_LENGTH (name) + strlen(numbuf) + 2);
2426 sprintf(newname, "%s#%i", IDENTIFIER_POINTER (name), i);
2427 return get_identifier (newname);
2430 /* Structure used to track the progress of find_parameter_packs_r. */
2431 struct find_parameter_pack_data
2433 /* TREE_LIST that will contain all of the parameter packs found by
2435 tree* parameter_packs;
2437 /* Set of AST nodes that have been visited by the traversal. */
2438 struct pointer_set_t *visited;
2441 /* Identifies all of the argument packs that occur in a template
2442 argument and appends them to the TREE_LIST inside DATA, which is a
2443 find_parameter_pack_data structure. This is a subroutine of
2444 make_pack_expansion and uses_parameter_packs. */
2446 find_parameter_packs_r (tree *tp, int *walk_subtrees, void* data)
2449 struct find_parameter_pack_data* ppd =
2450 (struct find_parameter_pack_data*)data;
2451 bool parameter_pack_p = false;
2453 /* Identify whether this is a parameter pack or not. */
2454 switch (TREE_CODE (t))
2456 case TEMPLATE_PARM_INDEX:
2457 if (TEMPLATE_PARM_PARAMETER_PACK (t))
2458 parameter_pack_p = true;
2461 case TEMPLATE_TYPE_PARM:
2462 case TEMPLATE_TEMPLATE_PARM:
2463 if (TEMPLATE_TYPE_PARAMETER_PACK (t))
2464 parameter_pack_p = true;
2468 if (FUNCTION_PARAMETER_PACK_P (t))
2470 /* We don't want to walk into the type of a PARM_DECL,
2471 because we don't want to see the type parameter pack. */
2473 parameter_pack_p = true;
2478 /* Not a parameter pack. */
2482 if (parameter_pack_p)
2484 /* Add this parameter pack to the list. */
2485 *ppd->parameter_packs = tree_cons (NULL_TREE, t, *ppd->parameter_packs);
2489 cp_walk_tree (&TYPE_CONTEXT (t),
2490 &find_parameter_packs_r, ppd, ppd->visited);
2492 /* This switch statement will return immediately if we don't find a
2494 switch (TREE_CODE (t))
2496 case TEMPLATE_PARM_INDEX:
2499 case BOUND_TEMPLATE_TEMPLATE_PARM:
2500 /* Check the template itself. */
2501 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t)),
2502 &find_parameter_packs_r, ppd, ppd->visited);
2503 /* Check the template arguments. */
2504 cp_walk_tree (&TYPE_TI_ARGS (t), &find_parameter_packs_r, ppd,
2509 case TEMPLATE_TYPE_PARM:
2510 case TEMPLATE_TEMPLATE_PARM:
2517 if (TYPE_PTRMEMFUNC_P (t))
2523 if (TYPE_TEMPLATE_INFO (t))
2524 cp_walk_tree (&TREE_VALUE (TYPE_TEMPLATE_INFO (t)),
2525 &find_parameter_packs_r, ppd, ppd->visited);
2531 cp_walk_tree (&TREE_TYPE (t),
2532 &find_parameter_packs_r, ppd, ppd->visited);
2536 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t), &find_parameter_packs_r,
2541 case TYPE_PACK_EXPANSION:
2542 case EXPR_PACK_EXPANSION:
2547 cp_walk_tree (&TYPE_MAX_VALUE (t), &find_parameter_packs_r,
2552 case IDENTIFIER_NODE:
2553 cp_walk_tree (&TREE_TYPE (t), &find_parameter_packs_r, ppd,
2565 /* Determines if the expression or type T uses any parameter packs. */
2567 uses_parameter_packs (tree t)
2569 tree parameter_packs = NULL_TREE;
2570 struct find_parameter_pack_data ppd;
2571 ppd.parameter_packs = ¶meter_packs;
2572 ppd.visited = pointer_set_create ();
2573 cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
2574 pointer_set_destroy (ppd.visited);
2575 return parameter_packs != NULL_TREE;
2578 /* Turn ARG, which may be an expression, type, or a TREE_LIST
2579 representation a base-class initializer into a parameter pack
2580 expansion. If all goes well, the resulting node will be an
2581 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
2584 make_pack_expansion (tree arg)
2587 tree parameter_packs = NULL_TREE;
2588 bool for_types = false;
2589 struct find_parameter_pack_data ppd;
2591 if (!arg || arg == error_mark_node)
2594 if (TREE_CODE (arg) == TREE_LIST)
2596 /* The only time we will see a TREE_LIST here is for a base
2597 class initializer. In this case, the TREE_PURPOSE will be a
2598 _TYPE node (representing the base class expansion we're
2599 initializing) and the TREE_VALUE will be a TREE_LIST
2600 containing the initialization arguments.
2602 The resulting expansion looks somewhat different from most
2603 expansions. Rather than returning just one _EXPANSION, we
2604 return a TREE_LIST whose TREE_PURPOSE is a
2605 TYPE_PACK_EXPANSION containing the bases that will be
2606 initialized. The TREE_VALUE will be identical to the
2607 original TREE_VALUE, which is a list of arguments that will
2608 be passed to each base. We do not introduce any new pack
2609 expansion nodes into the TREE_VALUE (although it is possible
2610 that some already exist), because the TREE_PURPOSE and
2611 TREE_VALUE all need to be expanded together with the same
2612 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
2613 resulting TREE_PURPOSE will mention the parameter packs in
2614 both the bases and the arguments to the bases. */
2617 tree parameter_packs = NULL_TREE;
2619 /* Determine which parameter packs will be used by the base
2621 ppd.visited = pointer_set_create ();
2622 ppd.parameter_packs = ¶meter_packs;
2623 cp_walk_tree (&TREE_PURPOSE (arg), &find_parameter_packs_r,
2626 if (parameter_packs == NULL_TREE)
2628 error ("base initializer expansion %<%T%> contains no parameter packs", arg);
2629 pointer_set_destroy (ppd.visited);
2630 return error_mark_node;
2633 if (TREE_VALUE (arg) != void_type_node)
2635 /* Collect the sets of parameter packs used in each of the
2636 initialization arguments. */
2637 for (value = TREE_VALUE (arg); value; value = TREE_CHAIN (value))
2639 /* Determine which parameter packs will be expanded in this
2641 cp_walk_tree (&TREE_VALUE (value), &find_parameter_packs_r,
2646 pointer_set_destroy (ppd.visited);
2648 /* Create the pack expansion type for the base type. */
2649 purpose = make_node (TYPE_PACK_EXPANSION);
2650 SET_PACK_EXPANSION_PATTERN (purpose, TREE_PURPOSE (arg));
2651 PACK_EXPANSION_PARAMETER_PACKS (purpose) = parameter_packs;
2653 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
2654 they will rarely be compared to anything. */
2655 SET_TYPE_STRUCTURAL_EQUALITY (purpose);
2657 return tree_cons (purpose, TREE_VALUE (arg), NULL_TREE);
2660 if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
2663 /* Build the PACK_EXPANSION_* node. */
2664 result = make_node (for_types ? TYPE_PACK_EXPANSION : EXPR_PACK_EXPANSION);
2665 SET_PACK_EXPANSION_PATTERN (result, arg);
2666 if (TREE_CODE (result) == EXPR_PACK_EXPANSION)
2668 /* Propagate type and const-expression information. */
2669 TREE_TYPE (result) = TREE_TYPE (arg);
2670 TREE_CONSTANT (result) = TREE_CONSTANT (arg);
2673 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
2674 they will rarely be compared to anything. */
2675 SET_TYPE_STRUCTURAL_EQUALITY (result);
2677 /* Determine which parameter packs will be expanded. */
2678 ppd.parameter_packs = ¶meter_packs;
2679 ppd.visited = pointer_set_create ();
2680 cp_walk_tree (&arg, &find_parameter_packs_r, &ppd, ppd.visited);
2681 pointer_set_destroy (ppd.visited);
2683 /* Make sure we found some parameter packs. */
2684 if (parameter_packs == NULL_TREE)
2687 error ("expansion pattern %<%T%> contains no argument packs", arg);
2689 error ("expansion pattern %<%E%> contains no argument packs", arg);
2690 return error_mark_node;
2692 PACK_EXPANSION_PARAMETER_PACKS (result) = parameter_packs;
2697 /* Checks T for any "bare" parameter packs, which have not yet been
2698 expanded, and issues an error if any are found. This operation can
2699 only be done on full expressions or types (e.g., an expression
2700 statement, "if" condition, etc.), because we could have expressions like:
2702 foo(f(g(h(args)))...)
2704 where "args" is a parameter pack. check_for_bare_parameter_packs
2705 should not be called for the subexpressions args, h(args),
2706 g(h(args)), or f(g(h(args))), because we would produce erroneous
2709 Returns TRUE and emits an error if there were bare parameter packs,
2710 returns FALSE otherwise. */
2712 check_for_bare_parameter_packs (tree t)
2714 tree parameter_packs = NULL_TREE;
2715 struct find_parameter_pack_data ppd;
2717 if (!processing_template_decl || !t || t == error_mark_node)
2720 if (TREE_CODE (t) == TYPE_DECL)
2723 ppd.parameter_packs = ¶meter_packs;
2724 ppd.visited = pointer_set_create ();
2725 cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
2726 pointer_set_destroy (ppd.visited);
2728 if (parameter_packs)
2730 error ("parameter packs not expanded with `...':");
2731 while (parameter_packs)
2733 tree pack = TREE_VALUE (parameter_packs);
2734 tree name = NULL_TREE;
2736 if (TREE_CODE (pack) == TEMPLATE_TYPE_PARM
2737 || TREE_CODE (pack) == TEMPLATE_TEMPLATE_PARM)
2738 name = TYPE_NAME (pack);
2739 else if (TREE_CODE (pack) == TEMPLATE_PARM_INDEX)
2740 name = DECL_NAME (TEMPLATE_PARM_DECL (pack));
2742 name = DECL_NAME (pack);
2745 inform (" %qD", name);
2747 inform (" <anonymous>");
2749 parameter_packs = TREE_CHAIN (parameter_packs);
2758 /* Expand any parameter packs that occur in the template arguments in
2761 expand_template_argument_pack (tree args)
2763 tree result_args = NULL_TREE;
2764 int in_arg, out_arg = 0, nargs = args ? TREE_VEC_LENGTH (args) : 0;
2765 int num_result_args = -1;
2767 /* First, determine if we need to expand anything, and the number of
2768 slots we'll need. */
2769 for (in_arg = 0; in_arg < nargs; ++in_arg)
2771 tree arg = TREE_VEC_ELT (args, in_arg);
2772 if (ARGUMENT_PACK_P (arg))
2774 int num_packed = TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg));
2775 if (num_result_args < 0)
2776 num_result_args = in_arg + num_packed;
2778 num_result_args += num_packed;
2782 if (num_result_args >= 0)
2787 /* If no expansion is necessary, we're done. */
2788 if (num_result_args < 0)
2791 /* Expand arguments. */
2792 result_args = make_tree_vec (num_result_args);
2793 for (in_arg = 0; in_arg < nargs; ++in_arg)
2795 tree arg = TREE_VEC_ELT (args, in_arg);
2796 if (ARGUMENT_PACK_P (arg))
2798 tree packed = ARGUMENT_PACK_ARGS (arg);
2799 int i, num_packed = TREE_VEC_LENGTH (packed);
2800 for (i = 0; i < num_packed; ++i, ++out_arg)
2801 TREE_VEC_ELT (result_args, out_arg) = TREE_VEC_ELT(packed, i);
2805 TREE_VEC_ELT (result_args, out_arg) = arg;
2813 /* Complain if DECL shadows a template parameter.
2815 [temp.local]: A template-parameter shall not be redeclared within its
2816 scope (including nested scopes). */
2819 check_template_shadow (tree decl)
2823 /* If we're not in a template, we can't possibly shadow a template
2825 if (!current_template_parms)
2828 /* Figure out what we're shadowing. */
2829 if (TREE_CODE (decl) == OVERLOAD)
2830 decl = OVL_CURRENT (decl);
2831 olddecl = innermost_non_namespace_value (DECL_NAME (decl));
2833 /* If there's no previous binding for this name, we're not shadowing
2834 anything, let alone a template parameter. */
2838 /* If we're not shadowing a template parameter, we're done. Note
2839 that OLDDECL might be an OVERLOAD (or perhaps even an
2840 ERROR_MARK), so we can't just blithely assume it to be a _DECL
2842 if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
2845 /* We check for decl != olddecl to avoid bogus errors for using a
2846 name inside a class. We check TPFI to avoid duplicate errors for
2847 inline member templates. */
2849 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms))
2852 error ("declaration of %q+#D", decl);
2853 error (" shadows template parm %q+#D", olddecl);
2856 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
2857 ORIG_LEVEL, DECL, and TYPE. */
2860 build_template_parm_index (int index,
2866 tree t = make_node (TEMPLATE_PARM_INDEX);
2867 TEMPLATE_PARM_IDX (t) = index;
2868 TEMPLATE_PARM_LEVEL (t) = level;
2869 TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
2870 TEMPLATE_PARM_DECL (t) = decl;
2871 TREE_TYPE (t) = type;
2872 TREE_CONSTANT (t) = TREE_CONSTANT (decl);
2873 TREE_INVARIANT (t) = TREE_INVARIANT (decl);
2874 TREE_READONLY (t) = TREE_READONLY (decl);
2879 /* Find the canonical type parameter for the given template type
2880 parameter. Returns the canonical type parameter, which may be TYPE
2881 if no such parameter existed. */
2883 canonical_type_parameter (tree type)
2886 int idx = TEMPLATE_TYPE_IDX (type);
2887 if (!canonical_template_parms)
2888 canonical_template_parms = VEC_alloc (tree, gc, idx+1);
2890 while (VEC_length (tree, canonical_template_parms) <= (unsigned)idx)
2891 VEC_safe_push (tree, gc, canonical_template_parms, NULL_TREE);
2893 list = VEC_index (tree, canonical_template_parms, idx);
2894 while (list && !comptypes (type, TREE_VALUE (list), COMPARE_STRUCTURAL))
2895 list = TREE_CHAIN (list);
2898 return TREE_VALUE (list);
2901 VEC_replace(tree, canonical_template_parms, idx,
2902 tree_cons (NULL_TREE, type,
2903 VEC_index (tree, canonical_template_parms, idx)));
2908 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
2909 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
2910 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
2911 new one is created. */
2914 reduce_template_parm_level (tree index, tree type, int levels, tree args,
2915 tsubst_flags_t complain)
2917 if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
2918 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
2919 != TEMPLATE_PARM_LEVEL (index) - levels))
2921 tree orig_decl = TEMPLATE_PARM_DECL (index);
2924 decl = build_decl (TREE_CODE (orig_decl), DECL_NAME (orig_decl), type);
2925 TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl);
2926 TREE_INVARIANT (decl) = TREE_INVARIANT (orig_decl);
2927 TREE_READONLY (decl) = TREE_READONLY (orig_decl);
2928 DECL_ARTIFICIAL (decl) = 1;
2929 SET_DECL_TEMPLATE_PARM_P (decl);
2931 t = build_template_parm_index (TEMPLATE_PARM_IDX (index),
2932 TEMPLATE_PARM_LEVEL (index) - levels,
2933 TEMPLATE_PARM_ORIG_LEVEL (index),
2935 TEMPLATE_PARM_DESCENDANTS (index) = t;
2936 TEMPLATE_PARM_PARAMETER_PACK (t)
2937 = TEMPLATE_PARM_PARAMETER_PACK (index);
2939 /* Template template parameters need this. */
2940 if (TREE_CODE (decl) == TEMPLATE_DECL)
2941 DECL_TEMPLATE_PARMS (decl) = tsubst_template_parms
2942 (DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index)),
2946 return TEMPLATE_PARM_DESCENDANTS (index);
2949 /* Process information from new template parameter PARM and append it to the
2950 LIST being built. This new parameter is a non-type parameter iff
2951 IS_NON_TYPE is true. This new parameter is a parameter
2952 pack iff IS_PARAMETER_PACK is true. */
2955 process_template_parm (tree list, tree parm, bool is_non_type,
2956 bool is_parameter_pack)
2963 gcc_assert (TREE_CODE (parm) == TREE_LIST);
2964 defval = TREE_PURPOSE (parm);
2968 tree p = tree_last (list);
2970 if (p && TREE_VALUE (p) != error_mark_node)
2973 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
2974 idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
2976 idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
2986 parm = TREE_VALUE (parm);
2988 SET_DECL_TEMPLATE_PARM_P (parm);
2990 if (TREE_TYPE (parm) == error_mark_node)
2992 err_parm_list = build_tree_list (defval, parm);
2993 TREE_VALUE (err_parm_list) = error_mark_node;
2994 return chainon (list, err_parm_list);
3000 The top-level cv-qualifiers on the template-parameter are
3001 ignored when determining its type. */
3002 TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
3003 if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
3005 err_parm_list = build_tree_list (defval, parm);
3006 TREE_VALUE (err_parm_list) = error_mark_node;
3007 return chainon (list, err_parm_list);
3010 if (uses_parameter_packs (TREE_TYPE (parm)) && !is_parameter_pack)
3012 /* This template parameter is not a parameter pack, but it
3013 should be. Complain about "bare" parameter packs. */
3014 check_for_bare_parameter_packs (TREE_TYPE (parm));
3016 /* Recover by calling this a parameter pack. */
3017 is_parameter_pack = true;
3021 /* A template parameter is not modifiable. */
3022 TREE_CONSTANT (parm) = 1;
3023 TREE_INVARIANT (parm) = 1;
3024 TREE_READONLY (parm) = 1;
3025 decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
3026 TREE_CONSTANT (decl) = 1;
3027 TREE_INVARIANT (decl) = 1;
3028 TREE_READONLY (decl) = 1;
3029 DECL_INITIAL (parm) = DECL_INITIAL (decl)
3030 = build_template_parm_index (idx, processing_template_decl,
3031 processing_template_decl,
3032 decl, TREE_TYPE (parm));
3034 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm))
3035 = is_parameter_pack;
3040 parm = TREE_VALUE (TREE_VALUE (parm));
3042 if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
3044 t = cxx_make_type (TEMPLATE_TEMPLATE_PARM);
3045 /* This is for distinguishing between real templates and template
3046 template parameters */
3047 TREE_TYPE (parm) = t;
3048 TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t;
3053 t = cxx_make_type (TEMPLATE_TYPE_PARM);
3054 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3055 decl = build_decl (TYPE_DECL, parm, t);
3058 TYPE_NAME (t) = decl;
3059 TYPE_STUB_DECL (t) = decl;
3061 TEMPLATE_TYPE_PARM_INDEX (t)
3062 = build_template_parm_index (idx, processing_template_decl,
3063 processing_template_decl,
3064 decl, TREE_TYPE (parm));
3065 TEMPLATE_TYPE_PARAMETER_PACK (t) = is_parameter_pack;
3066 TYPE_CANONICAL (t) = canonical_type_parameter (t);
3068 DECL_ARTIFICIAL (decl) = 1;
3069 SET_DECL_TEMPLATE_PARM_P (decl);
3071 parm = build_tree_list (defval, parm);
3072 return chainon (list, parm);
3075 /* The end of a template parameter list has been reached. Process the
3076 tree list into a parameter vector, converting each parameter into a more
3077 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3081 end_template_parm_list (tree parms)
3085 tree saved_parmlist = make_tree_vec (list_length (parms));
3087 current_template_parms
3088 = tree_cons (size_int (processing_template_decl),
3089 saved_parmlist, current_template_parms);
3091 for (parm = parms, nparms = 0; parm; parm = next, nparms++)
3093 next = TREE_CHAIN (parm);
3094 TREE_VEC_ELT (saved_parmlist, nparms) = parm;
3095 TREE_CHAIN (parm) = NULL_TREE;
3098 --processing_template_parmlist;
3100 return saved_parmlist;
3103 /* end_template_decl is called after a template declaration is seen. */
3106 end_template_decl (void)
3108 reset_specialization ();
3110 if (! processing_template_decl)
3113 /* This matches the pushlevel in begin_template_parm_list. */
3116 --processing_template_decl;
3117 current_template_parms = TREE_CHAIN (current_template_parms);
3120 /* Within the declaration of a template, return all levels of template
3121 parameters that apply. The template parameters are represented as
3122 a TREE_VEC, in the form documented in cp-tree.h for template
3126 current_template_args (void)
3129 tree args = NULL_TREE;
3130 int length = TMPL_PARMS_DEPTH (current_template_parms);
3133 /* If there is only one level of template parameters, we do not
3134 create a TREE_VEC of TREE_VECs. Instead, we return a single
3135 TREE_VEC containing the arguments. */
3137 args = make_tree_vec (length);
3139 for (header = current_template_parms; header; header = TREE_CHAIN (header))
3141 tree a = copy_node (TREE_VALUE (header));
3144 TREE_TYPE (a) = NULL_TREE;
3145 for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
3147 tree t = TREE_VEC_ELT (a, i);
3149 /* T will be a list if we are called from within a
3150 begin/end_template_parm_list pair, but a vector directly
3151 if within a begin/end_member_template_processing pair. */
3152 if (TREE_CODE (t) == TREE_LIST)
3156 if (!error_operand_p (t))
3158 if (TREE_CODE (t) == TYPE_DECL
3159 || TREE_CODE (t) == TEMPLATE_DECL)
3163 if (TEMPLATE_TYPE_PARAMETER_PACK (t))
3165 /* Turn this argument into a TYPE_ARGUMENT_PACK
3166 with a single element, which expands T. */
3167 tree vec = make_tree_vec (1);
3168 TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
3170 t = make_node (TYPE_ARGUMENT_PACK);
3171 SET_ARGUMENT_PACK_ARGS (t, vec);
3176 t = DECL_INITIAL (t);
3178 if (TEMPLATE_PARM_PARAMETER_PACK (t))
3180 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3181 with a single element, which expands T. */
3182 tree vec = make_tree_vec (1);
3183 tree type = TREE_TYPE (TEMPLATE_PARM_DECL (t));
3184 TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
3186 t = make_node (NONTYPE_ARGUMENT_PACK);
3187 SET_ARGUMENT_PACK_ARGS (t, vec);
3188 TREE_TYPE (t) = type;
3191 TREE_VEC_ELT (a, i) = t;
3197 TREE_VEC_ELT (args, --l) = a;
3205 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
3206 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
3207 a member template. Used by push_template_decl below. */
3210 build_template_decl (tree decl, tree parms, bool member_template_p)
3212 tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
3213 DECL_TEMPLATE_PARMS (tmpl) = parms;
3214 DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
3215 DECL_MEMBER_TEMPLATE_P (tmpl) = member_template_p;
3216 if (DECL_LANG_SPECIFIC (decl))
3218 DECL_STATIC_FUNCTION_P (tmpl) = DECL_STATIC_FUNCTION_P (decl);
3219 DECL_CONSTRUCTOR_P (tmpl) = DECL_CONSTRUCTOR_P (decl);
3220 DECL_DESTRUCTOR_P (tmpl) = DECL_DESTRUCTOR_P (decl);
3221 DECL_NONCONVERTING_P (tmpl) = DECL_NONCONVERTING_P (decl);
3222 DECL_ASSIGNMENT_OPERATOR_P (tmpl) = DECL_ASSIGNMENT_OPERATOR_P (decl);
3223 if (DECL_OVERLOADED_OPERATOR_P (decl))
3224 SET_OVERLOADED_OPERATOR_CODE (tmpl,
3225 DECL_OVERLOADED_OPERATOR_P (decl));
3231 struct template_parm_data
3233 /* The level of the template parameters we are currently
3237 /* The index of the specialization argument we are currently
3241 /* An array whose size is the number of template parameters. The
3242 elements are nonzero if the parameter has been used in any one
3243 of the arguments processed so far. */
3246 /* An array whose size is the number of template arguments. The
3247 elements are nonzero if the argument makes use of template
3248 parameters of this level. */
3249 int* arg_uses_template_parms;
3252 /* Subroutine of push_template_decl used to see if each template
3253 parameter in a partial specialization is used in the explicit
3254 argument list. If T is of the LEVEL given in DATA (which is
3255 treated as a template_parm_data*), then DATA->PARMS is marked
3259 mark_template_parm (tree t, void* data)
3263 struct template_parm_data* tpd = (struct template_parm_data*) data;
3265 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
3267 level = TEMPLATE_PARM_LEVEL (t);
3268 idx = TEMPLATE_PARM_IDX (t);
3272 level = TEMPLATE_TYPE_LEVEL (t);
3273 idx = TEMPLATE_TYPE_IDX (t);
3276 if (level == tpd->level)
3278 tpd->parms[idx] = 1;
3279 tpd->arg_uses_template_parms[tpd->current_arg] = 1;
3282 /* Return zero so that for_each_template_parm will continue the
3283 traversal of the tree; we want to mark *every* template parm. */
3287 /* Process the partial specialization DECL. */
3290 process_partial_specialization (tree decl)
3292 tree type = TREE_TYPE (decl);
3293 tree maintmpl = CLASSTYPE_TI_TEMPLATE (type);
3294 tree specargs = CLASSTYPE_TI_ARGS (type);
3295 tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
3296 tree inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
3297 tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
3298 int nargs = TREE_VEC_LENGTH (inner_args);
3299 int ntparms = TREE_VEC_LENGTH (inner_parms);
3301 int did_error_intro = 0;
3302 struct template_parm_data tpd;
3303 struct template_parm_data tpd2;
3305 /* We check that each of the template parameters given in the
3306 partial specialization is used in the argument list to the
3307 specialization. For example:
3309 template <class T> struct S;
3310 template <class T> struct S<T*>;
3312 The second declaration is OK because `T*' uses the template
3313 parameter T, whereas
3315 template <class T> struct S<int>;
3317 is no good. Even trickier is:
3328 The S2<T> declaration is actually invalid; it is a
3329 full-specialization. Of course,
3332 struct S2<T (*)(U)>;
3334 or some such would have been OK. */
3335 tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
3336 tpd.parms = (int *) alloca (sizeof (int) * ntparms);
3337 memset (tpd.parms, 0, sizeof (int) * ntparms);
3339 tpd.arg_uses_template_parms = (int *) alloca (sizeof (int) * nargs);
3340 memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
3341 for (i = 0; i < nargs; ++i)
3343 tpd.current_arg = i;
3344 for_each_template_parm (TREE_VEC_ELT (inner_args, i),
3345 &mark_template_parm,
3348 /*include_nondeduced_p=*/false);
3350 for (i = 0; i < ntparms; ++i)
3351 if (tpd.parms[i] == 0)
3353 /* One of the template parms was not used in the
3355 if (!did_error_intro)
3357 error ("template parameters not used in partial specialization:");
3358 did_error_intro = 1;
3361 error (" %qD", TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
3364 /* [temp.class.spec]
3366 The argument list of the specialization shall not be identical to
3367 the implicit argument list of the primary template. */
3368 if (comp_template_args
3370 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
3372 error ("partial specialization %qT does not specialize any template arguments", type);
3374 /* [temp.class.spec]
3376 A partially specialized non-type argument expression shall not
3377 involve template parameters of the partial specialization except
3378 when the argument expression is a simple identifier.
3380 The type of a template parameter corresponding to a specialized
3381 non-type argument shall not be dependent on a parameter of the
3384 Also, we verify that pack expansions only occur at the
3385 end of the argument list. */
3386 gcc_assert (nargs == DECL_NTPARMS (maintmpl));
3388 for (i = 0; i < nargs; ++i)
3390 tree parm = TREE_VALUE (TREE_VEC_ELT (main_inner_parms, i));
3391 tree arg = TREE_VEC_ELT (inner_args, i);
3392 tree packed_args = NULL_TREE;
3395 if (ARGUMENT_PACK_P (arg))
3397 /* Extract the arguments from the argument pack. We'll be
3398 iterating over these in the following loop. */
3399 packed_args = ARGUMENT_PACK_ARGS (arg);
3400 len = TREE_VEC_LENGTH (packed_args);
3403 for (j = 0; j < len; j++)
3406 /* Get the Jth argument in the parameter pack. */
3407 arg = TREE_VEC_ELT (packed_args, j);
3409 if (PACK_EXPANSION_P (arg))
3411 /* Pack expansions must come at the end of the
3413 if ((packed_args && j < len - 1)
3414 || (!packed_args && i < nargs - 1))
3416 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
3417 error ("parameter pack argument %qE must be at the end of the template argument list", arg);
3419 error ("parameter pack argument %qT must be at the end of the template argument list", arg);
3422 TREE_VEC_ELT (packed_args, j) = error_mark_node;
3426 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
3427 /* We only care about the pattern. */
3428 arg = PACK_EXPANSION_PATTERN (arg);
3430 if (/* These first two lines are the `non-type' bit. */
3432 && TREE_CODE (arg) != TEMPLATE_DECL
3433 /* This next line is the `argument expression is not just a
3434 simple identifier' condition and also the `specialized
3435 non-type argument' bit. */
3436 && TREE_CODE (arg) != TEMPLATE_PARM_INDEX)
3438 if ((!packed_args && tpd.arg_uses_template_parms[i])
3439 || (packed_args && uses_template_parms (arg)))
3440 error ("template argument %qE involves template parameter(s)",
3444 /* Look at the corresponding template parameter,
3445 marking which template parameters its type depends
3447 tree type = TREE_TYPE (parm);
3451 /* We haven't yet initialized TPD2. Do so now. */
3452 tpd2.arg_uses_template_parms
3453 = (int *) alloca (sizeof (int) * nargs);
3454 /* The number of parameters here is the number in the
3455 main template, which, as checked in the assertion
3457 tpd2.parms = (int *) alloca (sizeof (int) * nargs);
3459 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
3462 /* Mark the template parameters. But this time, we're
3463 looking for the template parameters of the main
3464 template, not in the specialization. */
3465 tpd2.current_arg = i;
3466 tpd2.arg_uses_template_parms[i] = 0;
3467 memset (tpd2.parms, 0, sizeof (int) * nargs);
3468 for_each_template_parm (type,
3469 &mark_template_parm,
3472 /*include_nondeduced_p=*/false);
3474 if (tpd2.arg_uses_template_parms [i])
3476 /* The type depended on some template parameters.
3477 If they are fully specialized in the
3478 specialization, that's OK. */
3480 for (j = 0; j < nargs; ++j)
3481 if (tpd2.parms[j] != 0
3482 && tpd.arg_uses_template_parms [j])
3484 error ("type %qT of template argument %qE depends "
3485 "on template parameter(s)",
3496 if (retrieve_specialization (maintmpl, specargs,
3497 /*class_specializations_p=*/true))
3498 /* We've already got this specialization. */
3501 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
3502 = tree_cons (specargs, inner_parms,
3503 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
3504 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
3508 /* Check that a template declaration's use of default arguments and
3509 parameter packs is not invalid. Here, PARMS are the template
3510 parameters. IS_PRIMARY is nonzero if DECL is the thing declared by
3511 a primary template. IS_PARTIAL is nonzero if DECL is a partial
3515 IS_FRIEND_DECL is nonzero if DECL is a friend function template
3516 declaration (but not a definition); 1 indicates a declaration, 2
3517 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
3518 emitted for extraneous default arguments.
3520 Returns TRUE if there were no errors found, FALSE otherwise. */
3523 check_default_tmpl_args (tree decl, tree parms, int is_primary,
3524 int is_partial, int is_friend_decl)
3527 int last_level_to_check;
3529 bool no_errors = true;
3533 A default template-argument shall not be specified in a
3534 function template declaration or a function template definition, nor
3535 in the template-parameter-list of the definition of a member of a
3538 if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
3539 /* You can't have a function template declaration in a local
3540 scope, nor you can you define a member of a class template in a
3544 if (current_class_type
3545 && !TYPE_BEING_DEFINED (current_class_type)
3546 && DECL_LANG_SPECIFIC (decl)
3547 /* If this is either a friend defined in the scope of the class
3548 or a member function. */
3549 && (DECL_FUNCTION_MEMBER_P (decl)
3550 ? same_type_p (DECL_CONTEXT (decl), current_class_type)
3551 : DECL_FRIEND_CONTEXT (decl)
3552 ? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type)
3554 /* And, if it was a member function, it really was defined in
3555 the scope of the class. */
3556 && (!DECL_FUNCTION_MEMBER_P (decl)
3557 || DECL_INITIALIZED_IN_CLASS_P (decl)))
3558 /* We already checked these parameters when the template was
3559 declared, so there's no need to do it again now. This function
3560 was defined in class scope, but we're processing it's body now
3561 that the class is complete. */
3564 /* Core issue 226 (C++0x only): the following only applies to class
3566 if ((cxx_dialect == cxx98) || TREE_CODE (decl) != FUNCTION_DECL)
3570 If a template-parameter has a default template-argument, all
3571 subsequent template-parameters shall have a default
3572 template-argument supplied. */
3573 for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
3575 tree inner_parms = TREE_VALUE (parm_level);
3576 int ntparms = TREE_VEC_LENGTH (inner_parms);
3577 int seen_def_arg_p = 0;
3580 for (i = 0; i < ntparms; ++i)
3582 tree parm = TREE_VEC_ELT (inner_parms, i);
3584 if (parm == error_mark_node)
3587 if (TREE_PURPOSE (parm))
3589 else if (seen_def_arg_p)
3591 error ("no default argument for %qD", TREE_VALUE (parm));
3592 /* For better subsequent error-recovery, we indicate that
3593 there should have been a default argument. */
3594 TREE_PURPOSE (parm) = error_mark_node;
3600 && TREE_CODE (decl) == TYPE_DECL
3602 && template_parameter_pack_p (TREE_VALUE (parm)))
3604 /* A primary class template can only have one
3605 parameter pack, at the end of the template
3608 if (TREE_CODE (TREE_VALUE (parm)) == PARM_DECL)
3609 error ("parameter pack %qE must be at the end of the"
3610 " template parameter list", TREE_VALUE (parm));
3612 error ("parameter pack %qT must be at the end of the"
3613 " template parameter list",
3614 TREE_TYPE (TREE_VALUE (parm)));
3616 TREE_VALUE (TREE_VEC_ELT (inner_parms, i))
3624 if (((cxx_dialect == cxx98) && TREE_CODE (decl) != TYPE_DECL)
3628 /* For an ordinary class template, default template arguments are
3629 allowed at the innermost level, e.g.:
3630 template <class T = int>
3632 but, in a partial specialization, they're not allowed even
3633 there, as we have in [temp.class.spec]:
3635 The template parameter list of a specialization shall not
3636 contain default template argument values.
3638 So, for a partial specialization, or for a function template
3639 (in C++98/C++03), we look at all of them. */
3642 /* But, for a primary class template that is not a partial
3643 specialization we look at all template parameters except the
3645 parms = TREE_CHAIN (parms);
3647 /* Figure out what error message to issue. */
3648 if (is_friend_decl == 2)
3649 msg = "default template arguments may not be used in function template friend re-declaration";
3650 else if (is_friend_decl)
3651 msg = "default template arguments may not be used in function template friend declarations";
3652 else if (TREE_CODE (decl) == FUNCTION_DECL && (cxx_dialect == cxx98))
3653 msg = "default template arguments may not be used in function templates";
3654 else if (is_partial)
3655 msg = "default template arguments may not be used in partial specializations";
3657 msg = "default argument for template parameter for class enclosing %qD";
3659 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
3660 /* If we're inside a class definition, there's no need to
3661 examine the parameters to the class itself. On the one
3662 hand, they will be checked when the class is defined, and,
3663 on the other, default arguments are valid in things like:
3664 template <class T = double>
3665 struct S { template <class U> void f(U); };
3666 Here the default argument for `S' has no bearing on the
3667 declaration of `f'. */
3668 last_level_to_check = template_class_depth (current_class_type) + 1;
3670 /* Check everything. */
3671 last_level_to_check = 0;
3673 for (parm_level = parms;
3674 parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
3675 parm_level = TREE_CHAIN (parm_level))
3677 tree inner_parms = TREE_VALUE (parm_level);
3681 ntparms = TREE_VEC_LENGTH (inner_parms);
3682 for (i = 0; i < ntparms; ++i)
3684 if (TREE_VEC_ELT (inner_parms, i) == error_mark_node)
3687 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
3692 if (is_friend_decl == 2)
3699 /* Clear out the default argument so that we are not
3701 TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
3705 /* At this point, if we're still interested in issuing messages,
3706 they must apply to classes surrounding the object declared. */
3708 msg = "default argument for template parameter for class enclosing %qD";
3714 /* Worker for push_template_decl_real, called via
3715 for_each_template_parm. DATA is really an int, indicating the
3716 level of the parameters we are interested in. If T is a template
3717 parameter of that level, return nonzero. */
3720 template_parm_this_level_p (tree t, void* data)
3722 int this_level = *(int *)data;
3725 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
3726 level = TEMPLATE_PARM_LEVEL (t);
3728 level = TEMPLATE_TYPE_LEVEL (t);
3729 return level == this_level;
3732 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
3733 parameters given by current_template_args, or reuses a
3734 previously existing one, if appropriate. Returns the DECL, or an
3735 equivalent one, if it is replaced via a call to duplicate_decls.
3737 If IS_FRIEND is true, DECL is a friend declaration. */
3740 push_template_decl_real (tree decl, bool is_friend)
3748 int new_template_p = 0;
3749 /* True if the template is a member template, in the sense of
3751 bool member_template_p = false;
3753 if (decl == error_mark_node)
3756 /* See if this is a partial specialization. */
3757 is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl)
3758 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
3759 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)));
3761 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl))
3765 /* For a friend, we want the context of the friend function, not
3766 the type of which it is a friend. */
3767 ctx = DECL_CONTEXT (decl);
3768 else if (CP_DECL_CONTEXT (decl)
3769 && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
3770 /* In the case of a virtual function, we want the class in which
3772 ctx = CP_DECL_CONTEXT (decl);
3774 /* Otherwise, if we're currently defining some class, the DECL
3775 is assumed to be a member of the class. */
3776 ctx = current_scope ();
3778 if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
3781 if (!DECL_CONTEXT (decl))
3782 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
3784 /* See if this is a primary template. */
3785 if (is_friend && ctx)
3786 /* A friend template that specifies a class context, i.e.
3787 template <typename T> friend void A<T>::f();
3791 primary = template_parm_scope_p ();
3795 if (DECL_CLASS_SCOPE_P (decl))
3796 member_template_p = true;
3797 if (TREE_CODE (decl) == TYPE_DECL
3798 && ANON_AGGRNAME_P (DECL_NAME (decl)))
3799 error ("template class without a name");
3800 else if (TREE_CODE (decl) == FUNCTION_DECL)
3802 if (DECL_DESTRUCTOR_P (decl))
3806 A destructor shall not be a member template. */
3807 error ("destructor %qD declared as member template", decl);
3808 return error_mark_node;
3810 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl))
3811 && (!TYPE_ARG_TYPES (TREE_TYPE (decl))
3812 || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
3813 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
3814 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl))))
3815 == void_list_node)))
3817 /* [basic.stc.dynamic.allocation]
3819 An allocation function can be a function
3820 template. ... Template allocation functions shall
3821 have two or more parameters. */
3822 error ("invalid template declaration of %qD", decl);
3823 return error_mark_node;
3826 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
3827 && CLASS_TYPE_P (TREE_TYPE (decl)))
3831 error ("template declaration of %q#D", decl);
3832 return error_mark_node;
3836 /* Check to see that the rules regarding the use of default
3837 arguments are not being violated. */
3838 check_default_tmpl_args (decl, current_template_parms,
3839 primary, is_partial, /*is_friend_decl=*/0);
3841 /* Ensure that there are no parameter packs in the type of this
3842 declaration that have not been expanded. */
3843 if (TREE_CODE (decl) == FUNCTION_DECL)
3845 /* Check each of the arguments individually to see if there are
3846 any bare parameter packs. */
3847 tree type = TREE_TYPE (decl);
3848 tree arg = DECL_ARGUMENTS (decl);
3849 tree argtype = TYPE_ARG_TYPES (type);
3851 while (arg && argtype)
3853 if (!FUNCTION_PARAMETER_PACK_P (arg)
3854 && check_for_bare_parameter_packs (TREE_TYPE (arg)))
3856 /* This is a PARM_DECL that contains unexpanded parameter
3857 packs. We have already complained about this in the
3858 check_for_bare_parameter_packs call, so just replace
3859 these types with ERROR_MARK_NODE. */
3860 TREE_TYPE (arg) = error_mark_node;
3861 TREE_VALUE (argtype) = error_mark_node;
3864 arg = TREE_CHAIN (arg);
3865 argtype = TREE_CHAIN (argtype);
3868 /* Check for bare parameter packs in the return type and the
3869 exception specifiers. */
3870 if (check_for_bare_parameter_packs (TREE_TYPE (type)))
3871 /* Errors were already issued, set return type to int
3872 as the frontend doesn't expect error_mark_node as
3874 TREE_TYPE (type) = integer_type_node;
3875 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type)))
3876 TYPE_RAISES_EXCEPTIONS (type) = NULL_TREE;
3878 else if (check_for_bare_parameter_packs (TREE_TYPE (decl)))
3880 TREE_TYPE (decl) = error_mark_node;
3881 return error_mark_node;
3885 return process_partial_specialization (decl);
3887 args = current_template_args ();
3890 || TREE_CODE (ctx) == FUNCTION_DECL
3891 || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
3892 || (is_friend && !DECL_TEMPLATE_INFO (decl)))
3894 if (DECL_LANG_SPECIFIC (decl)
3895 && DECL_TEMPLATE_INFO (decl)
3896 && DECL_TI_TEMPLATE (decl))
3897 tmpl = DECL_TI_TEMPLATE (decl);
3898 /* If DECL is a TYPE_DECL for a class-template, then there won't
3899 be DECL_LANG_SPECIFIC. The information equivalent to
3900 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
3901 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
3902 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
3903 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
3905 /* Since a template declaration already existed for this
3906 class-type, we must be redeclaring it here. Make sure
3907 that the redeclaration is valid. */
3908 redeclare_class_template (TREE_TYPE (decl),
3909 current_template_parms);
3910 /* We don't need to create a new TEMPLATE_DECL; just use the
3911 one we already had. */
3912 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
3916 tmpl = build_template_decl (decl, current_template_parms,
3920 if (DECL_LANG_SPECIFIC (decl)
3921 && DECL_TEMPLATE_SPECIALIZATION (decl))
3923 /* A specialization of a member template of a template
3925 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
3926 DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
3927 DECL_TEMPLATE_INFO (decl) = NULL_TREE;
3933 tree a, t, current, parms;
3935 tree tinfo = get_template_info (decl);
3939 error ("template definition of non-template %q#D", decl);
3940 return error_mark_node;
3943 tmpl = TI_TEMPLATE (tinfo);
3945 if (DECL_FUNCTION_TEMPLATE_P (tmpl)
3946 && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
3947 && DECL_TEMPLATE_SPECIALIZATION (decl)
3948 && DECL_MEMBER_TEMPLATE_P (tmpl))
3952 /* The declaration is a specialization of a member
3953 template, declared outside the class. Therefore, the
3954 innermost template arguments will be NULL, so we
3955 replace them with the arguments determined by the
3956 earlier call to check_explicit_specialization. */
3957 args = DECL_TI_ARGS (decl);
3960 = build_template_decl (decl, current_template_parms,
3962 DECL_TEMPLATE_RESULT (new_tmpl) = decl;
3963 TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
3964 DECL_TI_TEMPLATE (decl) = new_tmpl;
3965 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
3966 DECL_TEMPLATE_INFO (new_tmpl)
3967 = tree_cons (tmpl, args, NULL_TREE);
3969 register_specialization (new_tmpl,
3970 most_general_template (tmpl),
3976 /* Make sure the template headers we got make sense. */
3978 parms = DECL_TEMPLATE_PARMS (tmpl);
3979 i = TMPL_PARMS_DEPTH (parms);
3980 if (TMPL_ARGS_DEPTH (args) != i)
3982 error ("expected %d levels of template parms for %q#D, got %d",
3983 i, decl, TMPL_ARGS_DEPTH (args));
3986 for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
3988 a = TMPL_ARGS_LEVEL (args, i);
3989 t = INNERMOST_TEMPLATE_PARMS (parms);
3991 if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
3993 if (current == decl)
3994 error ("got %d template parameters for %q#D",
3995 TREE_VEC_LENGTH (a), decl);
3997 error ("got %d template parameters for %q#T",
3998 TREE_VEC_LENGTH (a), current);
3999 error (" but %d required", TREE_VEC_LENGTH (t));
4000 return error_mark_node;
4003 if (current == decl)
4006 current = (TYPE_P (current)
4007 ? TYPE_CONTEXT (current)
4008 : DECL_CONTEXT (current));
4011 /* Check that the parms are used in the appropriate qualifying scopes
4012 in the declarator. */
4013 if (!comp_template_args
4015 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl)))))
4018 template arguments to %qD do not match original template %qD",
4019 decl, DECL_TEMPLATE_RESULT (tmpl));
4020 if (!uses_template_parms (TI_ARGS (tinfo)))
4021 inform ("use template<> for an explicit specialization");
4022 /* Avoid crash in import_export_decl. */
4023 DECL_INTERFACE_KNOWN (decl) = 1;
4024 return error_mark_node;
4028 DECL_TEMPLATE_RESULT (tmpl) = decl;
4029 TREE_TYPE (tmpl) = TREE_TYPE (decl);
4031 /* Push template declarations for global functions and types. Note
4032 that we do not try to push a global template friend declared in a
4033 template class; such a thing may well depend on the template
4034 parameters of the class. */
4035 if (new_template_p && !ctx
4036 && !(is_friend && template_class_depth (current_class_type) > 0))
4038 tmpl = pushdecl_namespace_level (tmpl, is_friend);
4039 if (tmpl == error_mark_node)
4040 return error_mark_node;
4042 /* Hide template friend classes that haven't been declared yet. */
4043 if (is_friend && TREE_CODE (decl) == TYPE_DECL)
4045 DECL_ANTICIPATED (tmpl) = 1;
4046 DECL_FRIEND_P (tmpl) = 1;
4052 tree parms = DECL_TEMPLATE_PARMS (tmpl);
4055 DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
4056 if (DECL_CONV_FN_P (tmpl))
4058 int depth = TMPL_PARMS_DEPTH (parms);
4060 /* It is a conversion operator. See if the type converted to
4061 depends on innermost template operands. */
4063 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl)),
4065 DECL_TEMPLATE_CONV_FN_P (tmpl) = 1;
4068 /* Give template template parms a DECL_CONTEXT of the template
4069 for which they are a parameter. */
4070 parms = INNERMOST_TEMPLATE_PARMS (parms);
4071 for (i = TREE_VEC_LENGTH (parms) - 1; i >= 0; --i)
4073 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
4074 if (TREE_CODE (parm) == TEMPLATE_DECL)
4075 DECL_CONTEXT (parm) = tmpl;
4079 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
4080 back to its most general template. If TMPL is a specialization,
4081 ARGS may only have the innermost set of arguments. Add the missing
4082 argument levels if necessary. */
4083 if (DECL_TEMPLATE_INFO (tmpl))
4084 args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);
4086 info = tree_cons (tmpl, args, NULL_TREE);
4088 if (DECL_IMPLICIT_TYPEDEF_P (decl))
4089 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
4090 else if (DECL_LANG_SPECIFIC (decl))
4091 DECL_TEMPLATE_INFO (decl) = info;
4093 return DECL_TEMPLATE_RESULT (tmpl);
4097 push_template_decl (tree decl)
4099 return push_template_decl_real (decl, false);
4102 /* Called when a class template TYPE is redeclared with the indicated
4103 template PARMS, e.g.:
4105 template <class T> struct S;
4106 template <class T> struct S {}; */
4109 redeclare_class_template (tree type, tree parms)
4115 if (!TYPE_TEMPLATE_INFO (type))
4117 error ("%qT is not a template type", type);
4121 tmpl = TYPE_TI_TEMPLATE (type);
4122 if (!PRIMARY_TEMPLATE_P (tmpl))
4123 /* The type is nested in some template class. Nothing to worry
4124 about here; there are no new template parameters for the nested
4130 error ("template specifiers not specified in declaration of %qD",
4135 parms = INNERMOST_TEMPLATE_PARMS (parms);
4136 tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
4138 if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
4140 error ("redeclared with %d template parameter(s)",
4141 TREE_VEC_LENGTH (parms));
4142 inform ("previous declaration %q+D used %d template parameter(s)",
4143 tmpl, TREE_VEC_LENGTH (tmpl_parms));
4147 for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
4154 if (TREE_VEC_ELT (tmpl_parms, i) == error_mark_node
4155 || TREE_VEC_ELT (parms, i) == error_mark_node)
4158 tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
4159 parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
4160 tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i));
4161 parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
4163 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
4165 if (tmpl_parm != error_mark_node
4166 && (TREE_CODE (tmpl_parm) != TREE_CODE (parm)
4167 || (TREE_CODE (tmpl_parm) != TYPE_DECL
4168 && !same_type_p (TREE_TYPE (tmpl_parm), TREE_TYPE (parm)))
4169 || (TREE_CODE (tmpl_parm) != PARM_DECL
4170 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm))
4171 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm))))
4172 || (TREE_CODE (tmpl_parm) == PARM_DECL
4173 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm))
4174 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm))))))
4176 error ("template parameter %q+#D", tmpl_parm);
4177 error ("redeclared here as %q#D", parm);
4181 if (tmpl_default != NULL_TREE && parm_default != NULL_TREE)
4183 /* We have in [temp.param]:
4185 A template-parameter may not be given default arguments
4186 by two different declarations in the same scope. */
4187 error ("redefinition of default argument for %q#D", parm);
4188 inform ("%Joriginal definition appeared here", tmpl_parm);
4192 if (parm_default != NULL_TREE)
4193 /* Update the previous template parameters (which are the ones
4194 that will really count) with the new default value. */
4195 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default;
4196 else if (tmpl_default != NULL_TREE)
4197 /* Update the new parameters, too; they'll be used as the
4198 parameters for any members. */
4199 TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default;
4205 /* Simplify EXPR if it is a non-dependent expression. Returns the
4206 (possibly simplified) expression. */
4209 fold_non_dependent_expr (tree expr)
4211 if (expr == NULL_TREE)
4214 /* If we're in a template, but EXPR isn't value dependent, simplify
4215 it. We're supposed to treat:
4217 template <typename T> void f(T[1 + 1]);
4218 template <typename T> void f(T[2]);
4220 as two declarations of the same function, for example. */
4221 if (processing_template_decl
4222 && !type_dependent_expression_p (expr)
4223 && !value_dependent_expression_p (expr))
4225 HOST_WIDE_INT saved_processing_template_decl;
4227 saved_processing_template_decl = processing_template_decl;
4228 processing_template_decl = 0;
4229 expr = tsubst_copy_and_build (expr,
4232 /*in_decl=*/NULL_TREE,
4233 /*function_p=*/false,
4234 /*integral_constant_expression_p=*/true);
4235 processing_template_decl = saved_processing_template_decl;
4240 /* EXPR is an expression which is used in a constant-expression context.
4241 For instance, it could be a VAR_DECL with a constant initializer.
4242 Extract the innest constant expression.
4244 This is basically a more powerful version of
4245 integral_constant_value, which can be used also in templates where
4246 initializers can maintain a syntactic rather than semantic form
4247 (even if they are non-dependent, for access-checking purposes). */
4250 fold_decl_constant_value (tree expr)
4252 tree const_expr = expr;
4255 expr = fold_non_dependent_expr (const_expr);
4256 const_expr = integral_constant_value (expr);
4258 while (expr != const_expr);
4263 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
4264 must be a function or a pointer-to-function type, as specified
4265 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
4266 and check that the resulting function has external linkage. */
4269 convert_nontype_argument_function (tree type, tree expr)
4274 fn = instantiate_type (type, fns, tf_none);
4275 if (fn == error_mark_node)
4276 return error_mark_node;
4279 if (TREE_CODE (fn_no_ptr) == ADDR_EXPR)
4280 fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0);
4281 if (TREE_CODE (fn_no_ptr) == BASELINK)
4282 fn_no_ptr = BASELINK_FUNCTIONS (fn_no_ptr);
4284 /* [temp.arg.nontype]/1
4286 A template-argument for a non-type, non-template template-parameter
4289 -- the address of an object or function with external linkage. */
4290 if (!DECL_EXTERNAL_LINKAGE_P (fn_no_ptr))
4292 error ("%qE is not a valid template argument for type %qT "
4293 "because function %qD has not external linkage",
4294 expr, type, fn_no_ptr);
4301 /* Attempt to convert the non-type template parameter EXPR to the
4302 indicated TYPE. If the conversion is successful, return the
4303 converted value. If the conversion is unsuccessful, return
4304 NULL_TREE if we issued an error message, or error_mark_node if we
4305 did not. We issue error messages for out-and-out bad template
4306 parameters, but not simply because the conversion failed, since we
4307 might be just trying to do argument deduction. Both TYPE and EXPR
4308 must be non-dependent.
4310 The conversion follows the special rules described in
4311 [temp.arg.nontype], and it is much more strict than an implicit
4314 This function is called twice for each template argument (see
4315 lookup_template_class for a more accurate description of this
4316 problem). This means that we need to handle expressions which
4317 are not valid in a C++ source, but can be created from the
4318 first call (for instance, casts to perform conversions). These
4319 hacks can go away after we fix the double coercion problem. */
4322 convert_nontype_argument (tree type, tree expr)
4326 /* Detect immediately string literals as invalid non-type argument.
4327 This special-case is not needed for correctness (we would easily
4328 catch this later), but only to provide better diagnostic for this
4329 common user mistake. As suggested by DR 100, we do not mention
4330 linkage issues in the diagnostic as this is not the point. */
4331 if (TREE_CODE (expr) == STRING_CST)
4333 error ("%qE is not a valid template argument for type %qT "
4334 "because string literals can never be used in this context",
4339 /* If we are in a template, EXPR may be non-dependent, but still
4340 have a syntactic, rather than semantic, form. For example, EXPR
4341 might be a SCOPE_REF, rather than the VAR_DECL to which the
4342 SCOPE_REF refers. Preserving the qualifying scope is necessary
4343 so that access checking can be performed when the template is
4344 instantiated -- but here we need the resolved form so that we can
4345 convert the argument. */
4346 expr = fold_non_dependent_expr (expr);
4347 if (error_operand_p (expr))
4348 return error_mark_node;
4349 expr_type = TREE_TYPE (expr);
4351 /* HACK: Due to double coercion, we can get a
4352 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
4353 which is the tree that we built on the first call (see
4354 below when coercing to reference to object or to reference to
4355 function). We just strip everything and get to the arg.
4356 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
4358 if (TREE_CODE (expr) == NOP_EXPR)
4360 if (TYPE_REF_OBJ_P (type) || TYPE_REFFN_P (type))
4362 /* ??? Maybe we could use convert_from_reference here, but we
4363 would need to relax its constraints because the NOP_EXPR
4364 could actually change the type to something more cv-qualified,
4365 and this is not folded by convert_from_reference. */
4366 tree addr = TREE_OPERAND (expr, 0);
4367 gcc_assert (TREE_CODE (expr_type) == REFERENCE_TYPE);
4368 gcc_assert (TREE_CODE (addr) == ADDR_EXPR);
4369 gcc_assert (TREE_CODE (TREE_TYPE (addr)) == POINTER_TYPE);
4370 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4371 (TREE_TYPE (expr_type),
4372 TREE_TYPE (TREE_TYPE (addr))));
4374 expr = TREE_OPERAND (addr, 0);
4375 expr_type = TREE_TYPE (expr);
4378 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
4379 parameter is a pointer to object, through decay and
4380 qualification conversion. Let's strip everything. */
4381 else if (TYPE_PTROBV_P (type))
4384 gcc_assert (TREE_CODE (expr) == ADDR_EXPR);
4385 gcc_assert (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE);
4386 /* Skip the ADDR_EXPR only if it is part of the decay for
4387 an array. Otherwise, it is part of the original argument
4388 in the source code. */
4389 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == ARRAY_TYPE)
4390 expr = TREE_OPERAND (expr, 0);
4391 expr_type = TREE_TYPE (expr);
4395 /* [temp.arg.nontype]/5, bullet 1
4397 For a non-type template-parameter of integral or enumeration type,
4398 integral promotions (_conv.prom_) and integral conversions
4399 (_conv.integral_) are applied. */
4400 if (INTEGRAL_TYPE_P (type))
4402 if (!INTEGRAL_TYPE_P (expr_type))
4403 return error_mark_node;
4405 expr = fold_decl_constant_value (expr);
4406 /* Notice that there are constant expressions like '4 % 0' which
4407 do not fold into integer constants. */
4408 if (TREE_CODE (expr) != INTEGER_CST)
4410 error ("%qE is not a valid template argument for type %qT "
4411 "because it is a non-constant expression", expr, type);
4415 /* At this point, an implicit conversion does what we want,
4416 because we already know that the expression is of integral
4418 expr = ocp_convert (type, expr, CONV_IMPLICIT, LOOKUP_PROTECT);
4419 if (expr == error_mark_node)
4420 return error_mark_node;
4422 /* Conversion was allowed: fold it to a bare integer constant. */
4425 /* [temp.arg.nontype]/5, bullet 2
4427 For a non-type template-parameter of type pointer to object,
4428 qualification conversions (_conv.qual_) and the array-to-pointer
4429 conversion (_conv.array_) are applied. */
4430 else if (TYPE_PTROBV_P (type))
4432 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
4434 A template-argument for a non-type, non-template template-parameter
4435 shall be one of: [...]
4437 -- the name of a non-type template-parameter;
4438 -- the address of an object or function with external linkage, [...]
4439 expressed as "& id-expression" where the & is optional if the name
4440 refers to a function or array, or if the corresponding
4441 template-parameter is a reference.
4443 Here, we do not care about functions, as they are invalid anyway
4444 for a parameter of type pointer-to-object. */
4446 if (DECL_P (expr) && DECL_TEMPLATE_PARM_P (expr))
4447 /* Non-type template parameters are OK. */
4449 else if (TREE_CODE (expr) != ADDR_EXPR
4450 && TREE_CODE (expr_type) != ARRAY_TYPE)
4452 if (TREE_CODE (expr) == VAR_DECL)
4454 error ("%qD is not a valid template argument "
4455 "because %qD is a variable, not the address of "
4460 /* Other values, like integer constants, might be valid
4461 non-type arguments of some other type. */
4462 return error_mark_node;
4468 decl = ((TREE_CODE (expr) == ADDR_EXPR)
4469 ? TREE_OPERAND (expr, 0) : expr);
4470 if (TREE_CODE (decl) != VAR_DECL)
4472 error ("%qE is not a valid template argument of type %qT "
4473 "because %qE is not a variable",
4477 else if (!DECL_EXTERNAL_LINKAGE_P (decl))
4479 error ("%qE is not a valid template argument of type %qT "
4480 "because %qD does not have external linkage",
4486 expr = decay_conversion (expr);
4487 if (expr == error_mark_node)
4488 return error_mark_node;
4490 expr = perform_qualification_conversions (type, expr);
4491 if (expr == error_mark_node)
4492 return error_mark_node;
4494 /* [temp.arg.nontype]/5, bullet 3
4496 For a non-type template-parameter of type reference to object, no
4497 conversions apply. The type referred to by the reference may be more
4498 cv-qualified than the (otherwise identical) type of the
4499 template-argument. The template-parameter is bound directly to the
4500 template-argument, which must be an lvalue. */
4501 else if (TYPE_REF_OBJ_P (type))
4503 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type),
4505 return error_mark_node;
4507 if (!at_least_as_qualified_p (TREE_TYPE (type), expr_type))
4509 error ("%qE is not a valid template argument for type %qT "
4510 "because of conflicts in cv-qualification", expr, type);
4514 if (!real_lvalue_p (expr))
4516 error ("%qE is not a valid template argument for type %qT "
4517 "because it is not an lvalue", expr, type);
4521 /* [temp.arg.nontype]/1
4523 A template-argument for a non-type, non-template template-parameter
4524 shall be one of: [...]
4526 -- the address of an object or function with external linkage. */
4527 if (!DECL_EXTERNAL_LINKAGE_P (expr))
4529 error ("%qE is not a valid template argument for type %qT "
4530 "because object %qD has not external linkage",
4535 expr = build_nop (type, build_address (expr));
4537 /* [temp.arg.nontype]/5, bullet 4
4539 For a non-type template-parameter of type pointer to function, only
4540 the function-to-pointer conversion (_conv.func_) is applied. If the
4541 template-argument represents a set of overloaded functions (or a
4542 pointer to such), the matching function is selected from the set
4544 else if (TYPE_PTRFN_P (type))
4546 /* If the argument is a template-id, we might not have enough
4547 context information to decay the pointer. */
4548 if (!type_unknown_p (expr_type))
4550 expr = decay_conversion (expr);
4551 if (expr == error_mark_node)
4552 return error_mark_node;
4555 expr = convert_nontype_argument_function (type, expr);
4556 if (!expr || expr == error_mark_node)
4559 /* [temp.arg.nontype]/5, bullet 5
4561 For a non-type template-parameter of type reference to function, no
4562 conversions apply. If the template-argument represents a set of
4563 overloaded functions, the matching function is selected from the set
4565 else if (TYPE_REFFN_P (type))
4567 if (TREE_CODE (expr) == ADDR_EXPR)
4569 error ("%qE is not a valid template argument for type %qT "
4570 "because it is a pointer", expr, type);
4571 inform ("try using %qE instead", TREE_OPERAND (expr, 0));
4575 expr = convert_nontype_argument_function (TREE_TYPE (type), expr);
4576 if (!expr || expr == error_mark_node)
4579 expr = build_nop (type, build_address (expr));
4581 /* [temp.arg.nontype]/5, bullet 6
4583 For a non-type template-parameter of type pointer to member function,
4584 no conversions apply. If the template-argument represents a set of
4585 overloaded member functions, the matching member function is selected
4586 from the set (_over.over_). */
4587 else if (TYPE_PTRMEMFUNC_P (type))
4589 expr = instantiate_type (type, expr, tf_none);
4590 if (expr == error_mark_node)
4591 return error_mark_node;
4593 /* There is no way to disable standard conversions in
4594 resolve_address_of_overloaded_function (called by
4595 instantiate_type). It is possible that the call succeeded by
4596 converting &B::I to &D::I (where B is a base of D), so we need
4597 to reject this conversion here.
4599 Actually, even if there was a way to disable standard conversions,
4600 it would still be better to reject them here so that we can
4601 provide a superior diagnostic. */
4602 if (!same_type_p (TREE_TYPE (expr), type))
4604 /* Make sure we are just one standard conversion off. */
4605 gcc_assert (can_convert (type, TREE_TYPE (expr)));
4606 error ("%qE is not a valid template argument for type %qT "
4607 "because it is of type %qT", expr, type,
4609 inform ("standard conversions are not allowed in this context");
4613 /* [temp.arg.nontype]/5, bullet 7
4615 For a non-type template-parameter of type pointer to data member,
4616 qualification conversions (_conv.qual_) are applied. */
4617 else if (TYPE_PTRMEM_P (type))
4619 expr = perform_qualification_conversions (type, expr);
4620 if (expr == error_mark_node)
4623 /* A template non-type parameter must be one of the above. */
4627 /* Sanity check: did we actually convert the argument to the
4629 gcc_assert (same_type_p (type, TREE_TYPE (expr)));
4634 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
4635 template template parameters. Both PARM_PARMS and ARG_PARMS are
4636 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
4639 Consider the example:
4640 template <class T> class A;
4641 template<template <class U> class TT> class B;
4643 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
4644 the parameters to A, and OUTER_ARGS contains A. */
4647 coerce_template_template_parms (tree parm_parms,
4649 tsubst_flags_t complain,
4653 int nparms, nargs, i;
4656 gcc_assert (TREE_CODE (parm_parms) == TREE_VEC);
4657 gcc_assert (TREE_CODE (arg_parms) == TREE_VEC);
4659 nparms = TREE_VEC_LENGTH (parm_parms);
4660 nargs = TREE_VEC_LENGTH (arg_parms);
4662 if (nargs != nparms)
4665 for (i = 0; i < nparms; ++i)
4667 if (TREE_VEC_ELT (parm_parms, i) == error_mark_node
4668 || TREE_VEC_ELT (arg_parms, i) == error_mark_node)
4671 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
4672 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
4674 if (arg == NULL_TREE || arg == error_mark_node
4675 || parm == NULL_TREE || parm == error_mark_node)
4678 if (TREE_CODE (arg) != TREE_CODE (parm))
4681 switch (TREE_CODE (parm))
4684 /* We encounter instantiations of templates like
4685 template <template <template <class> class> class TT>
4688 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
4689 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
4691 if (!coerce_template_template_parms
4692 (parmparm, argparm, complain, in_decl, outer_args))
4698 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm))
4699 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg)))
4700 /* One is a parameter pack, the other is not. */
4705 /* The tsubst call is used to handle cases such as
4707 template <int> class C {};
4708 template <class T, template <T> class TT> class D {};
4711 i.e. the parameter list of TT depends on earlier parameters. */
4712 if (!dependent_type_p (TREE_TYPE (arg))
4714 (tsubst (TREE_TYPE (parm), outer_args, complain, in_decl),
4718 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm))
4719 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg)))
4720 /* One is a parameter pack, the other is not. */
4731 /* Verifies that the deduced template arguments (in TARGS) for the
4732 template template parameters (in TPARMS) represent valid bindings,
4733 by comparing the template parameter list of each template argument
4734 to the template parameter list of its corresponding template
4735 template parameter, in accordance with DR150. This
4736 routine can only be called after all template arguments have been
4737 deduced. It will return TRUE if all of the template template
4738 parameter bindings are okay, FALSE otherwise. */
4740 template_template_parm_bindings_ok_p (tree tparms, tree targs)
4742 int i, ntparms = TREE_VEC_LENGTH (tparms);
4744 targs = INNERMOST_TEMPLATE_ARGS (targs);
4746 for (i = 0; i < ntparms; ++i)
4748 tree tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
4749 tree targ = TREE_VEC_ELT (targs, i);
4751 if (TREE_CODE (tparm) == TEMPLATE_DECL && targ)
4753 tree packed_args = NULL_TREE;
4756 if (ARGUMENT_PACK_P (targ))
4758 /* Look inside the argument pack. */
4759 packed_args = ARGUMENT_PACK_ARGS (targ);
4760 len = TREE_VEC_LENGTH (packed_args);
4763 for (idx = 0; idx < len; ++idx)
4765 tree targ_parms = NULL_TREE;
4768 /* Extract the next argument from the argument
4770 targ = TREE_VEC_ELT (packed_args, idx);
4772 if (PACK_EXPANSION_P (targ))
4773 /* Look at the pattern of the pack expansion. */
4774 targ = PACK_EXPANSION_PATTERN (targ);
4776 /* Extract the template parameters from the template
4778 if (TREE_CODE (targ) == TEMPLATE_DECL)
4779 targ_parms = DECL_INNERMOST_TEMPLATE_PARMS (targ);
4780 else if (TREE_CODE (targ) == TEMPLATE_TEMPLATE_PARM)
4781 targ_parms = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ));
4783 /* Verify that we can coerce the template template
4784 parameters from the template argument to the template
4785 parameter. This requires an exact match. */
4787 && !coerce_template_template_parms
4788 (DECL_INNERMOST_TEMPLATE_PARMS (tparm),
4798 /* Everything is okay. */
4802 /* Convert the indicated template ARG as necessary to match the
4803 indicated template PARM. Returns the converted ARG, or
4804 error_mark_node if the conversion was unsuccessful. Error and
4805 warning messages are issued under control of COMPLAIN. This
4806 conversion is for the Ith parameter in the parameter list. ARGS is
4807 the full set of template arguments deduced so far. */
4810 convert_template_argument (tree parm,
4813 tsubst_flags_t complain,
4819 int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
4821 if (TREE_CODE (arg) == TREE_LIST
4822 && TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF)
4824 /* The template argument was the name of some
4825 member function. That's usually
4826 invalid, but static members are OK. In any
4827 case, grab the underlying fields/functions
4828 and issue an error later if required. */
4829 orig_arg = TREE_VALUE (arg);
4830 TREE_TYPE (arg) = unknown_type_node;
4835 requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
4836 requires_type = (TREE_CODE (parm) == TYPE_DECL
4837 || requires_tmpl_type);
4839 /* When determining whether an argument pack expansion is a template,
4840 look at the pattern. */
4841 if (TREE_CODE (arg) == TYPE_PACK_EXPANSION)
4842 arg = PACK_EXPANSION_PATTERN (arg);
4845 ((TREE_CODE (arg) == TEMPLATE_DECL
4846 && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
4847 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4848 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
4851 && (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4852 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE))
4853 arg = TYPE_STUB_DECL (arg);
4855 is_type = TYPE_P (arg) || is_tmpl_type;
4857 if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
4858 && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
4860 pedwarn ("to refer to a type member of a template parameter, "
4861 "use %<typename %E%>", orig_arg);
4863 orig_arg = make_typename_type (TREE_OPERAND (arg, 0),
4864 TREE_OPERAND (arg, 1),
4866 complain & tf_error);
4870 if (is_type != requires_type)
4874 if (complain & tf_error)
4876 error ("type/value mismatch at argument %d in template "
4877 "parameter list for %qD",
4880 error (" expected a constant of type %qT, got %qT",
4882 (DECL_P (arg) ? DECL_NAME (arg) : orig_arg));
4883 else if (requires_tmpl_type)
4884 error (" expected a class template, got %qE", orig_arg);
4886 error (" expected a type, got %qE", orig_arg);
4889 return error_mark_node;
4891 if (is_tmpl_type ^ requires_tmpl_type)
4893 if (in_decl && (complain & tf_error))
4895 error ("type/value mismatch at argument %d in template "
4896 "parameter list for %qD",
4899 error (" expected a type, got %qT", DECL_NAME (arg));
4901 error (" expected a class template, got %qT", orig_arg);
4903 return error_mark_node;
4908 if (requires_tmpl_type)
4910 if (TREE_CODE (TREE_TYPE (arg)) == UNBOUND_CLASS_TEMPLATE)
4911 /* The number of argument required is not known yet.
4912 Just accept it for now. */
4913 val = TREE_TYPE (arg);
4916 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
4919 argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
4921 if (coerce_template_template_parms (parmparm, argparm,
4927 /* TEMPLATE_TEMPLATE_PARM node is preferred over
4929 if (val != error_mark_node)
4931 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val))
4932 val = TREE_TYPE (val);
4933 else if (TREE_CODE (val) == TYPE_PACK_EXPANSION
4934 && DECL_TEMPLATE_TEMPLATE_PARM_P (arg))
4936 val = TREE_TYPE (arg);
4937 val = make_pack_expansion (val);
4943 if (in_decl && (complain & tf_error))
4945 error ("type/value mismatch at argument %d in "
4946 "template parameter list for %qD",
4948 error (" expected a template of type %qD, got %qD",
4952 val = error_mark_node;
4958 /* We only form one instance of each template specialization.
4959 Therefore, if we use a non-canonical variant (i.e., a
4960 typedef), any future messages referring to the type will use
4961 the typedef, which is confusing if those future uses do not
4962 themselves also use the typedef. */
4964 val = canonical_type_variant (val);
4968 tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl);
4970 if (invalid_nontype_parm_type_p (t, complain))
4971 return error_mark_node;
4973 if (!uses_template_parms (orig_arg) && !uses_template_parms (t))
4974 /* We used to call digest_init here. However, digest_init
4975 will report errors, which we don't want when complain
4976 is zero. More importantly, digest_init will try too
4977 hard to convert things: for example, `0' should not be
4978 converted to pointer type at this point according to
4979 the standard. Accepting this is not merely an
4980 extension, since deciding whether or not these
4981 conversions can occur is part of determining which
4982 function template to call, or whether a given explicit
4983 argument specification is valid. */
4984 val = convert_nontype_argument (t, orig_arg);
4988 if (val == NULL_TREE)
4989 val = error_mark_node;
4990 else if (val == error_mark_node && (complain & tf_error))
4991 error ("could not convert template argument %qE to %qT", orig_arg, t);
4997 /* Coerces the remaining template arguments in INNER_ARGS (from
4998 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
4999 Returns the coerced argument pack. PARM_IDX is the position of this
5000 parameter in the template parameter list. ARGS is the original
5001 template argument list. */
5003 coerce_template_parameter_pack (tree parms,
5011 tsubst_flags_t complain)
5013 tree parm = TREE_VEC_ELT (parms, parm_idx);
5014 int nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
5017 tree packed_types = NULL_TREE;
5019 if (arg_idx > nargs)
5022 packed_args = make_tree_vec (nargs - arg_idx);
5024 if (TREE_CODE (TREE_VALUE (parm)) == PARM_DECL
5025 && uses_parameter_packs (TREE_TYPE (TREE_VALUE (parm))))
5027 /* When the template parameter is a non-type template
5028 parameter pack whose type uses parameter packs, we need
5029 to look at each of the template arguments
5030 separately. Build a vector of the types for these
5031 non-type template parameters in PACKED_TYPES. */
5033 = make_pack_expansion (TREE_TYPE (TREE_VALUE (parm)));
5034 packed_types = tsubst_pack_expansion (expansion, args,
5037 if (packed_types == error_mark_node)
5038 return error_mark_node;
5040 /* Check that we have the right number of arguments. */
5042 && !PACK_EXPANSION_P (TREE_VEC_ELT (inner_args, arg_idx))
5043 && nargs - arg_idx != TREE_VEC_LENGTH (packed_types))
5046 = TREE_VEC_LENGTH (parms) - 1 + TREE_VEC_LENGTH (packed_types);
5047 error ("wrong number of template arguments (%d, should be %d)",
5048 nargs, needed_parms);
5049 return error_mark_node;
5052 /* If we aren't able to check the actual arguments now
5053 (because they haven't been expanded yet), we can at least
5054 verify that all of the types used for the non-type
5055 template parameter pack are, in fact, valid for non-type
5056 template parameters. */
5058 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args, arg_idx)))
5060 int j, len = TREE_VEC_LENGTH (packed_types);
5061 for (j = 0; j < len; ++j)
5063 tree t = TREE_VEC_ELT (packed_types, j);
5064 if (invalid_nontype_parm_type_p (t, complain))
5065 return error_mark_node;
5070 /* Convert the remaining arguments, which will be a part of the
5071 parameter pack "parm". */
5072 for (; arg_idx < nargs; ++arg_idx)
5074 tree arg = TREE_VEC_ELT (inner_args, arg_idx);
5075 tree actual_parm = TREE_VALUE (parm);
5077 if (packed_types && !PACK_EXPANSION_P (arg))
5079 /* When we have a vector of types (corresponding to the
5080 non-type template parameter pack that uses parameter
5081 packs in its type, as mention above), and the
5082 argument is not an expansion (which expands to a
5083 currently unknown number of arguments), clone the
5084 parm and give it the next type in PACKED_TYPES. */
5085 actual_parm = copy_node (actual_parm);
5086 TREE_TYPE (actual_parm) =
5087 TREE_VEC_ELT (packed_types, arg_idx - parm_idx);
5090 if (arg != error_mark_node)
5091 arg = convert_template_argument (actual_parm,
5092 arg, new_args, complain, parm_idx,
5094 if (arg == error_mark_node)
5096 TREE_VEC_ELT (packed_args, arg_idx - parm_idx) = arg;
5099 if (TREE_CODE (TREE_VALUE (parm)) == TYPE_DECL
5100 || TREE_CODE (TREE_VALUE (parm)) == TEMPLATE_DECL)
5101 argument_pack = make_node (TYPE_ARGUMENT_PACK);
5104 argument_pack = make_node (NONTYPE_ARGUMENT_PACK);
5105 TREE_TYPE (argument_pack)
5106 = tsubst (TREE_TYPE (TREE_VALUE (parm)), new_args, complain, in_decl);
5107 TREE_CONSTANT (argument_pack) = 1;
5110 SET_ARGUMENT_PACK_ARGS (argument_pack, packed_args);
5111 return argument_pack;
5114 /* Convert all template arguments to their appropriate types, and
5115 return a vector containing the innermost resulting template
5116 arguments. If any error occurs, return error_mark_node. Error and
5117 warning messages are issued under control of COMPLAIN.
5119 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
5120 for arguments not specified in ARGS. Otherwise, if
5121 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
5122 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
5123 USE_DEFAULT_ARGS is false, then all arguments must be specified in
5127 coerce_template_parms (tree parms,
5130 tsubst_flags_t complain,
5131 bool require_all_args,
5132 bool use_default_args)
5134 int nparms, nargs, parm_idx, arg_idx, lost = 0;
5137 tree new_inner_args;
5138 bool saved_skip_evaluation;
5140 /* When used as a boolean value, indicates whether this is a
5141 variadic template parameter list. Since it's an int, we can also
5142 subtract it from nparms to get the number of non-variadic
5147 = expand_template_argument_pack (INNERMOST_TEMPLATE_ARGS (args));
5149 nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
5150 nparms = TREE_VEC_LENGTH (parms);
5152 /* Determine if there are any parameter packs. */
5153 for (parm_idx = 0; parm_idx < nparms; ++parm_idx)
5155 tree tparm = TREE_VALUE (TREE_VEC_ELT (parms, parm_idx));
5156 if (template_parameter_pack_p (tparm))
5163 if ((nargs > nparms - variadic_p && !variadic_p)
5164 || (nargs < nparms - variadic_p
5166 && (!use_default_args
5167 || (TREE_VEC_ELT (parms, nargs) != error_mark_node
5168 && !TREE_PURPOSE (TREE_VEC_ELT (parms, nargs))))))
5170 if (complain & tf_error)
5172 const char *or_more = "";
5175 or_more = " or more";
5179 error ("wrong number of template arguments (%d, should be %d%s)",
5180 nargs, nparms, or_more);
5183 error ("provided for %q+D", in_decl);
5186 return error_mark_node;
5189 /* We need to evaluate the template arguments, even though this
5190 template-id may be nested within a "sizeof". */
5191 saved_skip_evaluation = skip_evaluation;
5192 skip_evaluation = false;
5193 new_inner_args = make_tree_vec (nparms);
5194 new_args = add_outermost_template_args (args, new_inner_args);
5195 for (parm_idx = 0, arg_idx = 0; parm_idx < nparms; parm_idx++, arg_idx++)
5200 /* Get the Ith template parameter. */
5201 parm = TREE_VEC_ELT (parms, parm_idx);
5203 if (parm == error_mark_node)
5205 TREE_VEC_ELT (new_inner_args, arg_idx) = error_mark_node;
5209 /* Calculate the next argument. */
5210 if (template_parameter_pack_p (TREE_VALUE (parm)))
5212 /* All remaining arguments will be placed in the
5213 template parameter pack PARM. */
5214 arg = coerce_template_parameter_pack (parms, parm_idx, args,
5215 inner_args, arg_idx,
5219 /* Store this argument. */
5220 if (arg == error_mark_node)
5222 TREE_VEC_ELT (new_inner_args, parm_idx) = arg;
5224 /* We are done with all of the arguments. */
5229 else if (arg_idx < nargs)
5231 arg = TREE_VEC_ELT (inner_args, arg_idx);
5233 if (arg && PACK_EXPANSION_P (arg))
5235 if (complain & tf_error)
5237 /* If ARG is a pack expansion, but PARM is not a
5238 template parameter pack (if it were, we would have
5239 handled it above), we're trying to expand into a
5240 fixed-length argument list. */
5241 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
5242 error ("cannot expand %<%E%> into a fixed-length "
5243 "argument list", arg);
5245 error ("cannot expand %<%T%> into a fixed-length "
5246 "argument list", arg);
5248 return error_mark_node;
5251 else if (require_all_args)
5252 /* There must be a default arg in this case. */
5253 arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
5258 if (arg == error_mark_node)
5260 if (complain & tf_error)
5261 error ("template argument %d is invalid", arg_idx + 1);
5264 /* This only occurs if there was an error in the template
5265 parameter list itself (which we would already have
5266 reported) that we are trying to recover from, e.g., a class
5267 template with a parameter list such as
5268 template<typename..., typename>. */
5269 return error_mark_node;
5271 arg = convert_template_argument (TREE_VALUE (parm),
5272 arg, new_args, complain,
5275 if (arg == error_mark_node)
5277 TREE_VEC_ELT (new_inner_args, arg_idx) = arg;
5279 skip_evaluation = saved_skip_evaluation;
5282 return error_mark_node;
5284 return new_inner_args;
5287 /* Returns 1 if template args OT and NT are equivalent. */
5290 template_args_equal (tree ot, tree nt)
5295 if (TREE_CODE (nt) == TREE_VEC)
5296 /* For member templates */
5297 return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt);
5298 else if (PACK_EXPANSION_P (ot))
5299 return PACK_EXPANSION_P (nt)
5300 && template_args_equal (PACK_EXPANSION_PATTERN (ot),
5301 PACK_EXPANSION_PATTERN (nt));
5302 else if (TYPE_P (nt))
5303 return TYPE_P (ot) && same_type_p (ot, nt);
5304 else if (TREE_CODE (ot) == TREE_VEC || TYPE_P (ot))
5307 return cp_tree_equal (ot, nt);
5310 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
5311 of template arguments. Returns 0 otherwise. */
5314 comp_template_args (tree oldargs, tree newargs)
5318 oldargs = expand_template_argument_pack (oldargs);
5319 newargs = expand_template_argument_pack (newargs);
5321 if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
5324 for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
5326 tree nt = TREE_VEC_ELT (newargs, i);
5327 tree ot = TREE_VEC_ELT (oldargs, i);
5329 if (! template_args_equal (ot, nt))
5336 add_pending_template (tree d)
5338 tree ti = (TYPE_P (d)
5339 ? CLASSTYPE_TEMPLATE_INFO (d)
5340 : DECL_TEMPLATE_INFO (d));
5341 struct pending_template *pt;
5344 if (TI_PENDING_TEMPLATE_FLAG (ti))
5347 /* We are called both from instantiate_decl, where we've already had a
5348 tinst_level pushed, and instantiate_template, where we haven't.
5350 level = !current_tinst_level || current_tinst_level->decl != d;
5353 push_tinst_level (d);
5355 pt = GGC_NEW (struct pending_template);
5357 pt->tinst = current_tinst_level;
5358 if (last_pending_template)
5359 last_pending_template->next = pt;
5361 pending_templates = pt;
5363 last_pending_template = pt;
5365 TI_PENDING_TEMPLATE_FLAG (ti) = 1;
5372 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
5373 ARGLIST. Valid choices for FNS are given in the cp-tree.def
5374 documentation for TEMPLATE_ID_EXPR. */
5377 lookup_template_function (tree fns, tree arglist)
5381 if (fns == error_mark_node || arglist == error_mark_node)
5382 return error_mark_node;
5384 gcc_assert (!arglist || TREE_CODE (arglist) == TREE_VEC);
5385 gcc_assert (fns && (is_overloaded_fn (fns)
5386 || TREE_CODE (fns) == IDENTIFIER_NODE));
5388 if (BASELINK_P (fns))
5390 BASELINK_FUNCTIONS (fns) = build2 (TEMPLATE_ID_EXPR,
5392 BASELINK_FUNCTIONS (fns),
5397 type = TREE_TYPE (fns);
5398 if (TREE_CODE (fns) == OVERLOAD || !type)
5399 type = unknown_type_node;
5401 return build2 (TEMPLATE_ID_EXPR, type, fns, arglist);
5404 /* Within the scope of a template class S<T>, the name S gets bound
5405 (in build_self_reference) to a TYPE_DECL for the class, not a
5406 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
5407 or one of its enclosing classes, and that type is a template,
5408 return the associated TEMPLATE_DECL. Otherwise, the original
5409 DECL is returned. */
5412 maybe_get_template_decl_from_type_decl (tree decl)
5414 return (decl != NULL_TREE
5415 && TREE_CODE (decl) == TYPE_DECL
5416 && DECL_ARTIFICIAL (decl)
5417 && CLASS_TYPE_P (TREE_TYPE (decl))
5418 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
5419 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl;
5422 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
5423 parameters, find the desired type.
5425 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
5427 IN_DECL, if non-NULL, is the template declaration we are trying to
5430 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
5431 the class we are looking up.
5433 Issue error and warning messages under control of COMPLAIN.
5435 If the template class is really a local class in a template
5436 function, then the FUNCTION_CONTEXT is the function in which it is
5439 ??? Note that this function is currently called *twice* for each
5440 template-id: the first time from the parser, while creating the
5441 incomplete type (finish_template_type), and the second type during the
5442 real instantiation (instantiate_template_class). This is surely something
5443 that we want to avoid. It also causes some problems with argument
5444 coercion (see convert_nontype_argument for more information on this). */
5447 lookup_template_class (tree d1,
5452 tsubst_flags_t complain)
5454 tree template = NULL_TREE, parmlist;
5457 timevar_push (TV_NAME_LOOKUP);
5459 if (TREE_CODE (d1) == IDENTIFIER_NODE)
5461 tree value = innermost_non_namespace_value (d1);
5462 if (value && DECL_TEMPLATE_TEMPLATE_PARM_P (value))
5467 push_decl_namespace (context);
5468 template = lookup_name (d1);
5469 template = maybe_get_template_decl_from_type_decl (template);
5471 pop_decl_namespace ();
5474 context = DECL_CONTEXT (template);
5476 else if (TREE_CODE (d1) == TYPE_DECL && MAYBE_CLASS_TYPE_P (TREE_TYPE (d1)))
5478 tree type = TREE_TYPE (d1);
5480 /* If we are declaring a constructor, say A<T>::A<T>, we will get
5481 an implicit typename for the second A. Deal with it. */
5482 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5483 type = TREE_TYPE (type);
5485 if (CLASSTYPE_TEMPLATE_INFO (type))
5487 template = CLASSTYPE_TI_TEMPLATE (type);
5488 d1 = DECL_NAME (template);
5491 else if (TREE_CODE (d1) == ENUMERAL_TYPE
5492 || (TYPE_P (d1) && MAYBE_CLASS_TYPE_P (d1)))
5494 template = TYPE_TI_TEMPLATE (d1);
5495 d1 = DECL_NAME (template);
5497 else if (TREE_CODE (d1) == TEMPLATE_DECL
5498 && TREE_CODE (DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL)
5501 d1 = DECL_NAME (template);
5502 context = DECL_CONTEXT (template);
5505 /* Issue an error message if we didn't find a template. */
5508 if (complain & tf_error)
5509 error ("%qT is not a template", d1);
5510 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5513 if (TREE_CODE (template) != TEMPLATE_DECL
5514 /* Make sure it's a user visible template, if it was named by
5516 || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (template)
5517 && !PRIMARY_TEMPLATE_P (template)))
5519 if (complain & tf_error)
5521 error ("non-template type %qT used as a template", d1);
5523 error ("for template declaration %q+D", in_decl);
5525 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5528 complain &= ~tf_user;
5530 if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
5532 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
5533 template arguments */
5539 parmlist = DECL_INNERMOST_TEMPLATE_PARMS (template);
5541 /* Consider an example where a template template parameter declared as
5543 template <class T, class U = std::allocator<T> > class TT
5545 The template parameter level of T and U are one level larger than
5546 of TT. To proper process the default argument of U, say when an
5547 instantiation `TT<int>' is seen, we need to build the full
5548 arguments containing {int} as the innermost level. Outer levels,
5549 available when not appearing as default template argument, can be
5550 obtained from the arguments of the enclosing template.
5552 Suppose that TT is later substituted with std::vector. The above
5553 instantiation is `TT<int, std::allocator<T> >' with TT at
5554 level 1, and T at level 2, while the template arguments at level 1
5555 becomes {std::vector} and the inner level 2 is {int}. */
5557 outer = DECL_CONTEXT (template);
5559 outer = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer)));
5560 else if (current_template_parms)
5561 /* This is an argument of the current template, so we haven't set
5562 DECL_CONTEXT yet. */
5563 outer = current_template_args ();
5566 arglist = add_to_template_args (outer, arglist);
5568 arglist2 = coerce_template_parms (parmlist, arglist, template,
5570 /*require_all_args=*/true,
5571 /*use_default_args=*/true);
5572 if (arglist2 == error_mark_node
5573 || (!uses_template_parms (arglist2)
5574 && check_instantiated_args (template, arglist2, complain)))
5575 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5577 parm = bind_template_template_parm (TREE_TYPE (template), arglist2);
5578 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, parm);
5582 tree template_type = TREE_TYPE (template);
5585 tree found = NULL_TREE;
5588 int is_partial_instantiation;
5590 gen_tmpl = most_general_template (template);
5591 parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
5592 parm_depth = TMPL_PARMS_DEPTH (parmlist);
5593 arg_depth = TMPL_ARGS_DEPTH (arglist);
5595 if (arg_depth == 1 && parm_depth > 1)
5597 /* We've been given an incomplete set of template arguments.
5600 template <class T> struct S1 {
5601 template <class U> struct S2 {};
5602 template <class U> struct S2<U*> {};
5605 we will be called with an ARGLIST of `U*', but the
5606 TEMPLATE will be `template <class T> template
5607 <class U> struct S1<T>::S2'. We must fill in the missing
5610 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)),
5612 arg_depth = TMPL_ARGS_DEPTH (arglist);
5615 /* Now we should have enough arguments. */
5616 gcc_assert (parm_depth == arg_depth);
5618 /* From here on, we're only interested in the most general
5620 template = gen_tmpl;
5622 /* Calculate the BOUND_ARGS. These will be the args that are
5623 actually tsubst'd into the definition to create the
5627 /* We have multiple levels of arguments to coerce, at once. */
5629 int saved_depth = TMPL_ARGS_DEPTH (arglist);
5631 tree bound_args = make_tree_vec (parm_depth);
5633 for (i = saved_depth,
5634 t = DECL_TEMPLATE_PARMS (template);
5635 i > 0 && t != NULL_TREE;
5636 --i, t = TREE_CHAIN (t))
5638 tree a = coerce_template_parms (TREE_VALUE (t),
5641 /*require_all_args=*/true,
5642 /*use_default_args=*/true);
5644 /* Don't process further if one of the levels fails. */
5645 if (a == error_mark_node)
5647 /* Restore the ARGLIST to its full size. */
5648 TREE_VEC_LENGTH (arglist) = saved_depth;
5649 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5652 SET_TMPL_ARGS_LEVEL (bound_args, i, a);
5654 /* We temporarily reduce the length of the ARGLIST so
5655 that coerce_template_parms will see only the arguments
5656 corresponding to the template parameters it is
5658 TREE_VEC_LENGTH (arglist)--;
5661 /* Restore the ARGLIST to its full size. */
5662 TREE_VEC_LENGTH (arglist) = saved_depth;
5664 arglist = bound_args;
5668 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist),
5669 INNERMOST_TEMPLATE_ARGS (arglist),
5672 /*require_all_args=*/true,
5673 /*use_default_args=*/true);
5675 if (arglist == error_mark_node)
5676 /* We were unable to bind the arguments. */
5677 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5679 /* In the scope of a template class, explicit references to the
5680 template class refer to the type of the template, not any
5681 instantiation of it. For example, in:
5683 template <class T> class C { void f(C<T>); }
5685 the `C<T>' is just the same as `C'. Outside of the
5686 class, however, such a reference is an instantiation. */
5687 if (comp_template_args (TYPE_TI_ARGS (template_type),
5690 found = template_type;
5692 if (!entering_scope && PRIMARY_TEMPLATE_P (template))
5696 for (ctx = current_class_type;
5697 ctx && TREE_CODE (ctx) != NAMESPACE_DECL;
5699 ? TYPE_CONTEXT (ctx)
5700 : DECL_CONTEXT (ctx)))
5701 if (TYPE_P (ctx) && same_type_p (ctx, template_type))
5704 /* We're not in the scope of the class, so the
5705 TEMPLATE_TYPE is not the type we want after all. */
5711 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
5713 /* If we already have this specialization, return it. */
5714 found = retrieve_specialization (template, arglist,
5715 /*class_specializations_p=*/false);
5717 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
5719 /* This type is a "partial instantiation" if any of the template
5720 arguments still involve template parameters. Note that we set
5721 IS_PARTIAL_INSTANTIATION for partial specializations as
5723 is_partial_instantiation = uses_template_parms (arglist);
5725 /* If the deduced arguments are invalid, then the binding
5727 if (!is_partial_instantiation
5728 && check_instantiated_args (template,
5729 INNERMOST_TEMPLATE_ARGS (arglist),
5731 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5733 if (!is_partial_instantiation
5734 && !PRIMARY_TEMPLATE_P (template)
5735 && TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL)
5737 found = xref_tag_from_type (TREE_TYPE (template),
5738 DECL_NAME (template),
5739 /*tag_scope=*/ts_global);
5740 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
5743 context = tsubst (DECL_CONTEXT (template), arglist,
5746 context = global_namespace;
5748 /* Create the type. */
5749 if (TREE_CODE (template_type) == ENUMERAL_TYPE)
5751 if (!is_partial_instantiation)
5753 set_current_access_from_decl (TYPE_NAME (template_type));
5754 t = start_enum (TYPE_IDENTIFIER (template_type));
5757 /* We don't want to call start_enum for this type, since
5758 the values for the enumeration constants may involve
5759 template parameters. And, no one should be interested
5760 in the enumeration constants for such a type. */
5761 t = make_node (ENUMERAL_TYPE);
5765 t = make_class_type (TREE_CODE (template_type));
5766 CLASSTYPE_DECLARED_CLASS (t)
5767 = CLASSTYPE_DECLARED_CLASS (template_type);
5768 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
5769 TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);
5771 /* A local class. Make sure the decl gets registered properly. */
5772 if (context == current_function_decl)
5773 pushtag (DECL_NAME (template), t, /*tag_scope=*/ts_current);
5775 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type), arglist))
5776 /* This instantiation is another name for the primary
5777 template type. Set the TYPE_CANONICAL field
5779 TYPE_CANONICAL (t) = template_type;
5780 else if (any_template_arguments_need_structural_equality_p (arglist))
5781 /* Some of the template arguments require structural
5782 equality testing, so this template class requires
5783 structural equality testing. */
5784 SET_TYPE_STRUCTURAL_EQUALITY (t);
5787 /* If we called start_enum or pushtag above, this information
5788 will already be set up. */
5791 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5793 type_decl = create_implicit_typedef (DECL_NAME (template), t);
5794 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
5795 TYPE_STUB_DECL (t) = type_decl;
5796 DECL_SOURCE_LOCATION (type_decl)
5797 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type));
5800 type_decl = TYPE_NAME (t);
5802 TREE_PRIVATE (type_decl)
5803 = TREE_PRIVATE (TYPE_STUB_DECL (template_type));
5804 TREE_PROTECTED (type_decl)
5805 = TREE_PROTECTED (TYPE_STUB_DECL (template_type));
5806 DECL_IN_SYSTEM_HEADER (type_decl)
5807 = DECL_IN_SYSTEM_HEADER (template);
5808 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type))
5810 DECL_VISIBILITY_SPECIFIED (type_decl) = 1;
5811 DECL_VISIBILITY (type_decl) = CLASSTYPE_VISIBILITY (template_type);
5814 /* Set up the template information. We have to figure out which
5815 template is the immediate parent if this is a full
5817 if (parm_depth == 1 || is_partial_instantiation
5818 || !PRIMARY_TEMPLATE_P (template))
5819 /* This case is easy; there are no member templates involved. */
5823 /* This is a full instantiation of a member template. Look
5824 for a partial instantiation of which this is an instance. */
5826 for (found = DECL_TEMPLATE_INSTANTIATIONS (template);
5827 found; found = TREE_CHAIN (found))
5830 tree tmpl = CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found));
5832 /* We only want partial instantiations, here, not
5833 specializations or full instantiations. */
5834 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found))
5835 || !uses_template_parms (TREE_VALUE (found)))
5838 /* Temporarily reduce by one the number of levels in the
5839 ARGLIST and in FOUND so as to avoid comparing the
5840 last set of arguments. */
5841 TREE_VEC_LENGTH (arglist)--;
5842 TREE_VEC_LENGTH (TREE_PURPOSE (found)) --;
5844 /* See if the arguments match. If they do, then TMPL is
5845 the partial instantiation we want. */
5846 success = comp_template_args (TREE_PURPOSE (found), arglist);
5848 /* Restore the argument vectors to their full size. */
5849 TREE_VEC_LENGTH (arglist)++;
5850 TREE_VEC_LENGTH (TREE_PURPOSE (found))++;
5861 /* There was no partial instantiation. This happens
5862 where C<T> is a member template of A<T> and it's used
5865 template <typename T> struct B { A<T>::C<int> m; };
5868 Create the partial instantiation.
5870 TREE_VEC_LENGTH (arglist)--;
5871 found = tsubst (template, arglist, complain, NULL_TREE);
5872 TREE_VEC_LENGTH (arglist)++;
5876 SET_TYPE_TEMPLATE_INFO (t, tree_cons (found, arglist, NULL_TREE));
5877 DECL_TEMPLATE_INSTANTIATIONS (template)
5878 = tree_cons (arglist, t,
5879 DECL_TEMPLATE_INSTANTIATIONS (template));
5881 if (TREE_CODE (t) == ENUMERAL_TYPE
5882 && !is_partial_instantiation)
5883 /* Now that the type has been registered on the instantiations
5884 list, we set up the enumerators. Because the enumeration
5885 constants may involve the enumeration type itself, we make
5886 sure to register the type first, and then create the
5887 constants. That way, doing tsubst_expr for the enumeration
5888 constants won't result in recursive calls here; we'll find
5889 the instantiation and exit above. */
5890 tsubst_enum (template_type, t, arglist);
5892 if (is_partial_instantiation)
5893 /* If the type makes use of template parameters, the
5894 code that generates debugging information will crash. */
5895 DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1;
5897 /* Possibly limit visibility based on template args. */
5898 TREE_PUBLIC (type_decl) = 1;
5899 determine_visibility (type_decl);
5901 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
5903 timevar_pop (TV_NAME_LOOKUP);
5910 /* True when we should also visit template parameters that occur in
5911 non-deduced contexts. */
5912 bool include_nondeduced_p;
5913 struct pointer_set_t *visited;
5916 /* Called from for_each_template_parm via walk_tree. */
5919 for_each_template_parm_r (tree *tp, int *walk_subtrees, void *d)
5922 struct pair_fn_data *pfd = (struct pair_fn_data *) d;
5923 tree_fn_t fn = pfd->fn;
5924 void *data = pfd->data;
5927 && (pfd->include_nondeduced_p || TREE_CODE (t) != TYPENAME_TYPE)
5928 && for_each_template_parm (TYPE_CONTEXT (t), fn, data, pfd->visited,
5929 pfd->include_nondeduced_p))
5930 return error_mark_node;
5932 switch (TREE_CODE (t))
5935 if (TYPE_PTRMEMFUNC_P (t))
5941 if (!TYPE_TEMPLATE_INFO (t))
5943 else if (for_each_template_parm (TREE_VALUE (TYPE_TEMPLATE_INFO (t)),
5944 fn, data, pfd->visited,
5945 pfd->include_nondeduced_p))
5946 return error_mark_node;
5950 if (for_each_template_parm (TYPE_MIN_VALUE (t),
5951 fn, data, pfd->visited,
5952 pfd->include_nondeduced_p)
5953 || for_each_template_parm (TYPE_MAX_VALUE (t),
5954 fn, data, pfd->visited,
5955 pfd->include_nondeduced_p))
5956 return error_mark_node;
5960 /* Since we're not going to walk subtrees, we have to do this
5962 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data,
5963 pfd->visited, pfd->include_nondeduced_p))
5964 return error_mark_node;
5968 /* Check the return type. */
5969 if (for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited,
5970 pfd->include_nondeduced_p))
5971 return error_mark_node;
5973 /* Check the parameter types. Since default arguments are not
5974 instantiated until they are needed, the TYPE_ARG_TYPES may
5975 contain expressions that involve template parameters. But,
5976 no-one should be looking at them yet. And, once they're
5977 instantiated, they don't contain template parameters, so
5978 there's no point in looking at them then, either. */
5982 for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm))
5983 if (for_each_template_parm (TREE_VALUE (parm), fn, data,
5984 pfd->visited, pfd->include_nondeduced_p))
5985 return error_mark_node;
5987 /* Since we've already handled the TYPE_ARG_TYPES, we don't
5988 want walk_tree walking into them itself. */
5994 if (pfd->include_nondeduced_p
5995 && for_each_template_parm (TYPE_FIELDS (t), fn, data,
5997 pfd->include_nondeduced_p))
5998 return error_mark_node;
6003 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
6004 && for_each_template_parm (DECL_TI_ARGS (t), fn, data,
6005 pfd->visited, pfd->include_nondeduced_p))
6006 return error_mark_node;
6011 if (TREE_CODE (t) == CONST_DECL && DECL_TEMPLATE_PARM_P (t)
6012 && for_each_template_parm (DECL_INITIAL (t), fn, data,
6013 pfd->visited, pfd->include_nondeduced_p))
6014 return error_mark_node;
6015 if (DECL_CONTEXT (t)
6016 && pfd->include_nondeduced_p
6017 && for_each_template_parm (DECL_CONTEXT (t), fn, data,
6018 pfd->visited, pfd->include_nondeduced_p))
6019 return error_mark_node;
6022 case BOUND_TEMPLATE_TEMPLATE_PARM:
6023 /* Record template parameters such as `T' inside `TT<T>'. */
6024 if (for_each_template_parm (TYPE_TI_ARGS (t), fn, data, pfd->visited,
6025 pfd->include_nondeduced_p))
6026 return error_mark_node;
6029 case TEMPLATE_TEMPLATE_PARM:
6030 case TEMPLATE_TYPE_PARM:
6031 case TEMPLATE_PARM_INDEX:
6032 if (fn && (*fn)(t, data))
6033 return error_mark_node;
6035 return error_mark_node;
6039 /* A template template parameter is encountered. */
6040 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)
6041 && for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited,
6042 pfd->include_nondeduced_p))
6043 return error_mark_node;
6045 /* Already substituted template template parameter */
6051 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t), fn,
6053 pfd->include_nondeduced_p))
6054 return error_mark_node;
6058 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))
6059 && pfd->include_nondeduced_p
6060 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
6061 (TREE_TYPE (t)), fn, data,
6062 pfd->visited, pfd->include_nondeduced_p))
6063 return error_mark_node;
6068 /* If there's no type, then this thing must be some expression
6069 involving template parameters. */
6070 if (!fn && !TREE_TYPE (t))
6071 return error_mark_node;
6076 case REINTERPRET_CAST_EXPR:
6077 case CONST_CAST_EXPR:
6078 case STATIC_CAST_EXPR:
6079 case DYNAMIC_CAST_EXPR:
6083 case PSEUDO_DTOR_EXPR:
6085 return error_mark_node;
6092 /* We didn't find any template parameters we liked. */
6096 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
6097 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
6098 call FN with the parameter and the DATA.
6099 If FN returns nonzero, the iteration is terminated, and
6100 for_each_template_parm returns 1. Otherwise, the iteration
6101 continues. If FN never returns a nonzero value, the value
6102 returned by for_each_template_parm is 0. If FN is NULL, it is
6103 considered to be the function which always returns 1.
6105 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
6106 parameters that occur in non-deduced contexts. When false, only
6107 visits those template parameters that can be deduced. */
6110 for_each_template_parm (tree t, tree_fn_t fn, void* data,
6111 struct pointer_set_t *visited,
6112 bool include_nondeduced_p)
6114 struct pair_fn_data pfd;
6120 pfd.include_nondeduced_p = include_nondeduced_p;
6122 /* Walk the tree. (Conceptually, we would like to walk without
6123 duplicates, but for_each_template_parm_r recursively calls
6124 for_each_template_parm, so we would need to reorganize a fair
6125 bit to use walk_tree_without_duplicates, so we keep our own
6128 pfd.visited = visited;
6130 pfd.visited = pointer_set_create ();
6131 result = cp_walk_tree (&t,
6132 for_each_template_parm_r,
6134 pfd.visited) != NULL_TREE;
6139 pointer_set_destroy (pfd.visited);
6146 /* Returns true if T depends on any template parameter. */
6149 uses_template_parms (tree t)
6152 int saved_processing_template_decl;
6154 saved_processing_template_decl = processing_template_decl;
6155 if (!saved_processing_template_decl)
6156 processing_template_decl = 1;
6158 dependent_p = dependent_type_p (t);
6159 else if (TREE_CODE (t) == TREE_VEC)
6160 dependent_p = any_dependent_template_arguments_p (t);
6161 else if (TREE_CODE (t) == TREE_LIST)
6162 dependent_p = (uses_template_parms (TREE_VALUE (t))
6163 || uses_template_parms (TREE_CHAIN (t)));
6164 else if (TREE_CODE (t) == TYPE_DECL)
6165 dependent_p = dependent_type_p (TREE_TYPE (t));
6168 || TREE_CODE (t) == TEMPLATE_PARM_INDEX
6169 || TREE_CODE (t) == OVERLOAD
6170 || TREE_CODE (t) == BASELINK
6171 || TREE_CODE (t) == IDENTIFIER_NODE
6172 || TREE_CODE (t) == TRAIT_EXPR
6173 || CONSTANT_CLASS_P (t))
6174 dependent_p = (type_dependent_expression_p (t)
6175 || value_dependent_expression_p (t));
6178 gcc_assert (t == error_mark_node);
6179 dependent_p = false;
6182 processing_template_decl = saved_processing_template_decl;
6187 /* Returns true if T depends on any template parameter with level LEVEL. */
6190 uses_template_parms_level (tree t, int level)
6192 return for_each_template_parm (t, template_parm_this_level_p, &level, NULL,
6193 /*include_nondeduced_p=*/true);
6196 static int tinst_depth;
6197 extern int max_tinst_depth;
6198 #ifdef GATHER_STATISTICS
6201 static int tinst_level_tick;
6202 static int last_template_error_tick;
6204 /* We're starting to instantiate D; record the template instantiation context
6205 for diagnostics and to restore it later. */
6208 push_tinst_level (tree d)
6210 struct tinst_level *new;
6212 if (tinst_depth >= max_tinst_depth)
6214 /* If the instantiation in question still has unbound template parms,
6215 we don't really care if we can't instantiate it, so just return.
6216 This happens with base instantiation for implicit `typename'. */
6217 if (uses_template_parms (d))
6220 last_template_error_tick = tinst_level_tick;
6221 error ("template instantiation depth exceeds maximum of %d (use "
6222 "-ftemplate-depth-NN to increase the maximum) instantiating %qD",
6223 max_tinst_depth, d);
6225 print_instantiation_context ();
6230 new = GGC_NEW (struct tinst_level);
6232 new->locus = input_location;
6233 new->in_system_header_p = in_system_header;
6234 new->next = current_tinst_level;
6235 current_tinst_level = new;
6238 #ifdef GATHER_STATISTICS
6239 if (tinst_depth > depth_reached)
6240 depth_reached = tinst_depth;
6247 /* We're done instantiating this template; return to the instantiation
6251 pop_tinst_level (void)
6253 /* Restore the filename and line number stashed away when we started
6254 this instantiation. */
6255 input_location = current_tinst_level->locus;
6256 in_system_header = current_tinst_level->in_system_header_p;
6257 current_tinst_level = current_tinst_level->next;
6262 /* We're instantiating a deferred template; restore the template
6263 instantiation context in which the instantiation was requested, which
6264 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
6267 reopen_tinst_level (struct tinst_level *level)
6269 struct tinst_level *t;
6272 for (t = level; t; t = t->next)
6275 current_tinst_level = level;
6280 /* Returns the TINST_LEVEL which gives the original instantiation
6283 struct tinst_level *
6284 outermost_tinst_level (void)
6286 struct tinst_level *level = current_tinst_level;
6289 level = level->next;
6293 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
6294 vector of template arguments, as for tsubst.
6296 Returns an appropriate tsubst'd friend declaration. */
6299 tsubst_friend_function (tree decl, tree args)
6303 if (TREE_CODE (decl) == FUNCTION_DECL
6304 && DECL_TEMPLATE_INSTANTIATION (decl)
6305 && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
6306 /* This was a friend declared with an explicit template
6307 argument list, e.g.:
6311 to indicate that f was a template instantiation, not a new
6312 function declaration. Now, we have to figure out what
6313 instantiation of what template. */
6315 tree template_id, arglist, fns;
6318 tree ns = decl_namespace_context (TYPE_MAIN_DECL (current_class_type));
6320 /* Friend functions are looked up in the containing namespace scope.
6321 We must enter that scope, to avoid finding member functions of the
6322 current cless with same name. */
6323 push_nested_namespace (ns);
6324 fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args,
6325 tf_warning_or_error, NULL_TREE,
6326 /*integral_constant_expression_p=*/false);
6327 pop_nested_namespace (ns);
6328 arglist = tsubst (DECL_TI_ARGS (decl), args,
6329 tf_warning_or_error, NULL_TREE);
6330 template_id = lookup_template_function (fns, arglist);
6332 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
6333 tmpl = determine_specialization (template_id, new_friend,
6335 /*need_member_template=*/0,
6336 TREE_VEC_LENGTH (args),
6338 return instantiate_template (tmpl, new_args, tf_error);
6341 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
6343 /* The NEW_FRIEND will look like an instantiation, to the
6344 compiler, but is not an instantiation from the point of view of
6345 the language. For example, we might have had:
6347 template <class T> struct S {
6348 template <class U> friend void f(T, U);
6351 Then, in S<int>, template <class U> void f(int, U) is not an
6352 instantiation of anything. */
6353 if (new_friend == error_mark_node)
6354 return error_mark_node;
6356 DECL_USE_TEMPLATE (new_friend) = 0;
6357 if (TREE_CODE (decl) == TEMPLATE_DECL)
6359 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0;
6360 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend))
6361 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
6364 /* The mangled name for the NEW_FRIEND is incorrect. The function
6365 is not a template instantiation and should not be mangled like
6366 one. Therefore, we forget the mangling here; we'll recompute it
6367 later if we need it. */
6368 if (TREE_CODE (new_friend) != TEMPLATE_DECL)
6370 SET_DECL_RTL (new_friend, NULL_RTX);
6371 SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE);
6374 if (DECL_NAMESPACE_SCOPE_P (new_friend))
6377 tree new_friend_template_info;
6378 tree new_friend_result_template_info;
6380 int new_friend_is_defn;
6382 /* We must save some information from NEW_FRIEND before calling
6383 duplicate decls since that function will free NEW_FRIEND if
6385 new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
6386 new_friend_is_defn =
6387 (DECL_INITIAL (DECL_TEMPLATE_RESULT
6388 (template_for_substitution (new_friend)))
6390 if (TREE_CODE (new_friend) == TEMPLATE_DECL)
6392 /* This declaration is a `primary' template. */
6393 DECL_PRIMARY_TEMPLATE (new_friend) = new_friend;
6395 new_friend_result_template_info
6396 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend));
6399 new_friend_result_template_info = NULL_TREE;
6401 /* Make the init_value nonzero so pushdecl knows this is a defn. */
6402 if (new_friend_is_defn)
6403 DECL_INITIAL (new_friend) = error_mark_node;
6405 /* Inside pushdecl_namespace_level, we will push into the
6406 current namespace. However, the friend function should go
6407 into the namespace of the template. */
6408 ns = decl_namespace_context (new_friend);
6409 push_nested_namespace (ns);
6410 old_decl = pushdecl_namespace_level (new_friend, /*is_friend=*/true);
6411 pop_nested_namespace (ns);
6413 if (old_decl == error_mark_node)
6414 return error_mark_node;
6416 if (old_decl != new_friend)
6418 /* This new friend declaration matched an existing
6419 declaration. For example, given:
6421 template <class T> void f(T);
6422 template <class U> class C {
6423 template <class T> friend void f(T) {}
6426 the friend declaration actually provides the definition
6427 of `f', once C has been instantiated for some type. So,
6428 old_decl will be the out-of-class template declaration,
6429 while new_friend is the in-class definition.
6431 But, if `f' was called before this point, the
6432 instantiation of `f' will have DECL_TI_ARGS corresponding
6433 to `T' but not to `U', references to which might appear
6434 in the definition of `f'. Previously, the most general
6435 template for an instantiation of `f' was the out-of-class
6436 version; now it is the in-class version. Therefore, we
6437 run through all specialization of `f', adding to their
6438 DECL_TI_ARGS appropriately. In particular, they need a
6439 new set of outer arguments, corresponding to the
6440 arguments for this class instantiation.
6442 The same situation can arise with something like this:
6445 template <class T> class C {
6449 when `C<int>' is instantiated. Now, `f(int)' is defined
6452 if (!new_friend_is_defn)
6453 /* On the other hand, if the in-class declaration does
6454 *not* provide a definition, then we don't want to alter
6455 existing definitions. We can just leave everything
6460 /* Overwrite whatever template info was there before, if
6461 any, with the new template information pertaining to
6463 DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
6465 if (TREE_CODE (old_decl) != TEMPLATE_DECL)
6466 reregister_specialization (new_friend,
6467 most_general_template (old_decl),
6472 tree new_friend_args;
6474 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl))
6475 = new_friend_result_template_info;
6477 new_friend_args = TI_ARGS (new_friend_template_info);
6478 for (t = DECL_TEMPLATE_SPECIALIZATIONS (old_decl);
6482 tree spec = TREE_VALUE (t);
6485 = add_outermost_template_args (new_friend_args,
6486 DECL_TI_ARGS (spec));
6489 /* Now, since specializations are always supposed to
6490 hang off of the most general template, we must move
6492 t = most_general_template (old_decl);
6495 DECL_TEMPLATE_SPECIALIZATIONS (t)
6496 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t),
6497 DECL_TEMPLATE_SPECIALIZATIONS (old_decl));
6498 DECL_TEMPLATE_SPECIALIZATIONS (old_decl) = NULL_TREE;
6503 /* The information from NEW_FRIEND has been merged into OLD_DECL
6504 by duplicate_decls. */
6505 new_friend = old_decl;
6510 tree context = DECL_CONTEXT (new_friend);
6514 template <class T> class C {
6515 template <class U> friend void C1<U>::f (); // case 1
6516 friend void C2<T>::f (); // case 2
6518 we only need to make sure CONTEXT is a complete type for
6519 case 2. To distinguish between the two cases, we note that
6520 CONTEXT of case 1 remains dependent type after tsubst while
6521 this isn't true for case 2. */
6522 ++processing_template_decl;
6523 dependent_p = dependent_type_p (context);
6524 --processing_template_decl;
6527 && !complete_type_or_else (context, NULL_TREE))
6528 return error_mark_node;
6530 if (COMPLETE_TYPE_P (context))
6532 /* Check to see that the declaration is really present, and,
6533 possibly obtain an improved declaration. */
6534 tree fn = check_classfn (context,
6535 new_friend, NULL_TREE);
6545 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
6546 template arguments, as for tsubst.
6548 Returns an appropriate tsubst'd friend type or error_mark_node on
6552 tsubst_friend_class (tree friend_tmpl, tree args)
6558 context = DECL_CONTEXT (friend_tmpl);
6562 if (TREE_CODE (context) == NAMESPACE_DECL)
6563 push_nested_namespace (context);
6565 push_nested_class (tsubst (context, args, tf_none, NULL_TREE));
6568 /* Look for a class template declaration. We look for hidden names
6569 because two friend declarations of the same template are the
6570 same. For example, in:
6573 template <typename> friend class F;
6575 template <typename> struct B {
6576 template <typename> friend class F;
6579 both F templates are the same. */
6580 tmpl = lookup_name_real (DECL_NAME (friend_tmpl), 0, 0,
6581 /*block_p=*/true, 0,
6582 LOOKUP_COMPLAIN | LOOKUP_HIDDEN);
6584 /* But, if we don't find one, it might be because we're in a
6585 situation like this:
6593 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
6594 for `S<int>', not the TEMPLATE_DECL. */
6595 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
6597 tmpl = lookup_name_prefer_type (DECL_NAME (friend_tmpl), 1);
6598 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
6601 if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
6603 /* The friend template has already been declared. Just
6604 check to see that the declarations match, and install any new
6605 default parameters. We must tsubst the default parameters,
6606 of course. We only need the innermost template parameters
6607 because that is all that redeclare_class_template will look
6609 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl))
6610 > TMPL_ARGS_DEPTH (args))
6613 location_t saved_input_location;
6614 parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
6615 args, tf_warning_or_error);
6617 saved_input_location = input_location;
6618 input_location = DECL_SOURCE_LOCATION (friend_tmpl);
6619 redeclare_class_template (TREE_TYPE (tmpl), parms);
6620 input_location = saved_input_location;
6624 friend_type = TREE_TYPE (tmpl);
6628 /* The friend template has not already been declared. In this
6629 case, the instantiation of the template class will cause the
6630 injection of this template into the global scope. */
6631 tmpl = tsubst (friend_tmpl, args, tf_warning_or_error, NULL_TREE);
6632 if (tmpl == error_mark_node)
6633 return error_mark_node;
6635 /* The new TMPL is not an instantiation of anything, so we
6636 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
6637 the new type because that is supposed to be the corresponding
6638 template decl, i.e., TMPL. */
6639 DECL_USE_TEMPLATE (tmpl) = 0;
6640 DECL_TEMPLATE_INFO (tmpl) = NULL_TREE;
6641 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0;
6642 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl))
6643 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)));
6645 /* Inject this template into the global scope. */
6646 friend_type = TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl, true));
6651 if (TREE_CODE (context) == NAMESPACE_DECL)
6652 pop_nested_namespace (context);
6654 pop_nested_class ();
6660 /* Returns zero if TYPE cannot be completed later due to circularity.
6661 Otherwise returns one. */
6664 can_complete_type_without_circularity (tree type)
6666 if (type == NULL_TREE || type == error_mark_node)
6668 else if (COMPLETE_TYPE_P (type))
6670 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
6671 return can_complete_type_without_circularity (TREE_TYPE (type));
6672 else if (CLASS_TYPE_P (type)
6673 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type)))
6679 /* Apply any attributes which had to be deferred until instantiation
6680 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
6681 ARGS, COMPLAIN, IN_DECL are as tsubst. */
6684 apply_late_template_attributes (tree *decl_p, tree attributes, int attr_flags,
6685 tree args, tsubst_flags_t complain, tree in_decl)
6687 tree last_dep = NULL_TREE;
6691 for (t = attributes; t; t = TREE_CHAIN (t))
6692 if (ATTR_IS_DEPENDENT (t))
6695 attributes = copy_list (attributes);
6699 if (DECL_P (*decl_p))
6701 if (TREE_TYPE (*decl_p) == error_mark_node)
6703 p = &DECL_ATTRIBUTES (*decl_p);
6706 p = &TYPE_ATTRIBUTES (*decl_p);
6710 tree late_attrs = NULL_TREE;
6711 tree *q = &late_attrs;
6713 for (*p = attributes; *p; )
6716 if (ATTR_IS_DEPENDENT (t))
6718 *p = TREE_CHAIN (t);
6719 TREE_CHAIN (t) = NULL_TREE;
6721 = tsubst_expr (TREE_VALUE (t), args, complain, in_decl,
6722 /*integral_constant_expression_p=*/false);
6724 q = &TREE_CHAIN (t);
6727 p = &TREE_CHAIN (t);
6730 cplus_decl_attributes (decl_p, late_attrs, attr_flags);
6735 instantiate_class_template (tree type)
6737 tree template, args, pattern, t, member;
6742 if (type == error_mark_node)
6743 return error_mark_node;
6745 if (TYPE_BEING_DEFINED (type)
6746 || COMPLETE_TYPE_P (type)
6747 || dependent_type_p (type))
6750 /* Figure out which template is being instantiated. */
6751 template = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
6752 gcc_assert (TREE_CODE (template) == TEMPLATE_DECL);
6754 /* Determine what specialization of the original template to
6756 t = most_specialized_class (type, template);
6757 if (t == error_mark_node)
6759 TYPE_BEING_DEFINED (type) = 1;
6760 return error_mark_node;
6764 /* This TYPE is actually an instantiation of a partial
6765 specialization. We replace the innermost set of ARGS with
6766 the arguments appropriate for substitution. For example,
6769 template <class T> struct S {};
6770 template <class T> struct S<T*> {};
6772 and supposing that we are instantiating S<int*>, ARGS will
6773 presently be {int*} -- but we need {int}. */
6774 pattern = TREE_TYPE (t);
6775 args = TREE_PURPOSE (t);
6779 pattern = TREE_TYPE (template);
6780 args = CLASSTYPE_TI_ARGS (type);
6783 /* If the template we're instantiating is incomplete, then clearly
6784 there's nothing we can do. */
6785 if (!COMPLETE_TYPE_P (pattern))
6788 /* If we've recursively instantiated too many templates, stop. */
6789 if (! push_tinst_level (type))
6792 /* Now we're really doing the instantiation. Mark the type as in
6793 the process of being defined. */
6794 TYPE_BEING_DEFINED (type) = 1;
6796 /* We may be in the middle of deferred access check. Disable
6798 push_deferring_access_checks (dk_no_deferred);
6800 push_to_top_level ();
6802 SET_CLASSTYPE_INTERFACE_UNKNOWN (type);
6804 /* Set the input location to the template definition. This is needed
6805 if tsubsting causes an error. */
6806 typedecl = TYPE_MAIN_DECL (type);
6807 input_location = DECL_SOURCE_LOCATION (typedecl);
6808 in_system_header = DECL_IN_SYSTEM_HEADER (typedecl);
6810 TYPE_HAS_USER_CONSTRUCTOR (type) = TYPE_HAS_USER_CONSTRUCTOR (pattern);
6811 TYPE_HAS_NEW_OPERATOR (type) = TYPE_HAS_NEW_OPERATOR (pattern);
6812 TYPE_HAS_ARRAY_NEW_OPERATOR (type) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern);
6813 TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern);
6814 TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern);
6815 TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern);
6816 TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern);
6817 TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern);
6818 TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern);
6819 TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern);
6820 TYPE_PACKED (type) = TYPE_PACKED (pattern);
6821 TYPE_ALIGN (type) = TYPE_ALIGN (pattern);
6822 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);
6823 TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */
6824 if (ANON_AGGR_TYPE_P (pattern))
6825 SET_ANON_AGGR_TYPE_P (type);
6826 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern))
6828 CLASSTYPE_VISIBILITY_SPECIFIED (type) = 1;
6829 CLASSTYPE_VISIBILITY (type) = CLASSTYPE_VISIBILITY (pattern);
6832 pbinfo = TYPE_BINFO (pattern);
6834 /* We should never instantiate a nested class before its enclosing
6835 class; we need to look up the nested class by name before we can
6836 instantiate it, and that lookup should instantiate the enclosing
6838 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))
6839 || COMPLETE_TYPE_P (TYPE_CONTEXT (type))
6840 || TYPE_BEING_DEFINED (TYPE_CONTEXT (type)));
6842 base_list = NULL_TREE;
6843 if (BINFO_N_BASE_BINFOS (pbinfo))
6846 tree context = TYPE_CONTEXT (type);
6850 /* We must enter the scope containing the type, as that is where
6851 the accessibility of types named in dependent bases are
6853 pushed_scope = push_scope (context ? context : global_namespace);
6855 /* Substitute into each of the bases to determine the actual
6857 for (i = 0; BINFO_BASE_ITERATE (pbinfo, i, pbase_binfo); i++)
6860 tree access = BINFO_BASE_ACCESS (pbinfo, i);
6861 tree expanded_bases = NULL_TREE;
6864 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo)))
6867 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo),
6868 args, tf_error, NULL_TREE);
6869 if (expanded_bases == error_mark_node)
6872 len = TREE_VEC_LENGTH (expanded_bases);
6875 for (idx = 0; idx < len; idx++)
6878 /* Extract the already-expanded base class. */
6879 base = TREE_VEC_ELT (expanded_bases, idx);
6881 /* Substitute to figure out the base class. */
6882 base = tsubst (BINFO_TYPE (pbase_binfo), args, tf_error,
6885 if (base == error_mark_node)
6888 base_list = tree_cons (access, base, base_list);
6889 if (BINFO_VIRTUAL_P (pbase_binfo))
6890 TREE_TYPE (base_list) = integer_type_node;
6894 /* The list is now in reverse order; correct that. */
6895 base_list = nreverse (base_list);
6898 pop_scope (pushed_scope);
6900 /* Now call xref_basetypes to set up all the base-class
6902 xref_basetypes (type, base_list);
6904 apply_late_template_attributes (&type, TYPE_ATTRIBUTES (pattern),
6905 (int) ATTR_FLAG_TYPE_IN_PLACE,
6906 args, tf_error, NULL_TREE);
6908 /* Now that our base classes are set up, enter the scope of the
6909 class, so that name lookups into base classes, etc. will work
6910 correctly. This is precisely analogous to what we do in
6911 begin_class_definition when defining an ordinary non-template
6912 class, except we also need to push the enclosing classes. */
6913 push_nested_class (type);
6915 /* Now members are processed in the order of declaration. */
6916 for (member = CLASSTYPE_DECL_LIST (pattern);
6917 member; member = TREE_CHAIN (member))
6919 tree t = TREE_VALUE (member);
6921 if (TREE_PURPOSE (member))
6925 /* Build new CLASSTYPE_NESTED_UTDS. */
6928 bool class_template_p;
6930 class_template_p = (TREE_CODE (t) != ENUMERAL_TYPE
6931 && TYPE_LANG_SPECIFIC (t)
6932 && CLASSTYPE_IS_TEMPLATE (t));
6933 /* If the member is a class template, then -- even after
6934 substitution -- there may be dependent types in the
6935 template argument list for the class. We increment
6936 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
6937 that function will assume that no types are dependent
6938 when outside of a template. */
6939 if (class_template_p)
6940 ++processing_template_decl;
6941 newtag = tsubst (t, args, tf_error, NULL_TREE);
6942 if (class_template_p)
6943 --processing_template_decl;
6944 if (newtag == error_mark_node)
6947 if (TREE_CODE (newtag) != ENUMERAL_TYPE)
6949 tree name = TYPE_IDENTIFIER (t);
6951 if (class_template_p)
6952 /* Unfortunately, lookup_template_class sets
6953 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
6954 instantiation (i.e., for the type of a member
6955 template class nested within a template class.)
6956 This behavior is required for
6957 maybe_process_partial_specialization to work
6958 correctly, but is not accurate in this case;
6959 the TAG is not an instantiation of anything.
6960 (The corresponding TEMPLATE_DECL is an
6961 instantiation, but the TYPE is not.) */
6962 CLASSTYPE_USE_TEMPLATE (newtag) = 0;
6964 /* Now, we call pushtag to put this NEWTAG into the scope of
6965 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
6966 pushtag calling push_template_decl. We don't have to do
6967 this for enums because it will already have been done in
6970 SET_IDENTIFIER_TYPE_VALUE (name, newtag);
6971 pushtag (name, newtag, /*tag_scope=*/ts_current);
6974 else if (TREE_CODE (t) == FUNCTION_DECL
6975 || DECL_FUNCTION_TEMPLATE_P (t))
6977 /* Build new TYPE_METHODS. */
6980 if (TREE_CODE (t) == TEMPLATE_DECL)
6981 ++processing_template_decl;
6982 r = tsubst (t, args, tf_error, NULL_TREE);
6983 if (TREE_CODE (t) == TEMPLATE_DECL)
6984 --processing_template_decl;
6985 set_current_access_from_decl (r);
6986 finish_member_declaration (r);
6990 /* Build new TYPE_FIELDS. */
6991 if (TREE_CODE (t) == STATIC_ASSERT)
6994 tsubst_expr (STATIC_ASSERT_CONDITION (t), args,
6995 tf_warning_or_error, NULL_TREE,
6996 /*integral_constant_expression_p=*/true);
6997 finish_static_assert (condition,
6998 STATIC_ASSERT_MESSAGE (t),
6999 STATIC_ASSERT_SOURCE_LOCATION (t),
7002 else if (TREE_CODE (t) != CONST_DECL)
7006 /* The the file and line for this declaration, to
7007 assist in error message reporting. Since we
7008 called push_tinst_level above, we don't need to
7010 input_location = DECL_SOURCE_LOCATION (t);
7012 if (TREE_CODE (t) == TEMPLATE_DECL)
7013 ++processing_template_decl;
7014 r = tsubst (t, args, tf_warning_or_error, NULL_TREE);
7015 if (TREE_CODE (t) == TEMPLATE_DECL)
7016 --processing_template_decl;
7017 if (TREE_CODE (r) == VAR_DECL)
7021 [t]he initialization (and any associated
7022 side-effects) of a static data member does
7023 not occur unless the static data member is
7024 itself used in a way that requires the
7025 definition of the static data member to
7028 Therefore, we do not substitute into the
7029 initialized for the static data member here. */
7030 finish_static_data_member_decl
7033 /*init_const_expr_p=*/false,
7034 /*asmspec_tree=*/NULL_TREE,
7036 if (DECL_INITIALIZED_IN_CLASS_P (r))
7037 check_static_variable_definition (r, TREE_TYPE (r));
7039 else if (TREE_CODE (r) == FIELD_DECL)
7041 /* Determine whether R has a valid type and can be
7042 completed later. If R is invalid, then it is
7043 replaced by error_mark_node so that it will not be
7044 added to TYPE_FIELDS. */
7045 tree rtype = TREE_TYPE (r);
7046 if (can_complete_type_without_circularity (rtype))
7047 complete_type (rtype);
7049 if (!COMPLETE_TYPE_P (rtype))
7051 cxx_incomplete_type_error (r, rtype);
7052 r = error_mark_node;
7056 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
7057 such a thing will already have been added to the field
7058 list by tsubst_enum in finish_member_declaration in the
7059 CLASSTYPE_NESTED_UTDS case above. */
7060 if (!(TREE_CODE (r) == TYPE_DECL
7061 && TREE_CODE (TREE_TYPE (r)) == ENUMERAL_TYPE
7062 && DECL_ARTIFICIAL (r)))
7064 set_current_access_from_decl (r);
7065 finish_member_declaration (r);
7072 if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t))
7074 /* Build new CLASSTYPE_FRIEND_CLASSES. */
7076 tree friend_type = t;
7077 bool adjust_processing_template_decl = false;
7079 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
7081 /* template <class T> friend class C; */
7082 friend_type = tsubst_friend_class (friend_type, args);
7083 adjust_processing_template_decl = true;
7085 else if (TREE_CODE (friend_type) == UNBOUND_CLASS_TEMPLATE)
7087 /* template <class T> friend class C::D; */
7088 friend_type = tsubst (friend_type, args,
7089 tf_warning_or_error, NULL_TREE);
7090 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
7091 friend_type = TREE_TYPE (friend_type);
7092 adjust_processing_template_decl = true;
7094 else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
7096 /* This could be either
7100 when dependent_type_p is false or
7102 template <class U> friend class T::C;
7105 friend_type = tsubst (friend_type, args,
7106 tf_warning_or_error, NULL_TREE);
7107 /* Bump processing_template_decl for correct
7108 dependent_type_p calculation. */
7109 ++processing_template_decl;
7110 if (dependent_type_p (friend_type))
7111 adjust_processing_template_decl = true;
7112 --processing_template_decl;
7114 else if (!CLASSTYPE_USE_TEMPLATE (friend_type)
7115 && hidden_name_p (TYPE_NAME (friend_type)))
7119 where C hasn't been declared yet. Let's lookup name
7120 from namespace scope directly, bypassing any name that
7121 come from dependent base class. */
7122 tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type));
7124 /* The call to xref_tag_from_type does injection for friend
7126 push_nested_namespace (ns);
7128 xref_tag_from_type (friend_type, NULL_TREE,
7129 /*tag_scope=*/ts_current);
7130 pop_nested_namespace (ns);
7132 else if (uses_template_parms (friend_type))
7133 /* friend class C<T>; */
7134 friend_type = tsubst (friend_type, args,
7135 tf_warning_or_error, NULL_TREE);
7140 where C is already declared or
7142 friend class C<int>;
7144 We don't have to do anything in these cases. */
7146 if (adjust_processing_template_decl)
7147 /* Trick make_friend_class into realizing that the friend
7148 we're adding is a template, not an ordinary class. It's
7149 important that we use make_friend_class since it will
7150 perform some error-checking and output cross-reference
7152 ++processing_template_decl;
7154 if (friend_type != error_mark_node)
7155 make_friend_class (type, friend_type, /*complain=*/false);
7157 if (adjust_processing_template_decl)
7158 --processing_template_decl;
7162 /* Build new DECL_FRIENDLIST. */
7165 /* The the file and line for this declaration, to
7166 assist in error message reporting. Since we
7167 called push_tinst_level above, we don't need to
7169 input_location = DECL_SOURCE_LOCATION (t);
7171 if (TREE_CODE (t) == TEMPLATE_DECL)
7173 ++processing_template_decl;
7174 push_deferring_access_checks (dk_no_check);
7177 r = tsubst_friend_function (t, args);
7178 add_friend (type, r, /*complain=*/false);
7179 if (TREE_CODE (t) == TEMPLATE_DECL)
7181 pop_deferring_access_checks ();
7182 --processing_template_decl;
7188 /* Set the file and line number information to whatever is given for
7189 the class itself. This puts error messages involving generated
7190 implicit functions at a predictable point, and the same point
7191 that would be used for non-template classes. */
7192 input_location = DECL_SOURCE_LOCATION (typedecl);
7194 unreverse_member_declarations (type);
7195 finish_struct_1 (type);
7196 TYPE_BEING_DEFINED (type) = 0;
7198 /* Now that the class is complete, instantiate default arguments for
7199 any member functions. We don't do this earlier because the
7200 default arguments may reference members of the class. */
7201 if (!PRIMARY_TEMPLATE_P (template))
7202 for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t))
7203 if (TREE_CODE (t) == FUNCTION_DECL
7204 /* Implicitly generated member functions will not have template
7205 information; they are not instantiations, but instead are
7206 created "fresh" for each instantiation. */
7207 && DECL_TEMPLATE_INFO (t))
7208 tsubst_default_arguments (t);
7210 pop_nested_class ();
7211 pop_from_top_level ();
7212 pop_deferring_access_checks ();
7215 /* The vtable for a template class can be emitted in any translation
7216 unit in which the class is instantiated. When there is no key
7217 method, however, finish_struct_1 will already have added TYPE to
7218 the keyed_classes list. */
7219 if (TYPE_CONTAINS_VPTR_P (type) && CLASSTYPE_KEY_METHOD (type))
7220 keyed_classes = tree_cons (NULL_TREE, type, keyed_classes);
7226 tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl)
7232 else if (TYPE_P (t))
7233 r = tsubst (t, args, complain, in_decl);
7236 r = tsubst_expr (t, args, complain, in_decl,
7237 /*integral_constant_expression_p=*/true);
7238 r = fold_non_dependent_expr (r);
7243 /* Substitute ARGS into T, which is an pack expansion
7244 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
7245 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
7246 (if only a partial substitution could be performed) or
7247 ERROR_MARK_NODE if there was an error. */
7249 tsubst_pack_expansion (tree t, tree args, tsubst_flags_t complain,
7253 tree pack, packs = NULL_TREE, unsubstituted_packs = NULL_TREE;
7254 tree first_arg_pack; int i, len = -1;
7258 gcc_assert (PACK_EXPANSION_P (t));
7259 pattern = PACK_EXPANSION_PATTERN (t);
7261 /* Determine the argument packs that will instantiate the parameter
7262 packs used in the expansion expression. While we're at it,
7263 compute the number of arguments to be expanded and make sure it
7265 for (pack = PACK_EXPANSION_PARAMETER_PACKS (t); pack;
7266 pack = TREE_CHAIN (pack))
7268 tree parm_pack = TREE_VALUE (pack);
7269 tree arg_pack = NULL_TREE;
7270 tree orig_arg = NULL_TREE;
7272 if (TREE_CODE (parm_pack) == PARM_DECL)
7273 arg_pack = retrieve_local_specialization (parm_pack);
7276 int level, idx, levels;
7277 template_parm_level_and_index (parm_pack, &level, &idx);
7279 levels = TMPL_ARGS_DEPTH (args);
7280 if (level <= levels)
7281 arg_pack = TMPL_ARG (args, level, idx);
7284 orig_arg = arg_pack;
7285 if (arg_pack && TREE_CODE (arg_pack) == ARGUMENT_PACK_SELECT)
7286 arg_pack = ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack);
7288 if (arg_pack && !ARGUMENT_PACK_P (arg_pack))
7289 /* This can only happen if we forget to expand an argument
7290 pack somewhere else. Just return an error, silently. */
7292 result = make_tree_vec (1);
7293 TREE_VEC_ELT (result, 0) = error_mark_node;
7298 && TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack)) == 1
7299 && PACK_EXPANSION_P (TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg_pack), 0)))
7301 tree expansion = TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg_pack), 0);
7302 tree pattern = PACK_EXPANSION_PATTERN (expansion);
7303 if ((TYPE_P (pattern) && same_type_p (pattern, parm_pack))
7304 || (!TYPE_P (pattern) && cp_tree_equal (parm_pack, pattern)))
7305 /* The argument pack that the parameter maps to is just an
7306 expansion of the parameter itself, such as one would
7307 find in the implicit typedef of a class inside the
7308 class itself. Consider this parameter "unsubstituted",
7309 so that we will maintain the outer pack expansion. */
7310 arg_pack = NULL_TREE;
7316 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack));
7318 /* It's all-or-nothing with incomplete argument packs. */
7319 if (incomplete && !ARGUMENT_PACK_INCOMPLETE_P (arg_pack))
7320 return error_mark_node;
7322 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack))
7328 first_arg_pack = arg_pack;
7330 else if (len != my_len)
7332 if (TREE_CODE (t) == TYPE_PACK_EXPANSION)
7333 error ("mismatched argument pack lengths while expanding "
7337 error ("mismatched argument pack lengths while expanding "
7340 return error_mark_node;
7343 /* Keep track of the parameter packs and their corresponding
7345 packs = tree_cons (parm_pack, arg_pack, packs);
7346 TREE_TYPE (packs) = orig_arg;
7349 /* We can't substitute for this parameter pack. */
7350 unsubstituted_packs = tree_cons (TREE_PURPOSE (pack),
7352 unsubstituted_packs);
7355 /* We cannot expand this expansion expression, because we don't have
7356 all of the argument packs we need. Substitute into the pattern
7357 and return a PACK_EXPANSION_*. The caller will need to deal with
7359 if (unsubstituted_packs)
7360 return make_pack_expansion (tsubst (pattern, args, complain,
7363 /* We could not find any argument packs that work. */
7365 return error_mark_node;
7367 /* For each argument in each argument pack, substitute into the
7369 result = make_tree_vec (len + incomplete);
7370 for (i = 0; i < len + incomplete; ++i)
7372 /* For parameter pack, change the substitution of the parameter
7373 pack to the ith argument in its argument pack, then expand
7375 for (pack = packs; pack; pack = TREE_CHAIN (pack))
7377 tree parm = TREE_PURPOSE (pack);
7379 if (TREE_CODE (parm) == PARM_DECL)
7381 /* Select the Ith argument from the pack. */
7382 tree arg = make_node (ARGUMENT_PACK_SELECT);
7383 ARGUMENT_PACK_SELECT_FROM_PACK (arg) = TREE_VALUE (pack);
7384 ARGUMENT_PACK_SELECT_INDEX (arg) = i;
7386 register_local_specialization (arg, parm);
7392 template_parm_level_and_index (parm, &level, &idx);
7396 /* Select the Ith argument from the pack. */
7397 value = make_node (ARGUMENT_PACK_SELECT);
7398 ARGUMENT_PACK_SELECT_FROM_PACK (value) = TREE_VALUE (pack);
7399 ARGUMENT_PACK_SELECT_INDEX (value) = i;
7402 /* Update the corresponding argument. */
7403 TMPL_ARG (args, level, idx) = value;
7407 /* Substitute into the PATTERN with the altered arguments. */
7408 if (TREE_CODE (t) == EXPR_PACK_EXPANSION)
7409 TREE_VEC_ELT (result, i) =
7410 tsubst_expr (pattern, args, complain, in_decl,
7411 /*integral_constant_expression_p=*/false);
7413 TREE_VEC_ELT (result, i) = tsubst (pattern, args, complain, in_decl);
7416 /* When we have incomplete argument packs, the last "expanded"
7417 result is itself a pack expansion, which allows us
7418 to deduce more arguments. */
7419 TREE_VEC_ELT (result, i) =
7420 make_pack_expansion (TREE_VEC_ELT (result, i));
7422 if (TREE_VEC_ELT (result, i) == error_mark_node)
7424 result = error_mark_node;
7429 /* Update ARGS to restore the substitution from parameter packs to
7430 their argument packs. */
7431 for (pack = packs; pack; pack = TREE_CHAIN (pack))
7433 tree parm = TREE_PURPOSE (pack);
7435 if (TREE_CODE (parm) == PARM_DECL)
7436 register_local_specialization (TREE_TYPE (pack), parm);
7440 template_parm_level_and_index (parm, &level, &idx);
7442 /* Update the corresponding argument. */
7443 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
7444 TREE_VEC_ELT (TREE_VEC_ELT (args, level -1 ), idx) =
7447 TREE_VEC_ELT (args, idx) = TREE_TYPE (pack);
7454 /* Substitute ARGS into the vector or list of template arguments T. */
7457 tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl)
7460 int len = TREE_VEC_LENGTH (t);
7461 int need_new = 0, i, expanded_len_adjust = 0, out;
7462 tree *elts = (tree *) alloca (len * sizeof (tree));
7464 for (i = 0; i < len; i++)
7466 tree orig_arg = TREE_VEC_ELT (t, i);
7469 if (TREE_CODE (orig_arg) == TREE_VEC)
7470 new_arg = tsubst_template_args (orig_arg, args, complain, in_decl);
7471 else if (PACK_EXPANSION_P (orig_arg))
7473 /* Substitute into an expansion expression. */
7474 new_arg = tsubst_pack_expansion (orig_arg, args, complain, in_decl);
7476 if (TREE_CODE (new_arg) == TREE_VEC)
7477 /* Add to the expanded length adjustment the number of
7478 expanded arguments. We subtract one from this
7479 measurement, because the argument pack expression
7480 itself is already counted as 1 in
7481 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
7482 the argument pack is empty. */
7483 expanded_len_adjust += TREE_VEC_LENGTH (new_arg) - 1;
7485 else if (ARGUMENT_PACK_P (orig_arg))
7487 /* Substitute into each of the arguments. */
7488 new_arg = make_node (TREE_CODE (orig_arg));
7490 SET_ARGUMENT_PACK_ARGS (
7492 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg),
7493 args, complain, in_decl));
7495 if (ARGUMENT_PACK_ARGS (new_arg) == error_mark_node)
7496 new_arg = error_mark_node;
7498 if (TREE_CODE (new_arg) == NONTYPE_ARGUMENT_PACK) {
7499 TREE_TYPE (new_arg) = tsubst (TREE_TYPE (orig_arg), args,
7501 TREE_CONSTANT (new_arg) = TREE_CONSTANT (orig_arg);
7503 if (TREE_TYPE (new_arg) == error_mark_node)
7504 new_arg = error_mark_node;
7508 new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl);
7510 if (new_arg == error_mark_node)
7511 return error_mark_node;
7514 if (new_arg != orig_arg)
7521 /* Make space for the expanded arguments coming from template
7523 t = make_tree_vec (len + expanded_len_adjust);
7524 for (i = 0, out = 0; i < len; i++)
7526 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t, i))
7527 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t, i)))
7528 && TREE_CODE (elts[i]) == TREE_VEC)
7532 /* Now expand the template argument pack "in place". */
7533 for (idx = 0; idx < TREE_VEC_LENGTH (elts[i]); idx++, out++)
7534 TREE_VEC_ELT (t, out) = TREE_VEC_ELT (elts[i], idx);
7538 TREE_VEC_ELT (t, out) = elts[i];
7546 /* Return the result of substituting ARGS into the template parameters
7547 given by PARMS. If there are m levels of ARGS and m + n levels of
7548 PARMS, then the result will contain n levels of PARMS. For
7549 example, if PARMS is `template <class T> template <class U>
7550 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
7551 result will be `template <int*, double, class V>'. */
7554 tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain)
7559 /* When substituting into a template, we must set
7560 PROCESSING_TEMPLATE_DECL as the template parameters may be
7561 dependent if they are based on one-another, and the dependency
7562 predicates are short-circuit outside of templates. */
7563 ++processing_template_decl;
7565 for (new_parms = &r;
7566 TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args);
7567 new_parms = &(TREE_CHAIN (*new_parms)),
7568 parms = TREE_CHAIN (parms))
7571 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms)));
7574 for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i)
7580 if (parms == error_mark_node)
7583 tuple = TREE_VEC_ELT (TREE_VALUE (parms), i);
7585 if (tuple == error_mark_node)
7588 default_value = TREE_PURPOSE (tuple);
7589 parm_decl = TREE_VALUE (tuple);
7591 parm_decl = tsubst (parm_decl, args, complain, NULL_TREE);
7592 if (TREE_CODE (parm_decl) == PARM_DECL
7593 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl), complain))
7594 parm_decl = error_mark_node;
7595 default_value = tsubst_template_arg (default_value, args,
7596 complain, NULL_TREE);
7598 tuple = build_tree_list (default_value, parm_decl);
7599 TREE_VEC_ELT (new_vec, i) = tuple;
7603 tree_cons (size_int (TMPL_PARMS_DEPTH (parms)
7604 - TMPL_ARGS_DEPTH (args)),
7605 new_vec, NULL_TREE);
7608 --processing_template_decl;
7613 /* Substitute the ARGS into the indicated aggregate (or enumeration)
7614 type T. If T is not an aggregate or enumeration type, it is
7615 handled as if by tsubst. IN_DECL is as for tsubst. If
7616 ENTERING_SCOPE is nonzero, T is the context for a template which
7617 we are presently tsubst'ing. Return the substituted value. */
7620 tsubst_aggr_type (tree t,
7622 tsubst_flags_t complain,
7629 switch (TREE_CODE (t))
7632 if (TYPE_PTRMEMFUNC_P (t))
7633 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl);
7635 /* Else fall through. */
7638 if (TYPE_TEMPLATE_INFO (t) && uses_template_parms (t))
7643 bool saved_skip_evaluation;
7645 /* In "sizeof(X<I>)" we need to evaluate "I". */
7646 saved_skip_evaluation = skip_evaluation;
7647 skip_evaluation = false;
7649 /* First, determine the context for the type we are looking
7651 context = TYPE_CONTEXT (t);
7654 context = tsubst_aggr_type (context, args, complain,
7655 in_decl, /*entering_scope=*/1);
7656 /* If context is a nested class inside a class template,
7657 it may still need to be instantiated (c++/33959). */
7658 if (TYPE_P (context))
7659 context = complete_type (context);
7662 /* Then, figure out what arguments are appropriate for the
7663 type we are trying to find. For example, given:
7665 template <class T> struct S;
7666 template <class T, class U> void f(T, U) { S<U> su; }
7668 and supposing that we are instantiating f<int, double>,
7669 then our ARGS will be {int, double}, but, when looking up
7670 S we only want {double}. */
7671 argvec = tsubst_template_args (TYPE_TI_ARGS (t), args,
7673 if (argvec == error_mark_node)
7674 r = error_mark_node;
7677 r = lookup_template_class (t, argvec, in_decl, context,
7678 entering_scope, complain);
7679 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
7682 skip_evaluation = saved_skip_evaluation;
7687 /* This is not a template type, so there's nothing to do. */
7691 return tsubst (t, args, complain, in_decl);
7695 /* Substitute into the default argument ARG (a default argument for
7696 FN), which has the indicated TYPE. */
7699 tsubst_default_argument (tree fn, tree type, tree arg)
7701 tree saved_class_ptr = NULL_TREE;
7702 tree saved_class_ref = NULL_TREE;
7704 /* This default argument came from a template. Instantiate the
7705 default argument here, not in tsubst. In the case of
7714 we must be careful to do name lookup in the scope of S<T>,
7715 rather than in the current class. */
7716 push_access_scope (fn);
7717 /* The "this" pointer is not valid in a default argument. */
7720 saved_class_ptr = current_class_ptr;
7721 cp_function_chain->x_current_class_ptr = NULL_TREE;
7722 saved_class_ref = current_class_ref;
7723 cp_function_chain->x_current_class_ref = NULL_TREE;
7726 push_deferring_access_checks(dk_no_deferred);
7727 /* The default argument expression may cause implicitly defined
7728 member functions to be synthesized, which will result in garbage
7729 collection. We must treat this situation as if we were within
7730 the body of function so as to avoid collecting live data on the
7733 arg = tsubst_expr (arg, DECL_TI_ARGS (fn),
7734 tf_warning_or_error, NULL_TREE,
7735 /*integral_constant_expression_p=*/false);
7737 pop_deferring_access_checks();
7739 /* Restore the "this" pointer. */
7742 cp_function_chain->x_current_class_ptr = saved_class_ptr;
7743 cp_function_chain->x_current_class_ref = saved_class_ref;
7746 pop_access_scope (fn);
7748 /* Make sure the default argument is reasonable. */
7749 arg = check_default_argument (type, arg);
7754 /* Substitute into all the default arguments for FN. */
7757 tsubst_default_arguments (tree fn)
7762 tmpl_args = DECL_TI_ARGS (fn);
7764 /* If this function is not yet instantiated, we certainly don't need
7765 its default arguments. */
7766 if (uses_template_parms (tmpl_args))
7769 for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
7771 arg = TREE_CHAIN (arg))
7772 if (TREE_PURPOSE (arg))
7773 TREE_PURPOSE (arg) = tsubst_default_argument (fn,
7775 TREE_PURPOSE (arg));
7778 /* Substitute the ARGS into the T, which is a _DECL. Return the
7779 result of the substitution. Issue error and warning messages under
7780 control of COMPLAIN. */
7783 tsubst_decl (tree t, tree args, tsubst_flags_t complain)
7785 location_t saved_loc;
7789 /* Set the filename and linenumber to improve error-reporting. */
7790 saved_loc = input_location;
7791 input_location = DECL_SOURCE_LOCATION (t);
7793 switch (TREE_CODE (t))
7797 /* We can get here when processing a member function template,
7798 member class template, and template template parameter of
7799 a template class. */
7800 tree decl = DECL_TEMPLATE_RESULT (t);
7805 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
7807 /* Template template parameter is treated here. */
7808 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
7809 if (new_type == error_mark_node)
7810 return error_mark_node;
7813 TREE_CHAIN (r) = NULL_TREE;
7814 TREE_TYPE (r) = new_type;
7815 DECL_TEMPLATE_RESULT (r)
7816 = build_decl (TYPE_DECL, DECL_NAME (decl), new_type);
7817 DECL_TEMPLATE_PARMS (r)
7818 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
7820 TYPE_NAME (new_type) = r;
7824 /* We might already have an instance of this template.
7825 The ARGS are for the surrounding class type, so the
7826 full args contain the tsubst'd args for the context,
7827 plus the innermost args from the template decl. */
7828 tmpl_args = DECL_CLASS_TEMPLATE_P (t)
7829 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t))
7830 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t));
7831 /* Because this is a template, the arguments will still be
7832 dependent, even after substitution. If
7833 PROCESSING_TEMPLATE_DECL is not set, the dependency
7834 predicates will short-circuit. */
7835 ++processing_template_decl;
7836 full_args = tsubst_template_args (tmpl_args, args,
7838 --processing_template_decl;
7839 if (full_args == error_mark_node)
7840 return error_mark_node;
7842 /* tsubst_template_args doesn't copy the vector if
7843 nothing changed. But, *something* should have
7845 gcc_assert (full_args != tmpl_args);
7847 spec = retrieve_specialization (t, full_args,
7848 /*class_specializations_p=*/true);
7849 if (spec != NULL_TREE)
7855 /* Make a new template decl. It will be similar to the
7856 original, but will record the current template arguments.
7857 We also create a new function declaration, which is just
7858 like the old one, but points to this new template, rather
7859 than the old one. */
7861 gcc_assert (DECL_LANG_SPECIFIC (r) != 0);
7862 TREE_CHAIN (r) = NULL_TREE;
7864 DECL_TEMPLATE_INFO (r) = build_tree_list (t, args);
7866 if (TREE_CODE (decl) == TYPE_DECL)
7869 ++processing_template_decl;
7870 new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
7871 --processing_template_decl;
7872 if (new_type == error_mark_node)
7873 return error_mark_node;
7875 TREE_TYPE (r) = new_type;
7876 CLASSTYPE_TI_TEMPLATE (new_type) = r;
7877 DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type);
7878 DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type);
7879 DECL_CONTEXT (r) = TYPE_CONTEXT (new_type);
7884 ++processing_template_decl;
7885 new_decl = tsubst (decl, args, complain, in_decl);
7886 --processing_template_decl;
7887 if (new_decl == error_mark_node)
7888 return error_mark_node;
7890 DECL_TEMPLATE_RESULT (r) = new_decl;
7891 DECL_TI_TEMPLATE (new_decl) = r;
7892 TREE_TYPE (r) = TREE_TYPE (new_decl);
7893 DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl);
7894 DECL_CONTEXT (r) = DECL_CONTEXT (new_decl);
7897 SET_DECL_IMPLICIT_INSTANTIATION (r);
7898 DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE;
7899 DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE;
7901 /* The template parameters for this new template are all the
7902 template parameters for the old template, except the
7903 outermost level of parameters. */
7904 DECL_TEMPLATE_PARMS (r)
7905 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
7908 if (PRIMARY_TEMPLATE_P (t))
7909 DECL_PRIMARY_TEMPLATE (r) = r;
7911 if (TREE_CODE (decl) != TYPE_DECL)
7912 /* Record this non-type partial instantiation. */
7913 register_specialization (r, t,
7914 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r)),
7922 tree argvec = NULL_TREE;
7930 /* Nobody should be tsubst'ing into non-template functions. */
7931 gcc_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE);
7933 if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL)
7938 /* If T is not dependent, just return it. We have to
7939 increment PROCESSING_TEMPLATE_DECL because
7940 value_dependent_expression_p assumes that nothing is
7941 dependent when PROCESSING_TEMPLATE_DECL is zero. */
7942 ++processing_template_decl;
7943 dependent_p = value_dependent_expression_p (t);
7944 --processing_template_decl;
7948 /* Calculate the most general template of which R is a
7949 specialization, and the complete set of arguments used to
7951 gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
7952 argvec = tsubst_template_args (DECL_TI_ARGS
7953 (DECL_TEMPLATE_RESULT (gen_tmpl)),
7954 args, complain, in_decl);
7956 /* Check to see if we already have this specialization. */
7957 spec = retrieve_specialization (gen_tmpl, argvec,
7958 /*class_specializations_p=*/false);
7966 /* We can see more levels of arguments than parameters if
7967 there was a specialization of a member template, like
7970 template <class T> struct S { template <class U> void f(); }
7971 template <> template <class U> void S<int>::f(U);
7973 Here, we'll be substituting into the specialization,
7974 because that's where we can find the code we actually
7975 want to generate, but we'll have enough arguments for
7976 the most general template.
7978 We also deal with the peculiar case:
7980 template <class T> struct S {
7981 template <class U> friend void f();
7983 template <class U> void f() {}
7985 template void f<double>();
7987 Here, the ARGS for the instantiation of will be {int,
7988 double}. But, we only need as many ARGS as there are
7989 levels of template parameters in CODE_PATTERN. We are
7990 careful not to get fooled into reducing the ARGS in
7993 template <class T> struct S { template <class U> void f(U); }
7994 template <class T> template <> void S<T>::f(int) {}
7996 which we can spot because the pattern will be a
7997 specialization in this case. */
7998 args_depth = TMPL_ARGS_DEPTH (args);
8000 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t)));
8001 if (args_depth > parms_depth
8002 && !DECL_TEMPLATE_SPECIALIZATION (t))
8003 args = get_innermost_template_args (args, parms_depth);
8007 /* This special case arises when we have something like this:
8009 template <class T> struct S {
8010 friend void f<int>(int, double);
8013 Here, the DECL_TI_TEMPLATE for the friend declaration
8014 will be an IDENTIFIER_NODE. We are being called from
8015 tsubst_friend_function, and we want only to create a
8016 new decl (R) with appropriate types so that we can call
8017 determine_specialization. */
8018 gen_tmpl = NULL_TREE;
8021 if (DECL_CLASS_SCOPE_P (t))
8023 if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t)))
8027 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
8028 complain, t, /*entering_scope=*/1);
8033 ctx = DECL_CONTEXT (t);
8035 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8036 if (type == error_mark_node)
8037 return error_mark_node;
8039 /* We do NOT check for matching decls pushed separately at this
8040 point, as they may not represent instantiations of this
8041 template, and in any case are considered separate under the
8044 DECL_USE_TEMPLATE (r) = 0;
8045 TREE_TYPE (r) = type;
8046 /* Clear out the mangled name and RTL for the instantiation. */
8047 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
8048 SET_DECL_RTL (r, NULL_RTX);
8049 DECL_INITIAL (r) = NULL_TREE;
8050 DECL_CONTEXT (r) = ctx;
8052 if (member && DECL_CONV_FN_P (r))
8053 /* Type-conversion operator. Reconstruct the name, in
8054 case it's the name of one of the template's parameters. */
8055 DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type));
8057 DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args,
8059 DECL_RESULT (r) = NULL_TREE;
8061 TREE_STATIC (r) = 0;
8062 TREE_PUBLIC (r) = TREE_PUBLIC (t);
8063 DECL_EXTERNAL (r) = 1;
8064 /* If this is an instantiation of a function with internal
8065 linkage, we already know what object file linkage will be
8066 assigned to the instantiation. */
8067 DECL_INTERFACE_KNOWN (r) = !TREE_PUBLIC (r);
8068 DECL_DEFER_OUTPUT (r) = 0;
8069 TREE_CHAIN (r) = NULL_TREE;
8070 DECL_PENDING_INLINE_INFO (r) = 0;
8071 DECL_PENDING_INLINE_P (r) = 0;
8072 DECL_SAVED_TREE (r) = NULL_TREE;
8074 if (DECL_CLONED_FUNCTION (r))
8076 DECL_CLONED_FUNCTION (r) = tsubst (DECL_CLONED_FUNCTION (t),
8078 TREE_CHAIN (r) = TREE_CHAIN (DECL_CLONED_FUNCTION (r));
8079 TREE_CHAIN (DECL_CLONED_FUNCTION (r)) = r;
8082 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
8083 this in the special friend case mentioned above where
8084 GEN_TMPL is NULL. */
8087 DECL_TEMPLATE_INFO (r)
8088 = tree_cons (gen_tmpl, argvec, NULL_TREE);
8089 SET_DECL_IMPLICIT_INSTANTIATION (r);
8090 register_specialization (r, gen_tmpl, argvec, false);
8092 /* We're not supposed to instantiate default arguments
8093 until they are called, for a template. But, for a
8096 template <class T> void f ()
8097 { extern void g(int i = T()); }
8099 we should do the substitution when the template is
8100 instantiated. We handle the member function case in
8101 instantiate_class_template since the default arguments
8102 might refer to other members of the class. */
8104 && !PRIMARY_TEMPLATE_P (gen_tmpl)
8105 && !uses_template_parms (argvec))
8106 tsubst_default_arguments (r);
8109 DECL_TEMPLATE_INFO (r) = NULL_TREE;
8111 /* Copy the list of befriending classes. */
8112 for (friends = &DECL_BEFRIENDING_CLASSES (r);
8114 friends = &TREE_CHAIN (*friends))
8116 *friends = copy_node (*friends);
8117 TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends),
8122 if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r))
8124 maybe_retrofit_in_chrg (r);
8125 if (DECL_CONSTRUCTOR_P (r))
8126 grok_ctor_properties (ctx, r);
8127 /* If this is an instantiation of a member template, clone it.
8128 If it isn't, that'll be handled by
8129 clone_constructors_and_destructors. */
8130 if (PRIMARY_TEMPLATE_P (gen_tmpl))
8131 clone_function_decl (r, /*update_method_vec_p=*/0);
8133 else if (IDENTIFIER_OPNAME_P (DECL_NAME (r))
8134 && !grok_op_properties (r, (complain & tf_error) != 0))
8135 return error_mark_node;
8137 if (DECL_FRIEND_P (t) && DECL_FRIEND_CONTEXT (t))
8138 SET_DECL_FRIEND_CONTEXT (r,
8139 tsubst (DECL_FRIEND_CONTEXT (t),
8140 args, complain, in_decl));
8142 /* Possibly limit visibility based on template args. */
8143 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
8144 if (DECL_VISIBILITY_SPECIFIED (t))
8146 DECL_VISIBILITY_SPECIFIED (r) = 0;
8148 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
8150 determine_visibility (r);
8152 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
8153 args, complain, in_decl);
8159 tree type = NULL_TREE;
8161 tree expanded_types = NULL_TREE;
8162 tree prev_r = NULL_TREE;
8163 tree first_r = NULL_TREE;
8165 if (FUNCTION_PARAMETER_PACK_P (t))
8167 /* If there is a local specialization that isn't a
8168 parameter pack, it means that we're doing a "simple"
8169 substitution from inside tsubst_pack_expansion. Just
8170 return the local specialization (which will be a single
8172 tree spec = retrieve_local_specialization (t);
8174 && TREE_CODE (spec) == PARM_DECL
8175 && TREE_CODE (TREE_TYPE (spec)) != TYPE_PACK_EXPANSION)
8178 /* Expand the TYPE_PACK_EXPANSION that provides the types for
8179 the parameters in this function parameter pack. */
8180 expanded_types = tsubst_pack_expansion (TREE_TYPE (t), args,
8182 if (TREE_CODE (expanded_types) == TREE_VEC)
8184 len = TREE_VEC_LENGTH (expanded_types);
8186 /* Zero-length parameter packs are boring. Just substitute
8189 return tsubst (TREE_CHAIN (t), args, complain,
8194 /* All we did was update the type. Make a note of that. */
8195 type = expanded_types;
8196 expanded_types = NULL_TREE;
8200 /* Loop through all of the parameter's we'll build. When T is
8201 a function parameter pack, LEN is the number of expanded
8202 types in EXPANDED_TYPES; otherwise, LEN is 1. */
8204 for (i = 0; i < len; ++i)
8208 if (DECL_TEMPLATE_PARM_P (t))
8209 SET_DECL_TEMPLATE_PARM_P (r);
8212 /* We're on the Ith parameter of the function parameter
8215 /* Get the Ith type. */
8216 type = TREE_VEC_ELT (expanded_types, i);
8219 /* Rename the parameter to include the index. */
8221 make_ith_pack_parameter_name (DECL_NAME (r), i);
8224 /* We're dealing with a normal parameter. */
8225 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8227 type = type_decays_to (type);
8228 TREE_TYPE (r) = type;
8229 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
8231 if (DECL_INITIAL (r))
8233 if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
8234 DECL_INITIAL (r) = TREE_TYPE (r);
8236 DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
8240 DECL_CONTEXT (r) = NULL_TREE;
8242 if (!DECL_TEMPLATE_PARM_P (r))
8243 DECL_ARG_TYPE (r) = type_passed_as (type);
8245 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
8246 args, complain, in_decl);
8248 /* Keep track of the first new parameter we
8249 generate. That's what will be returned to the
8254 /* Build a proper chain of parameters when substituting
8255 into a function parameter pack. */
8257 TREE_CHAIN (prev_r) = r;
8261 TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args,
8262 complain, TREE_CHAIN (t));
8264 /* FIRST_R contains the start of the chain we've built. */
8274 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8275 if (type == error_mark_node)
8276 return error_mark_node;
8277 TREE_TYPE (r) = type;
8278 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
8280 /* DECL_INITIAL gives the number of bits in a bit-field. */
8282 = tsubst_expr (DECL_INITIAL (t), args,
8284 /*integral_constant_expression_p=*/true);
8285 /* We don't have to set DECL_CONTEXT here; it is set by
8286 finish_member_declaration. */
8287 TREE_CHAIN (r) = NULL_TREE;
8288 if (VOID_TYPE_P (type))
8289 error ("instantiation of %q+D as type %qT", r, type);
8291 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
8292 args, complain, in_decl);
8297 /* We reach here only for member using decls. */
8298 if (DECL_DEPENDENT_P (t))
8300 r = do_class_using_decl
8301 (tsubst_copy (USING_DECL_SCOPE (t), args, complain, in_decl),
8302 tsubst_copy (DECL_NAME (t), args, complain, in_decl));
8304 r = error_mark_node;
8309 TREE_CHAIN (r) = NULL_TREE;
8316 tree argvec = NULL_TREE;
8317 tree gen_tmpl = NULL_TREE;
8319 tree tmpl = NULL_TREE;
8321 tree type = NULL_TREE;
8324 if (TREE_CODE (t) == TYPE_DECL
8325 && t == TYPE_MAIN_DECL (TREE_TYPE (t)))
8327 /* If this is the canonical decl, we don't have to
8328 mess with instantiations, and often we can't (for
8329 typename, template type parms and such). Note that
8330 TYPE_NAME is not correct for the above test if
8331 we've copied the type for a typedef. */
8332 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8333 if (type == error_mark_node)
8334 return error_mark_node;
8335 r = TYPE_NAME (type);
8339 /* Check to see if we already have the specialization we
8342 if (DECL_CLASS_SCOPE_P (t) || DECL_NAMESPACE_SCOPE_P (t))
8344 /* T is a static data member or namespace-scope entity.
8345 We have to substitute into namespace-scope variables
8346 (even though such entities are never templates) because
8349 template <class T> void f() { extern T t; }
8351 where the entity referenced is not known until
8352 instantiation time. */
8354 ctx = DECL_CONTEXT (t);
8355 if (DECL_CLASS_SCOPE_P (t))
8357 ctx = tsubst_aggr_type (ctx, args,
8359 in_decl, /*entering_scope=*/1);
8360 /* If CTX is unchanged, then T is in fact the
8361 specialization we want. That situation occurs when
8362 referencing a static data member within in its own
8363 class. We can use pointer equality, rather than
8364 same_type_p, because DECL_CONTEXT is always
8366 if (ctx == DECL_CONTEXT (t))
8372 tmpl = DECL_TI_TEMPLATE (t);
8373 gen_tmpl = most_general_template (tmpl);
8374 argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl);
8375 spec = (retrieve_specialization
8377 /*class_specializations_p=*/false));
8382 /* A local variable. */
8384 /* Subsequent calls to pushdecl will fill this in. */
8386 spec = retrieve_local_specialization (t);
8388 /* If we already have the specialization we need, there is
8389 nothing more to do. */
8396 /* Create a new node for the specialization we need. */
8398 if (type == NULL_TREE)
8399 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8400 if (TREE_CODE (r) == VAR_DECL)
8402 /* Even if the original location is out of scope, the
8403 newly substituted one is not. */
8404 DECL_DEAD_FOR_LOCAL (r) = 0;
8405 DECL_INITIALIZED_P (r) = 0;
8406 DECL_TEMPLATE_INSTANTIATED (r) = 0;
8407 if (type == error_mark_node)
8408 return error_mark_node;
8409 if (TREE_CODE (type) == FUNCTION_TYPE)
8411 /* It may seem that this case cannot occur, since:
8416 declares a function, not a variable. However:
8419 template <typename T> void g() { T t; }
8420 template void g<f>();
8422 is an attempt to declare a variable with function
8424 error ("variable %qD has function type",
8425 /* R is not yet sufficiently initialized, so we
8426 just use its name. */
8428 return error_mark_node;
8430 type = complete_type (type);
8431 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
8432 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t);
8433 type = check_var_type (DECL_NAME (r), type);
8435 if (DECL_HAS_VALUE_EXPR_P (t))
8437 tree ve = DECL_VALUE_EXPR (t);
8438 ve = tsubst_expr (ve, args, complain, in_decl,
8439 /*constant_expression_p=*/false);
8440 SET_DECL_VALUE_EXPR (r, ve);
8443 else if (DECL_SELF_REFERENCE_P (t))
8444 SET_DECL_SELF_REFERENCE_P (r);
8445 TREE_TYPE (r) = type;
8446 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
8447 DECL_CONTEXT (r) = ctx;
8448 /* Clear out the mangled name and RTL for the instantiation. */
8449 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
8450 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
8451 SET_DECL_RTL (r, NULL_RTX);
8452 /* The initializer must not be expanded until it is required;
8454 DECL_INITIAL (r) = NULL_TREE;
8455 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
8456 SET_DECL_RTL (r, NULL_RTX);
8457 DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0;
8458 if (TREE_CODE (r) == VAR_DECL)
8460 /* Possibly limit visibility based on template args. */
8461 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
8462 if (DECL_VISIBILITY_SPECIFIED (t))
8464 DECL_VISIBILITY_SPECIFIED (r) = 0;
8466 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
8468 determine_visibility (r);
8470 /* Preserve a typedef that names a type. */
8471 else if (TREE_CODE (r) == TYPE_DECL
8472 && DECL_ORIGINAL_TYPE (t)
8473 && type != error_mark_node)
8475 DECL_ORIGINAL_TYPE (r) = tsubst (DECL_ORIGINAL_TYPE (t),
8476 args, complain, in_decl);
8477 TREE_TYPE (r) = type = build_variant_type_copy (type);
8478 TYPE_NAME (type) = r;
8483 /* A static data member declaration is always marked
8484 external when it is declared in-class, even if an
8485 initializer is present. We mimic the non-template
8487 DECL_EXTERNAL (r) = 1;
8489 register_specialization (r, gen_tmpl, argvec, false);
8490 DECL_TEMPLATE_INFO (r) = tree_cons (tmpl, argvec, NULL_TREE);
8491 SET_DECL_IMPLICIT_INSTANTIATION (r);
8494 register_local_specialization (r, t);
8496 TREE_CHAIN (r) = NULL_TREE;
8498 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r),
8499 (int) ATTR_FLAG_TYPE_IN_PLACE,
8500 args, complain, in_decl);
8509 /* Restore the file and line information. */
8510 input_location = saved_loc;
8515 /* Substitute into the ARG_TYPES of a function type. */
8518 tsubst_arg_types (tree arg_types,
8520 tsubst_flags_t complain,
8523 tree remaining_arg_types;
8524 tree type = NULL_TREE;
8526 tree expanded_args = NULL_TREE;
8529 if (!arg_types || arg_types == void_list_node)
8532 remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types),
8533 args, complain, in_decl);
8534 if (remaining_arg_types == error_mark_node)
8535 return error_mark_node;
8537 if (PACK_EXPANSION_P (TREE_VALUE (arg_types)))
8539 /* For a pack expansion, perform substitution on the
8540 entire expression. Later on, we'll handle the arguments
8542 expanded_args = tsubst_pack_expansion (TREE_VALUE (arg_types),
8543 args, complain, in_decl);
8545 if (TREE_CODE (expanded_args) == TREE_VEC)
8546 /* So that we'll spin through the parameters, one by one. */
8547 i = TREE_VEC_LENGTH (expanded_args);
8550 /* We only partially substituted into the parameter
8551 pack. Our type is TYPE_PACK_EXPANSION. */
8552 type = expanded_args;
8553 expanded_args = NULL_TREE;
8561 type = TREE_VEC_ELT (expanded_args, i);
8563 type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
8565 if (type == error_mark_node)
8566 return error_mark_node;
8567 if (VOID_TYPE_P (type))
8569 if (complain & tf_error)
8571 error ("invalid parameter type %qT", type);
8573 error ("in declaration %q+D", in_decl);
8575 return error_mark_node;
8578 /* Do array-to-pointer, function-to-pointer conversion, and ignore
8579 top-level qualifiers as required. */
8580 type = TYPE_MAIN_VARIANT (type_decays_to (type));
8582 /* We do not substitute into default arguments here. The standard
8583 mandates that they be instantiated only when needed, which is
8584 done in build_over_call. */
8585 default_arg = TREE_PURPOSE (arg_types);
8587 if (default_arg && TREE_CODE (default_arg) == DEFAULT_ARG)
8589 /* We've instantiated a template before its default arguments
8590 have been parsed. This can happen for a nested template
8591 class, and is not an error unless we require the default
8592 argument in a call of this function. */
8593 remaining_arg_types =
8594 tree_cons (default_arg, type, remaining_arg_types);
8595 VEC_safe_push (tree, gc, DEFARG_INSTANTIATIONS (default_arg),
8596 remaining_arg_types);
8599 remaining_arg_types =
8600 hash_tree_cons (default_arg, type, remaining_arg_types);
8603 return remaining_arg_types;
8606 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
8607 *not* handle the exception-specification for FNTYPE, because the
8608 initial substitution of explicitly provided template parameters
8609 during argument deduction forbids substitution into the
8610 exception-specification:
8614 All references in the function type of the function template to the
8615 corresponding template parameters are replaced by the specified tem-
8616 plate argument values. If a substitution in a template parameter or
8617 in the function type of the function template results in an invalid
8618 type, type deduction fails. [Note: The equivalent substitution in
8619 exception specifications is done only when the function is instanti-
8620 ated, at which point a program is ill-formed if the substitution
8621 results in an invalid type.] */
8624 tsubst_function_type (tree t,
8626 tsubst_flags_t complain,
8633 /* The TYPE_CONTEXT is not used for function/method types. */
8634 gcc_assert (TYPE_CONTEXT (t) == NULL_TREE);
8636 /* Substitute the return type. */
8637 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8638 if (return_type == error_mark_node)
8639 return error_mark_node;
8640 /* The standard does not presently indicate that creation of a
8641 function type with an invalid return type is a deduction failure.
8642 However, that is clearly analogous to creating an array of "void"
8643 or a reference to a reference. This is core issue #486. */
8644 if (TREE_CODE (return_type) == ARRAY_TYPE
8645 || TREE_CODE (return_type) == FUNCTION_TYPE)
8647 if (complain & tf_error)
8649 if (TREE_CODE (return_type) == ARRAY_TYPE)
8650 error ("function returning an array");
8652 error ("function returning a function");
8654 return error_mark_node;
8657 /* Substitute the argument types. */
8658 arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args,
8660 if (arg_types == error_mark_node)
8661 return error_mark_node;
8663 if (TYPE_QUALS (return_type) != TYPE_UNQUALIFIED
8664 && in_decl != NULL_TREE
8665 && !TREE_NO_WARNING (in_decl)
8666 && (SCALAR_TYPE_P (return_type) || VOID_TYPE_P (return_type)))
8667 warning (OPT_Wignored_qualifiers,
8668 "type qualifiers ignored on function return type");
8670 /* Construct a new type node and return it. */
8671 if (TREE_CODE (t) == FUNCTION_TYPE)
8672 fntype = build_function_type (return_type, arg_types);
8675 tree r = TREE_TYPE (TREE_VALUE (arg_types));
8676 if (! MAYBE_CLASS_TYPE_P (r))
8680 Type deduction may fail for any of the following
8683 -- Attempting to create "pointer to member of T" when T
8684 is not a class type. */
8685 if (complain & tf_error)
8686 error ("creating pointer to member function of non-class type %qT",
8688 return error_mark_node;
8691 fntype = build_method_type_directly (r, return_type,
8692 TREE_CHAIN (arg_types));
8694 fntype = cp_build_qualified_type_real (fntype, TYPE_QUALS (t), complain);
8695 fntype = cp_build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t));
8700 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
8701 ARGS into that specification, and return the substituted
8702 specification. If there is no specification, return NULL_TREE. */
8705 tsubst_exception_specification (tree fntype,
8707 tsubst_flags_t complain,
8713 specs = TYPE_RAISES_EXCEPTIONS (fntype);
8714 new_specs = NULL_TREE;
8717 if (! TREE_VALUE (specs))
8724 tree expanded_specs = NULL_TREE;
8726 if (PACK_EXPANSION_P (TREE_VALUE (specs)))
8728 /* Expand the pack expansion type. */
8729 expanded_specs = tsubst_pack_expansion (TREE_VALUE (specs),
8733 if (expanded_specs == error_mark_node)
8734 return error_mark_node;
8735 else if (TREE_CODE (expanded_specs) == TREE_VEC)
8736 len = TREE_VEC_LENGTH (expanded_specs);
8739 /* We're substituting into a member template, so
8740 we got a TYPE_PACK_EXPANSION back. Add that
8741 expansion and move on. */
8742 gcc_assert (TREE_CODE (expanded_specs)
8743 == TYPE_PACK_EXPANSION);
8744 new_specs = add_exception_specifier (new_specs,
8747 specs = TREE_CHAIN (specs);
8752 for (i = 0; i < len; ++i)
8755 spec = TREE_VEC_ELT (expanded_specs, i);
8757 spec = tsubst (TREE_VALUE (specs), args, complain, in_decl);
8758 if (spec == error_mark_node)
8760 new_specs = add_exception_specifier (new_specs, spec,
8764 specs = TREE_CHAIN (specs);
8770 /* Take the tree structure T and replace template parameters used
8771 therein with the argument vector ARGS. IN_DECL is an associated
8772 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
8773 Issue error and warning messages under control of COMPLAIN. Note
8774 that we must be relatively non-tolerant of extensions here, in
8775 order to preserve conformance; if we allow substitutions that
8776 should not be allowed, we may allow argument deductions that should
8777 not succeed, and therefore report ambiguous overload situations
8778 where there are none. In theory, we could allow the substitution,
8779 but indicate that it should have failed, and allow our caller to
8780 make sure that the right thing happens, but we don't try to do this
8783 This function is used for dealing with types, decls and the like;
8784 for expressions, use tsubst_expr or tsubst_copy. */
8787 tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
8791 if (t == NULL_TREE || t == error_mark_node
8792 || t == integer_type_node
8793 || t == void_type_node
8794 || t == char_type_node
8795 || t == unknown_type_node
8796 || TREE_CODE (t) == NAMESPACE_DECL)
8800 return tsubst_decl (t, args, complain);
8802 if (TREE_CODE (t) == IDENTIFIER_NODE)
8803 type = IDENTIFIER_TYPE_VALUE (t);
8805 type = TREE_TYPE (t);
8807 gcc_assert (type != unknown_type_node);
8809 /* Reuse typedefs. We need to do this to handle dependent attributes,
8810 such as attribute aligned. */
8813 && TYPE_NAME (t) != TYPE_MAIN_DECL (t))
8815 tree decl = TYPE_NAME (t);
8817 if (DECL_CLASS_SCOPE_P (decl)
8818 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl))
8819 && uses_template_parms (DECL_CONTEXT (decl)))
8821 tree tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
8822 tree gen_args = tsubst (DECL_TI_ARGS (decl), args, complain, in_decl);
8823 r = retrieve_specialization (tmpl, gen_args, false);
8825 else if (DECL_FUNCTION_SCOPE_P (decl)
8826 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl))
8827 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl))))
8828 r = retrieve_local_specialization (decl);
8830 /* The typedef is from a non-template context. */
8836 r = cp_build_qualified_type_real
8837 (r, cp_type_quals (t) | cp_type_quals (r),
8838 complain | tf_ignore_bad_quals);
8841 /* Else we must be instantiating the typedef, so fall through. */
8845 && TREE_CODE (t) != TYPENAME_TYPE
8846 && TREE_CODE (t) != IDENTIFIER_NODE
8847 && TREE_CODE (t) != FUNCTION_TYPE
8848 && TREE_CODE (t) != METHOD_TYPE)
8849 type = tsubst (type, args, complain, in_decl);
8850 if (type == error_mark_node)
8851 return error_mark_node;
8853 switch (TREE_CODE (t))
8858 return tsubst_aggr_type (t, args, complain, in_decl,
8859 /*entering_scope=*/0);
8862 case IDENTIFIER_NODE:
8874 if (t == integer_type_node)
8877 if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
8878 && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
8882 tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);
8884 max = tsubst_expr (omax, args, complain, in_decl,
8885 /*integral_constant_expression_p=*/false);
8886 max = fold_decl_constant_value (max);
8888 if (TREE_CODE (max) != INTEGER_CST
8889 && !at_function_scope_p ()
8890 && !value_dependent_expression_p (max))
8892 if (complain & tf_error)
8893 error ("array bound is not an integer constant");
8894 return error_mark_node;
8899 Type deduction may fail for any of the following
8902 Attempting to create an array with a size that is
8903 zero or negative. */
8904 if (integer_zerop (max) && !(complain & tf_error))
8905 /* We must fail if performing argument deduction (as
8906 indicated by the state of complain), so that
8907 another substitution can be found. */
8908 return error_mark_node;
8909 else if (TREE_CODE (max) == INTEGER_CST
8910 && INT_CST_LT (max, integer_zero_node))
8912 if (complain & tf_error)
8913 error ("creating array with negative size (%qE)", max);
8915 return error_mark_node;
8918 return compute_array_index_type (NULL_TREE, max);
8921 case TEMPLATE_TYPE_PARM:
8922 case TEMPLATE_TEMPLATE_PARM:
8923 case BOUND_TEMPLATE_TEMPLATE_PARM:
8924 case TEMPLATE_PARM_INDEX:
8929 tree arg = NULL_TREE;
8933 gcc_assert (TREE_VEC_LENGTH (args) > 0);
8934 template_parm_level_and_index (t, &level, &idx);
8936 levels = TMPL_ARGS_DEPTH (args);
8937 if (level <= levels)
8939 arg = TMPL_ARG (args, level, idx);
8941 if (arg && TREE_CODE (arg) == ARGUMENT_PACK_SELECT)
8942 /* See through ARGUMENT_PACK_SELECT arguments. */
8943 arg = ARGUMENT_PACK_SELECT_ARG (arg);
8946 if (arg == error_mark_node)
8947 return error_mark_node;
8948 else if (arg != NULL_TREE)
8950 if (ARGUMENT_PACK_P (arg))
8951 /* If ARG is an argument pack, we don't actually want to
8952 perform a substitution here, because substitutions
8953 for argument packs are only done
8954 element-by-element. We can get to this point when
8955 substituting the type of a non-type template
8956 parameter pack, when that type actually contains
8957 template parameter packs from an outer template, e.g.,
8959 template<typename... Types> struct A {
8960 template<Types... Values> struct B { };
8964 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
8967 gcc_assert (TYPE_P (arg));
8969 /* cv-quals from the template are discarded when
8970 substituting in a function or reference type. */
8971 if (TREE_CODE (arg) == FUNCTION_TYPE
8972 || TREE_CODE (arg) == METHOD_TYPE
8973 || TREE_CODE (arg) == REFERENCE_TYPE)
8974 quals = cp_type_quals (arg);
8976 quals = cp_type_quals (arg) | cp_type_quals (t);
8978 return cp_build_qualified_type_real
8979 (arg, quals, complain | tf_ignore_bad_quals);
8981 else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
8983 /* We are processing a type constructed from a
8984 template template parameter. */
8985 tree argvec = tsubst (TYPE_TI_ARGS (t),
8986 args, complain, in_decl);
8987 if (argvec == error_mark_node)
8988 return error_mark_node;
8990 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
8991 are resolving nested-types in the signature of a
8992 member function templates. Otherwise ARG is a
8993 TEMPLATE_DECL and is the real template to be
8995 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
8996 arg = TYPE_NAME (arg);
8998 r = lookup_template_class (arg,
9001 /*entering_scope=*/0,
9003 return cp_build_qualified_type_real
9004 (r, TYPE_QUALS (t), complain);
9007 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
9012 /* This can happen during the attempted tsubst'ing in
9013 unify. This means that we don't yet have any information
9014 about the template parameter in question. */
9017 /* If we get here, we must have been looking at a parm for a
9018 more deeply nested template. Make a new version of this
9019 template parameter, but with a lower level. */
9020 switch (TREE_CODE (t))
9022 case TEMPLATE_TYPE_PARM:
9023 case TEMPLATE_TEMPLATE_PARM:
9024 case BOUND_TEMPLATE_TEMPLATE_PARM:
9025 if (cp_type_quals (t))
9027 r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
9028 r = cp_build_qualified_type_real
9029 (r, cp_type_quals (t),
9030 complain | (TREE_CODE (t) == TEMPLATE_TYPE_PARM
9031 ? tf_ignore_bad_quals : 0));
9036 TEMPLATE_TYPE_PARM_INDEX (r)
9037 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t),
9038 r, levels, args, complain);
9039 TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r);
9040 TYPE_MAIN_VARIANT (r) = r;
9041 TYPE_POINTER_TO (r) = NULL_TREE;
9042 TYPE_REFERENCE_TO (r) = NULL_TREE;
9044 if (TREE_CODE (r) == TEMPLATE_TEMPLATE_PARM)
9045 /* We have reduced the level of the template
9046 template parameter, but not the levels of its
9047 template parameters, so canonical_type_parameter
9048 will not be able to find the canonical template
9049 template parameter for this level. Thus, we
9050 require structural equality checking to compare
9051 TEMPLATE_TEMPLATE_PARMs. */
9052 SET_TYPE_STRUCTURAL_EQUALITY (r);
9053 else if (TYPE_STRUCTURAL_EQUALITY_P (t))
9054 SET_TYPE_STRUCTURAL_EQUALITY (r);
9056 TYPE_CANONICAL (r) = canonical_type_parameter (r);
9058 if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
9060 tree argvec = tsubst (TYPE_TI_ARGS (t), args,
9062 if (argvec == error_mark_node)
9063 return error_mark_node;
9065 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r)
9066 = tree_cons (TYPE_TI_TEMPLATE (t), argvec, NULL_TREE);
9071 case TEMPLATE_PARM_INDEX:
9072 r = reduce_template_parm_level (t, type, levels, args, complain);
9084 tree purpose, value, chain;
9086 if (t == void_list_node)
9089 purpose = TREE_PURPOSE (t);
9092 purpose = tsubst (purpose, args, complain, in_decl);
9093 if (purpose == error_mark_node)
9094 return error_mark_node;
9096 value = TREE_VALUE (t);
9099 value = tsubst (value, args, complain, in_decl);
9100 if (value == error_mark_node)
9101 return error_mark_node;
9103 chain = TREE_CHAIN (t);
9104 if (chain && chain != void_type_node)
9106 chain = tsubst (chain, args, complain, in_decl);
9107 if (chain == error_mark_node)
9108 return error_mark_node;
9110 if (purpose == TREE_PURPOSE (t)
9111 && value == TREE_VALUE (t)
9112 && chain == TREE_CHAIN (t))
9114 return hash_tree_cons (purpose, value, chain);
9118 /* We should never be tsubsting a binfo. */
9122 /* A vector of template arguments. */
9124 return tsubst_template_args (t, args, complain, in_decl);
9127 case REFERENCE_TYPE:
9129 enum tree_code code;
9131 if (type == TREE_TYPE (t) && TREE_CODE (type) != METHOD_TYPE)
9134 code = TREE_CODE (t);
9139 Type deduction may fail for any of the following
9142 -- Attempting to create a pointer to reference type.
9143 -- Attempting to create a reference to a reference type or
9144 a reference to void.
9146 Core issue 106 says that creating a reference to a reference
9147 during instantiation is no longer a cause for failure. We
9148 only enforce this check in strict C++98 mode. */
9149 if ((TREE_CODE (type) == REFERENCE_TYPE
9150 && (((cxx_dialect == cxx98) && flag_iso) || code != REFERENCE_TYPE))
9151 || (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE))
9153 static location_t last_loc;
9155 /* We keep track of the last time we issued this error
9156 message to avoid spewing a ton of messages during a
9157 single bad template instantiation. */
9158 if (complain & tf_error
9159 && last_loc != input_location)
9161 if (TREE_CODE (type) == VOID_TYPE)
9162 error ("forming reference to void");
9164 error ("forming %s to reference type %qT",
9165 (code == POINTER_TYPE) ? "pointer" : "reference",
9167 last_loc = input_location;
9170 return error_mark_node;
9172 else if (code == POINTER_TYPE)
9174 r = build_pointer_type (type);
9175 if (TREE_CODE (type) == METHOD_TYPE)
9176 r = build_ptrmemfunc_type (r);
9178 else if (TREE_CODE (type) == REFERENCE_TYPE)
9179 /* In C++0x, during template argument substitution, when there is an
9180 attempt to create a reference to a reference type, reference
9181 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
9183 "If a template-argument for a template-parameter T names a type
9184 that is a reference to a type A, an attempt to create the type
9185 'lvalue reference to cv T' creates the type 'lvalue reference to
9186 A,' while an attempt to create the type type rvalue reference to
9187 cv T' creates the type T"
9189 r = cp_build_reference_type
9191 TYPE_REF_IS_RVALUE (t) && TYPE_REF_IS_RVALUE (type));
9193 r = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
9194 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
9196 if (r != error_mark_node)
9197 /* Will this ever be needed for TYPE_..._TO values? */
9204 r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
9205 if (r == error_mark_node || !MAYBE_CLASS_TYPE_P (r))
9209 Type deduction may fail for any of the following
9212 -- Attempting to create "pointer to member of T" when T
9213 is not a class type. */
9214 if (complain & tf_error)
9215 error ("creating pointer to member of non-class type %qT", r);
9216 return error_mark_node;
9218 if (TREE_CODE (type) == REFERENCE_TYPE)
9220 if (complain & tf_error)
9221 error ("creating pointer to member reference type %qT", type);
9222 return error_mark_node;
9224 if (TREE_CODE (type) == VOID_TYPE)
9226 if (complain & tf_error)
9227 error ("creating pointer to member of type void");
9228 return error_mark_node;
9230 gcc_assert (TREE_CODE (type) != METHOD_TYPE);
9231 if (TREE_CODE (type) == FUNCTION_TYPE)
9233 /* The type of the implicit object parameter gets its
9234 cv-qualifiers from the FUNCTION_TYPE. */
9236 tree this_type = cp_build_qualified_type (TYPE_MAIN_VARIANT (r),
9237 cp_type_quals (type));
9239 method_type = build_method_type_directly (this_type,
9241 TYPE_ARG_TYPES (type));
9242 memptr = build_ptrmemfunc_type (build_pointer_type (method_type));
9243 return cp_build_qualified_type_real (memptr, cp_type_quals (t),
9247 return cp_build_qualified_type_real (build_ptrmem_type (r, type),
9256 fntype = tsubst_function_type (t, args, complain, in_decl);
9257 if (fntype == error_mark_node)
9258 return error_mark_node;
9260 /* Substitute the exception specification. */
9261 specs = tsubst_exception_specification (t, args, complain,
9263 if (specs == error_mark_node)
9264 return error_mark_node;
9266 fntype = build_exception_variant (fntype, specs);
9271 tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
9272 if (domain == error_mark_node)
9273 return error_mark_node;
9275 /* As an optimization, we avoid regenerating the array type if
9276 it will obviously be the same as T. */
9277 if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
9280 /* These checks should match the ones in grokdeclarator.
9284 The deduction may fail for any of the following reasons:
9286 -- Attempting to create an array with an element type that
9287 is void, a function type, or a reference type, or [DR337]
9288 an abstract class type. */
9289 if (TREE_CODE (type) == VOID_TYPE
9290 || TREE_CODE (type) == FUNCTION_TYPE
9291 || TREE_CODE (type) == REFERENCE_TYPE)
9293 if (complain & tf_error)
9294 error ("creating array of %qT", type);
9295 return error_mark_node;
9297 if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
9299 if (complain & tf_error)
9300 error ("creating array of %qT, which is an abstract class type",
9302 return error_mark_node;
9305 r = build_cplus_array_type (type, domain);
9307 if (TYPE_USER_ALIGN (t))
9309 TYPE_ALIGN (r) = TYPE_ALIGN (t);
9310 TYPE_USER_ALIGN (r) = 1;
9319 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
9320 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
9322 if (e1 == error_mark_node || e2 == error_mark_node)
9323 return error_mark_node;
9325 return fold_build2 (TREE_CODE (t), TREE_TYPE (t), e1, e2);
9331 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
9332 if (e == error_mark_node)
9333 return error_mark_node;
9335 return fold_build1 (TREE_CODE (t), TREE_TYPE (t), e);
9340 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
9341 in_decl, /*entering_scope=*/1);
9342 tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
9345 if (ctx == error_mark_node || f == error_mark_node)
9346 return error_mark_node;
9348 if (!MAYBE_CLASS_TYPE_P (ctx))
9350 if (complain & tf_error)
9351 error ("%qT is not a class, struct, or union type", ctx);
9352 return error_mark_node;
9354 else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
9356 /* Normally, make_typename_type does not require that the CTX
9357 have complete type in order to allow things like:
9359 template <class T> struct S { typename S<T>::X Y; };
9361 But, such constructs have already been resolved by this
9362 point, so here CTX really should have complete type, unless
9363 it's a partial instantiation. */
9364 ctx = complete_type (ctx);
9365 if (!COMPLETE_TYPE_P (ctx))
9367 if (complain & tf_error)
9368 cxx_incomplete_type_error (NULL_TREE, ctx);
9369 return error_mark_node;
9373 f = make_typename_type (ctx, f, typename_type,
9374 (complain & tf_error) | tf_keep_type_decl);
9375 if (f == error_mark_node)
9377 if (TREE_CODE (f) == TYPE_DECL)
9379 complain |= tf_ignore_bad_quals;
9383 if (TREE_CODE (f) != TYPENAME_TYPE)
9385 if (TYPENAME_IS_ENUM_P (t) && TREE_CODE (f) != ENUMERAL_TYPE)
9386 error ("%qT resolves to %qT, which is not an enumeration type",
9388 else if (TYPENAME_IS_CLASS_P (t) && !CLASS_TYPE_P (f))
9389 error ("%qT resolves to %qT, which is is not a class type",
9393 return cp_build_qualified_type_real
9394 (f, cp_type_quals (f) | cp_type_quals (t), complain);
9397 case UNBOUND_CLASS_TEMPLATE:
9399 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
9400 in_decl, /*entering_scope=*/1);
9401 tree name = TYPE_IDENTIFIER (t);
9402 tree parm_list = DECL_TEMPLATE_PARMS (TYPE_NAME (t));
9404 if (ctx == error_mark_node || name == error_mark_node)
9405 return error_mark_node;
9408 parm_list = tsubst_template_parms (parm_list, args, complain);
9409 return make_unbound_class_template (ctx, name, parm_list, complain);
9419 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
9420 tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl,
9421 /*integral_constant_expression_p=*/false);
9422 if (e1 == error_mark_node || e2 == error_mark_node)
9423 return error_mark_node;
9425 return build_nt (ARRAY_REF, e1, e2, NULL_TREE, NULL_TREE);
9430 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
9431 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
9432 if (e1 == error_mark_node || e2 == error_mark_node)
9433 return error_mark_node;
9435 return build_qualified_name (/*type=*/NULL_TREE,
9436 e1, e2, QUALIFIED_NAME_IS_TEMPLATE (t));
9443 type = finish_typeof (tsubst_expr
9444 (TYPEOF_TYPE_EXPR (t), args,
9446 /*integral_constant_expression_p=*/false));
9447 return cp_build_qualified_type_real (type,
9449 | cp_type_quals (type),
9458 finish_decltype_type (tsubst_expr
9459 (DECLTYPE_TYPE_EXPR (t), args,
9461 /*integral_constant_expression_p=*/false),
9462 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t));
9463 return cp_build_qualified_type_real (type,
9465 | cp_type_quals (type),
9469 case TYPE_ARGUMENT_PACK:
9470 case NONTYPE_ARGUMENT_PACK:
9472 tree r = make_node (TREE_CODE (t));
9474 tsubst_template_args (ARGUMENT_PACK_ARGS (t),
9478 SET_ARGUMENT_PACK_ARGS (r, packed_out);
9480 /* For template nontype argument packs, also substitute into
9482 if (TREE_CODE (t) == NONTYPE_ARGUMENT_PACK)
9483 TREE_TYPE (r) = tsubst (TREE_TYPE (t), args, complain, in_decl);
9490 sorry ("use of %qs in template",
9491 tree_code_name [(int) TREE_CODE (t)]);
9492 return error_mark_node;
9496 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
9497 type of the expression on the left-hand side of the "." or "->"
9501 tsubst_baselink (tree baselink, tree object_type,
9502 tree args, tsubst_flags_t complain, tree in_decl)
9505 tree qualifying_scope;
9508 tree template_args = 0;
9509 bool template_id_p = false;
9511 /* A baselink indicates a function from a base class. Both the
9512 BASELINK_ACCESS_BINFO and the base class referenced may
9513 indicate bases of the template class, rather than the
9514 instantiated class. In addition, lookups that were not
9515 ambiguous before may be ambiguous now. Therefore, we perform
9516 the lookup again. */
9517 qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink));
9518 qualifying_scope = tsubst (qualifying_scope, args,
9520 fns = BASELINK_FUNCTIONS (baselink);
9521 optype = BASELINK_OPTYPE (baselink);
9522 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
9524 template_id_p = true;
9525 template_args = TREE_OPERAND (fns, 1);
9526 fns = TREE_OPERAND (fns, 0);
9528 template_args = tsubst_template_args (template_args, args,
9531 name = DECL_NAME (get_first_fn (fns));
9532 baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1);
9534 /* If lookup found a single function, mark it as used at this
9535 point. (If it lookup found multiple functions the one selected
9536 later by overload resolution will be marked as used at that
9538 if (BASELINK_P (baselink))
9539 fns = BASELINK_FUNCTIONS (baselink);
9540 if (!template_id_p && !really_overloaded_fn (fns))
9541 mark_used (OVL_CURRENT (fns));
9543 /* Add back the template arguments, if present. */
9544 if (BASELINK_P (baselink) && template_id_p)
9545 BASELINK_FUNCTIONS (baselink)
9546 = build_nt (TEMPLATE_ID_EXPR,
9547 BASELINK_FUNCTIONS (baselink),
9549 /* Update the conversion operator type. */
9550 BASELINK_OPTYPE (baselink)
9551 = tsubst (optype, args, complain, in_decl);
9554 object_type = current_class_type;
9555 return adjust_result_of_qualified_name_lookup (baselink,
9560 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
9561 true if the qualified-id will be a postfix-expression in-and-of
9562 itself; false if more of the postfix-expression follows the
9563 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
9567 tsubst_qualified_id (tree qualified_id, tree args,
9568 tsubst_flags_t complain, tree in_decl,
9569 bool done, bool address_p)
9577 gcc_assert (TREE_CODE (qualified_id) == SCOPE_REF);
9579 /* Figure out what name to look up. */
9580 name = TREE_OPERAND (qualified_id, 1);
9581 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
9584 template_args = TREE_OPERAND (name, 1);
9586 template_args = tsubst_template_args (template_args, args,
9588 name = TREE_OPERAND (name, 0);
9592 is_template = false;
9593 template_args = NULL_TREE;
9596 /* Substitute into the qualifying scope. When there are no ARGS, we
9597 are just trying to simplify a non-dependent expression. In that
9598 case the qualifying scope may be dependent, and, in any case,
9599 substituting will not help. */
9600 scope = TREE_OPERAND (qualified_id, 0);
9603 scope = tsubst (scope, args, complain, in_decl);
9604 expr = tsubst_copy (name, args, complain, in_decl);
9609 if (dependent_type_p (scope))
9610 return build_qualified_name (/*type=*/NULL_TREE,
9612 QUALIFIED_NAME_IS_TEMPLATE (qualified_id));
9614 if (!BASELINK_P (name) && !DECL_P (expr))
9616 if (TREE_CODE (expr) == BIT_NOT_EXPR)
9617 /* If this were actually a destructor call, it would have been
9618 parsed as such by the parser. */
9619 expr = error_mark_node;
9621 expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0, false);
9622 if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL
9623 ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL)
9625 if (complain & tf_error)
9627 error ("dependent-name %qE is parsed as a non-type, but "
9628 "instantiation yields a type", qualified_id);
9629 inform ("say %<typename %E%> if a type is meant", qualified_id);
9631 return error_mark_node;
9637 check_accessibility_of_qualified_id (expr, /*object_type=*/NULL_TREE,
9639 /* Remember that there was a reference to this entity. */
9643 if (expr == error_mark_node || TREE_CODE (expr) == TREE_LIST)
9645 if (complain & tf_error)
9646 qualified_name_lookup_error (scope,
9647 TREE_OPERAND (qualified_id, 1),
9649 return error_mark_node;
9653 expr = lookup_template_function (expr, template_args);
9655 if (expr == error_mark_node && complain & tf_error)
9656 qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1),
9658 else if (TYPE_P (scope))
9660 expr = (adjust_result_of_qualified_name_lookup
9661 (expr, scope, current_class_type));
9662 expr = (finish_qualified_id_expr
9663 (scope, expr, done, address_p,
9664 QUALIFIED_NAME_IS_TEMPLATE (qualified_id),
9665 /*template_arg_p=*/false));
9668 /* Expressions do not generally have reference type. */
9669 if (TREE_CODE (expr) != SCOPE_REF
9670 /* However, if we're about to form a pointer-to-member, we just
9671 want the referenced member referenced. */
9672 && TREE_CODE (expr) != OFFSET_REF)
9673 expr = convert_from_reference (expr);
9678 /* Like tsubst, but deals with expressions. This function just replaces
9679 template parms; to finish processing the resultant expression, use
9683 tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
9685 enum tree_code code;
9688 if (t == NULL_TREE || t == error_mark_node)
9691 code = TREE_CODE (t);
9696 r = retrieve_local_specialization (t);
9697 gcc_assert (r != NULL);
9698 if (TREE_CODE (r) == ARGUMENT_PACK_SELECT)
9699 r = ARGUMENT_PACK_SELECT_ARG (r);
9708 if (DECL_TEMPLATE_PARM_P (t))
9709 return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
9710 /* There is no need to substitute into namespace-scope
9712 if (DECL_NAMESPACE_SCOPE_P (t))
9714 /* If ARGS is NULL, then T is known to be non-dependent. */
9715 if (args == NULL_TREE)
9716 return integral_constant_value (t);
9718 /* Unfortunately, we cannot just call lookup_name here.
9721 template <int I> int f() {
9723 struct S { void g() { E e = a; } };
9726 When we instantiate f<7>::S::g(), say, lookup_name is not
9727 clever enough to find f<7>::a. */
9729 = tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl,
9730 /*entering_scope=*/0);
9732 for (v = TYPE_VALUES (enum_type);
9735 if (TREE_PURPOSE (v) == DECL_NAME (t))
9736 return TREE_VALUE (v);
9738 /* We didn't find the name. That should never happen; if
9739 name-lookup found it during preliminary parsing, we
9740 should find it again here during instantiation. */
9746 if (DECL_CONTEXT (t))
9750 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
9751 /*entering_scope=*/1);
9752 if (ctx != DECL_CONTEXT (t))
9754 tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
9757 if (complain & tf_error)
9758 error ("using invalid field %qD", t);
9759 return error_mark_node;
9769 if ((DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
9770 || local_variable_p (t))
9771 t = tsubst (t, args, complain, in_decl);
9776 return tsubst_baselink (t, current_class_type, args, complain, in_decl);
9779 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
9780 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
9781 args, complain, in_decl);
9782 else if (DECL_FUNCTION_TEMPLATE_P (t) && DECL_MEMBER_TEMPLATE_P (t))
9783 return tsubst (t, args, complain, in_decl);
9784 else if (DECL_CLASS_SCOPE_P (t)
9785 && uses_template_parms (DECL_CONTEXT (t)))
9787 /* Template template argument like the following example need
9790 template <template <class> class TT> struct C {};
9791 template <class T> struct D {
9792 template <class U> struct E {};
9797 We are processing the template argument `E' in #1 for
9798 the template instantiation #2. Originally, `E' is a
9799 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
9800 have to substitute this with one having context `D<int>'. */
9802 tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
9803 return lookup_field (context, DECL_NAME(t), 0, false);
9806 /* Ordinary template template argument. */
9810 case REINTERPRET_CAST_EXPR:
9811 case CONST_CAST_EXPR:
9812 case STATIC_CAST_EXPR:
9813 case DYNAMIC_CAST_EXPR:
9816 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
9817 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
9820 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
9822 /* We only want to compute the number of arguments. */
9823 tree expanded = tsubst_pack_expansion (TREE_OPERAND (t, 0), args,
9825 if (expanded == error_mark_node)
9826 return error_mark_node;
9827 return build_int_cst (size_type_node, TREE_VEC_LENGTH (expanded));
9833 case TRUTH_NOT_EXPR:
9836 case UNARY_PLUS_EXPR: /* Unary + */
9844 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
9845 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
9852 object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
9853 name = TREE_OPERAND (t, 1);
9854 if (TREE_CODE (name) == BIT_NOT_EXPR)
9856 name = tsubst_copy (TREE_OPERAND (name, 0), args,
9858 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
9860 else if (TREE_CODE (name) == SCOPE_REF
9861 && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
9863 tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
9865 name = TREE_OPERAND (name, 1);
9866 name = tsubst_copy (TREE_OPERAND (name, 0), args,
9868 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
9869 name = build_qualified_name (/*type=*/NULL_TREE,
9871 /*template_p=*/false);
9873 else if (TREE_CODE (name) == BASELINK)
9874 name = tsubst_baselink (name,
9875 non_reference (TREE_TYPE (object)),
9879 name = tsubst_copy (name, args, complain, in_decl);
9880 return build_nt (COMPONENT_REF, object, name, NULL_TREE);
9886 case TRUNC_DIV_EXPR:
9888 case FLOOR_DIV_EXPR:
9889 case ROUND_DIV_EXPR:
9890 case EXACT_DIV_EXPR:
9894 case TRUNC_MOD_EXPR:
9895 case FLOOR_MOD_EXPR:
9896 case TRUTH_ANDIF_EXPR:
9897 case TRUTH_ORIF_EXPR:
9898 case TRUTH_AND_EXPR:
9915 case PREDECREMENT_EXPR:
9916 case PREINCREMENT_EXPR:
9917 case POSTDECREMENT_EXPR:
9918 case POSTINCREMENT_EXPR:
9920 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9921 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
9924 return build_qualified_name (/*type=*/NULL_TREE,
9925 tsubst_copy (TREE_OPERAND (t, 0),
9926 args, complain, in_decl),
9927 tsubst_copy (TREE_OPERAND (t, 1),
9928 args, complain, in_decl),
9929 QUALIFIED_NAME_IS_TEMPLATE (t));
9934 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9935 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
9936 NULL_TREE, NULL_TREE);
9940 int n = VL_EXP_OPERAND_LENGTH (t);
9941 tree result = build_vl_exp (CALL_EXPR, n);
9943 for (i = 0; i < n; i++)
9944 TREE_OPERAND (t, i) = tsubst_copy (TREE_OPERAND (t, i), args,
9951 case PSEUDO_DTOR_EXPR:
9954 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9955 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
9956 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
9957 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
9964 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9965 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
9966 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
9967 NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
9974 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9975 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
9976 DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
9977 DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
9981 case TEMPLATE_ID_EXPR:
9983 /* Substituted template arguments */
9984 tree fn = TREE_OPERAND (t, 0);
9985 tree targs = TREE_OPERAND (t, 1);
9987 fn = tsubst_copy (fn, args, complain, in_decl);
9989 targs = tsubst_template_args (targs, args, complain, in_decl);
9991 return lookup_template_function (fn, targs);
9996 tree purpose, value, chain;
9998 if (t == void_list_node)
10001 purpose = TREE_PURPOSE (t);
10003 purpose = tsubst_copy (purpose, args, complain, in_decl);
10004 value = TREE_VALUE (t);
10006 value = tsubst_copy (value, args, complain, in_decl);
10007 chain = TREE_CHAIN (t);
10008 if (chain && chain != void_type_node)
10009 chain = tsubst_copy (chain, args, complain, in_decl);
10010 if (purpose == TREE_PURPOSE (t)
10011 && value == TREE_VALUE (t)
10012 && chain == TREE_CHAIN (t))
10014 return tree_cons (purpose, value, chain);
10019 case ENUMERAL_TYPE:
10021 case TEMPLATE_TYPE_PARM:
10022 case TEMPLATE_TEMPLATE_PARM:
10023 case BOUND_TEMPLATE_TEMPLATE_PARM:
10024 case TEMPLATE_PARM_INDEX:
10026 case REFERENCE_TYPE:
10028 case FUNCTION_TYPE:
10031 case TYPENAME_TYPE:
10032 case UNBOUND_CLASS_TEMPLATE:
10034 case DECLTYPE_TYPE:
10036 return tsubst (t, args, complain, in_decl);
10038 case IDENTIFIER_NODE:
10039 if (IDENTIFIER_TYPENAME_P (t))
10041 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10042 return mangle_conv_op_name_for_type (new_type);
10048 /* This is handled by tsubst_copy_and_build. */
10049 gcc_unreachable ();
10052 return build_x_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain,
10054 tsubst (TREE_TYPE (t), args, complain, in_decl));
10056 case CLEANUP_POINT_EXPR:
10057 /* We shouldn't have built any of these during initial template
10058 generation. Instead, they should be built during instantiation
10059 in response to the saved STMT_IS_FULL_EXPR_P setting. */
10060 gcc_unreachable ();
10063 mark_used (TREE_OPERAND (t, 1));
10066 case EXPR_PACK_EXPANSION:
10067 error ("invalid use of pack expansion expression");
10068 return error_mark_node;
10070 case NONTYPE_ARGUMENT_PACK:
10071 error ("use %<...%> to expand argument pack");
10072 return error_mark_node;
10079 /* Like tsubst_copy, but specifically for OpenMP clauses. */
10082 tsubst_omp_clauses (tree clauses, tree args, tsubst_flags_t complain,
10085 tree new_clauses = NULL, nc, oc;
10087 for (oc = clauses; oc ; oc = OMP_CLAUSE_CHAIN (oc))
10089 nc = copy_node (oc);
10090 OMP_CLAUSE_CHAIN (nc) = new_clauses;
10093 switch (OMP_CLAUSE_CODE (nc))
10095 case OMP_CLAUSE_PRIVATE:
10096 case OMP_CLAUSE_SHARED:
10097 case OMP_CLAUSE_FIRSTPRIVATE:
10098 case OMP_CLAUSE_LASTPRIVATE:
10099 case OMP_CLAUSE_REDUCTION:
10100 case OMP_CLAUSE_COPYIN:
10101 case OMP_CLAUSE_COPYPRIVATE:
10102 case OMP_CLAUSE_IF:
10103 case OMP_CLAUSE_NUM_THREADS:
10104 case OMP_CLAUSE_SCHEDULE:
10105 OMP_CLAUSE_OPERAND (nc, 0)
10106 = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 0), args, complain,
10107 in_decl, /*integral_constant_expression_p=*/false);
10109 case OMP_CLAUSE_NOWAIT:
10110 case OMP_CLAUSE_ORDERED:
10111 case OMP_CLAUSE_DEFAULT:
10114 gcc_unreachable ();
10118 return finish_omp_clauses (nreverse (new_clauses));
10121 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
10124 tsubst_copy_asm_operands (tree t, tree args, tsubst_flags_t complain,
10127 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
10129 tree purpose, value, chain;
10134 if (TREE_CODE (t) != TREE_LIST)
10135 return tsubst_copy_and_build (t, args, complain, in_decl,
10136 /*function_p=*/false,
10137 /*integral_constant_expression_p=*/false);
10139 if (t == void_list_node)
10142 purpose = TREE_PURPOSE (t);
10144 purpose = RECUR (purpose);
10145 value = TREE_VALUE (t);
10147 value = RECUR (value);
10148 chain = TREE_CHAIN (t);
10149 if (chain && chain != void_type_node)
10150 chain = RECUR (chain);
10151 return tree_cons (purpose, value, chain);
10155 /* Like tsubst_copy for expressions, etc. but also does semantic
10159 tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl,
10160 bool integral_constant_expression_p)
10162 #define RECUR(NODE) \
10163 tsubst_expr ((NODE), args, complain, in_decl, \
10164 integral_constant_expression_p)
10168 if (t == NULL_TREE || t == error_mark_node)
10171 if (EXPR_HAS_LOCATION (t))
10172 input_location = EXPR_LOCATION (t);
10173 if (STATEMENT_CODE_P (TREE_CODE (t)))
10174 current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
10176 switch (TREE_CODE (t))
10178 case STATEMENT_LIST:
10180 tree_stmt_iterator i;
10181 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
10182 RECUR (tsi_stmt (i));
10186 case CTOR_INITIALIZER:
10187 finish_mem_initializers (tsubst_initializer_list
10188 (TREE_OPERAND (t, 0), args));
10192 finish_return_stmt (RECUR (TREE_OPERAND (t, 0)));
10196 tmp = RECUR (EXPR_STMT_EXPR (t));
10197 if (EXPR_STMT_STMT_EXPR_RESULT (t))
10198 finish_stmt_expr_expr (tmp, cur_stmt_expr);
10200 finish_expr_stmt (tmp);
10204 do_using_directive (RECUR (USING_STMT_NAMESPACE (t)));
10212 decl = DECL_EXPR_DECL (t);
10213 if (TREE_CODE (decl) == LABEL_DECL)
10214 finish_label_decl (DECL_NAME (decl));
10215 else if (TREE_CODE (decl) == USING_DECL)
10217 tree scope = USING_DECL_SCOPE (decl);
10218 tree name = DECL_NAME (decl);
10221 scope = RECUR (scope);
10222 decl = lookup_qualified_name (scope, name,
10223 /*is_type_p=*/false,
10224 /*complain=*/false);
10225 if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
10226 qualified_name_lookup_error (scope, name, decl);
10228 do_local_using_decl (decl, scope, name);
10232 init = DECL_INITIAL (decl);
10233 decl = tsubst (decl, args, complain, in_decl);
10234 if (decl != error_mark_node)
10236 /* By marking the declaration as instantiated, we avoid
10237 trying to instantiate it. Since instantiate_decl can't
10238 handle local variables, and since we've already done
10239 all that needs to be done, that's the right thing to
10241 if (TREE_CODE (decl) == VAR_DECL)
10242 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
10243 if (TREE_CODE (decl) == VAR_DECL
10244 && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
10245 /* Anonymous aggregates are a special case. */
10246 finish_anon_union (decl);
10249 maybe_push_decl (decl);
10250 if (TREE_CODE (decl) == VAR_DECL
10251 && DECL_PRETTY_FUNCTION_P (decl))
10253 /* For __PRETTY_FUNCTION__ we have to adjust the
10255 const char *const name
10256 = cxx_printable_name (current_function_decl, 2);
10257 init = cp_fname_init (name, &TREE_TYPE (decl));
10261 tree t = RECUR (init);
10264 /* If we had an initializer but it
10265 instantiated to nothing,
10266 value-initialize the object. This will
10267 only occur when the initializer was a
10268 pack expansion where the parameter packs
10269 used in that expansion were of length
10271 init = build_default_init (TREE_TYPE (decl),
10277 finish_decl (decl, init, NULL_TREE);
10282 /* A DECL_EXPR can also be used as an expression, in the condition
10283 clause of an if/for/while construct. */
10288 stmt = begin_for_stmt ();
10289 RECUR (FOR_INIT_STMT (t));
10290 finish_for_init_stmt (stmt);
10291 tmp = RECUR (FOR_COND (t));
10292 finish_for_cond (tmp, stmt);
10293 tmp = RECUR (FOR_EXPR (t));
10294 finish_for_expr (tmp, stmt);
10295 RECUR (FOR_BODY (t));
10296 finish_for_stmt (stmt);
10300 stmt = begin_while_stmt ();
10301 tmp = RECUR (WHILE_COND (t));
10302 finish_while_stmt_cond (tmp, stmt);
10303 RECUR (WHILE_BODY (t));
10304 finish_while_stmt (stmt);
10308 stmt = begin_do_stmt ();
10309 RECUR (DO_BODY (t));
10310 finish_do_body (stmt);
10311 tmp = RECUR (DO_COND (t));
10312 finish_do_stmt (tmp, stmt);
10316 stmt = begin_if_stmt ();
10317 tmp = RECUR (IF_COND (t));
10318 finish_if_stmt_cond (tmp, stmt);
10319 RECUR (THEN_CLAUSE (t));
10320 finish_then_clause (stmt);
10322 if (ELSE_CLAUSE (t))
10324 begin_else_clause (stmt);
10325 RECUR (ELSE_CLAUSE (t));
10326 finish_else_clause (stmt);
10329 finish_if_stmt (stmt);
10333 if (BIND_EXPR_BODY_BLOCK (t))
10334 stmt = begin_function_body ();
10336 stmt = begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t)
10337 ? BCS_TRY_BLOCK : 0);
10339 RECUR (BIND_EXPR_BODY (t));
10341 if (BIND_EXPR_BODY_BLOCK (t))
10342 finish_function_body (stmt);
10344 finish_compound_stmt (stmt);
10348 finish_break_stmt ();
10351 case CONTINUE_STMT:
10352 finish_continue_stmt ();
10356 stmt = begin_switch_stmt ();
10357 tmp = RECUR (SWITCH_STMT_COND (t));
10358 finish_switch_cond (tmp, stmt);
10359 RECUR (SWITCH_STMT_BODY (t));
10360 finish_switch_stmt (stmt);
10363 case CASE_LABEL_EXPR:
10364 finish_case_label (RECUR (CASE_LOW (t)),
10365 RECUR (CASE_HIGH (t)));
10369 finish_label_stmt (DECL_NAME (LABEL_EXPR_LABEL (t)));
10373 tmp = GOTO_DESTINATION (t);
10374 if (TREE_CODE (tmp) != LABEL_DECL)
10375 /* Computed goto's must be tsubst'd into. On the other hand,
10376 non-computed gotos must not be; the identifier in question
10377 will have no binding. */
10380 tmp = DECL_NAME (tmp);
10381 finish_goto_stmt (tmp);
10385 tmp = finish_asm_stmt
10386 (ASM_VOLATILE_P (t),
10387 RECUR (ASM_STRING (t)),
10388 tsubst_copy_asm_operands (ASM_OUTPUTS (t), args, complain, in_decl),
10389 tsubst_copy_asm_operands (ASM_INPUTS (t), args, complain, in_decl),
10390 tsubst_copy_asm_operands (ASM_CLOBBERS (t), args, complain, in_decl));
10392 tree asm_expr = tmp;
10393 if (TREE_CODE (asm_expr) == CLEANUP_POINT_EXPR)
10394 asm_expr = TREE_OPERAND (asm_expr, 0);
10395 ASM_INPUT_P (asm_expr) = ASM_INPUT_P (t);
10402 stmt = begin_try_block ();
10403 RECUR (TRY_STMTS (t));
10404 finish_cleanup_try_block (stmt);
10405 finish_cleanup (RECUR (TRY_HANDLERS (t)), stmt);
10409 tree compound_stmt = NULL_TREE;
10411 if (FN_TRY_BLOCK_P (t))
10412 stmt = begin_function_try_block (&compound_stmt);
10414 stmt = begin_try_block ();
10416 RECUR (TRY_STMTS (t));
10418 if (FN_TRY_BLOCK_P (t))
10419 finish_function_try_block (stmt);
10421 finish_try_block (stmt);
10423 RECUR (TRY_HANDLERS (t));
10424 if (FN_TRY_BLOCK_P (t))
10425 finish_function_handler_sequence (stmt, compound_stmt);
10427 finish_handler_sequence (stmt);
10433 tree decl = HANDLER_PARMS (t);
10437 decl = tsubst (decl, args, complain, in_decl);
10438 /* Prevent instantiate_decl from trying to instantiate
10439 this variable. We've already done all that needs to be
10441 if (decl != error_mark_node)
10442 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
10444 stmt = begin_handler ();
10445 finish_handler_parms (decl, stmt);
10446 RECUR (HANDLER_BODY (t));
10447 finish_handler (stmt);
10452 tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
10455 case STATIC_ASSERT:
10458 tsubst_expr (STATIC_ASSERT_CONDITION (t),
10461 /*integral_constant_expression_p=*/true);
10462 finish_static_assert (condition,
10463 STATIC_ASSERT_MESSAGE (t),
10464 STATIC_ASSERT_SOURCE_LOCATION (t),
10465 /*member_p=*/false);
10470 tmp = tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t),
10471 args, complain, in_decl);
10472 stmt = begin_omp_parallel ();
10473 RECUR (OMP_PARALLEL_BODY (t));
10474 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp, stmt))
10475 = OMP_PARALLEL_COMBINED (t);
10480 tree clauses, decl, init, cond, incr, body, pre_body;
10482 clauses = tsubst_omp_clauses (OMP_FOR_CLAUSES (t),
10483 args, complain, in_decl);
10484 init = OMP_FOR_INIT (t);
10485 gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
10486 decl = RECUR (TREE_OPERAND (init, 0));
10487 init = RECUR (TREE_OPERAND (init, 1));
10488 cond = RECUR (OMP_FOR_COND (t));
10489 incr = RECUR (OMP_FOR_INCR (t));
10491 stmt = begin_omp_structured_block ();
10493 pre_body = push_stmt_list ();
10494 RECUR (OMP_FOR_PRE_BODY (t));
10495 pre_body = pop_stmt_list (pre_body);
10497 body = push_stmt_list ();
10498 RECUR (OMP_FOR_BODY (t));
10499 body = pop_stmt_list (body);
10501 t = finish_omp_for (EXPR_LOCATION (t), decl, init, cond, incr, body,
10504 OMP_FOR_CLAUSES (t) = clauses;
10506 add_stmt (finish_omp_structured_block (stmt));
10512 tmp = tsubst_omp_clauses (OMP_CLAUSES (t), args, complain, in_decl);
10513 stmt = push_stmt_list ();
10514 RECUR (OMP_BODY (t));
10515 stmt = pop_stmt_list (stmt);
10518 OMP_BODY (t) = stmt;
10519 OMP_CLAUSES (t) = tmp;
10527 stmt = push_stmt_list ();
10528 RECUR (OMP_BODY (t));
10529 stmt = pop_stmt_list (stmt);
10532 OMP_BODY (t) = stmt;
10537 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t));
10539 tree op1 = TREE_OPERAND (t, 1);
10540 tree lhs = RECUR (TREE_OPERAND (op1, 0));
10541 tree rhs = RECUR (TREE_OPERAND (op1, 1));
10542 finish_omp_atomic (TREE_CODE (op1), lhs, rhs);
10546 case EXPR_PACK_EXPANSION:
10547 error ("invalid use of pack expansion expression");
10548 return error_mark_node;
10550 case NONTYPE_ARGUMENT_PACK:
10551 error ("use %<...%> to expand argument pack");
10552 return error_mark_node;
10555 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t)));
10557 return tsubst_copy_and_build (t, args, complain, in_decl,
10558 /*function_p=*/false,
10559 integral_constant_expression_p);
10566 /* T is a postfix-expression that is not being used in a function
10567 call. Return the substituted version of T. */
10570 tsubst_non_call_postfix_expression (tree t, tree args,
10571 tsubst_flags_t complain,
10574 if (TREE_CODE (t) == SCOPE_REF)
10575 t = tsubst_qualified_id (t, args, complain, in_decl,
10576 /*done=*/false, /*address_p=*/false);
10578 t = tsubst_copy_and_build (t, args, complain, in_decl,
10579 /*function_p=*/false,
10580 /*integral_constant_expression_p=*/false);
10585 /* Like tsubst but deals with expressions and performs semantic
10586 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
10589 tsubst_copy_and_build (tree t,
10591 tsubst_flags_t complain,
10594 bool integral_constant_expression_p)
10596 #define RECUR(NODE) \
10597 tsubst_copy_and_build (NODE, args, complain, in_decl, \
10598 /*function_p=*/false, \
10599 integral_constant_expression_p)
10603 if (t == NULL_TREE || t == error_mark_node)
10606 switch (TREE_CODE (t))
10610 /* Fall through. */
10611 case IDENTIFIER_NODE:
10615 bool non_integral_constant_expression_p;
10616 const char *error_msg;
10618 if (IDENTIFIER_TYPENAME_P (t))
10620 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10621 t = mangle_conv_op_name_for_type (new_type);
10624 /* Look up the name. */
10625 decl = lookup_name (t);
10627 /* By convention, expressions use ERROR_MARK_NODE to indicate
10628 failure, not NULL_TREE. */
10629 if (decl == NULL_TREE)
10630 decl = error_mark_node;
10632 decl = finish_id_expression (t, decl, NULL_TREE,
10634 integral_constant_expression_p,
10635 /*allow_non_integral_constant_expression_p=*/false,
10636 &non_integral_constant_expression_p,
10637 /*template_p=*/false,
10639 /*address_p=*/false,
10640 /*template_arg_p=*/false,
10644 if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE)
10645 decl = unqualified_name_lookup_error (decl);
10649 case TEMPLATE_ID_EXPR:
10652 tree template = RECUR (TREE_OPERAND (t, 0));
10653 tree targs = TREE_OPERAND (t, 1);
10656 targs = tsubst_template_args (targs, args, complain, in_decl);
10658 if (TREE_CODE (template) == COMPONENT_REF)
10660 object = TREE_OPERAND (template, 0);
10661 template = TREE_OPERAND (template, 1);
10664 object = NULL_TREE;
10665 template = lookup_template_function (template, targs);
10668 return build3 (COMPONENT_REF, TREE_TYPE (template),
10669 object, template, NULL_TREE);
10671 return baselink_for_fns (template);
10676 tree r = RECUR (TREE_OPERAND (t, 0));
10678 if (REFERENCE_REF_P (t))
10680 /* A type conversion to reference type will be enclosed in
10681 such an indirect ref, but the substitution of the cast
10682 will have also added such an indirect ref. */
10683 if (TREE_CODE (TREE_TYPE (r)) == REFERENCE_TYPE)
10684 r = convert_from_reference (r);
10687 r = build_x_indirect_ref (r, "unary *");
10693 (tsubst (TREE_TYPE (t), args, complain, in_decl),
10694 RECUR (TREE_OPERAND (t, 0)));
10697 case REINTERPRET_CAST_EXPR:
10698 case CONST_CAST_EXPR:
10699 case DYNAMIC_CAST_EXPR:
10700 case STATIC_CAST_EXPR:
10705 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10706 if (integral_constant_expression_p
10707 && !cast_valid_in_integral_constant_expression_p (type))
10709 error ("a cast to a type other than an integral or "
10710 "enumeration type cannot appear in a constant-expression");
10711 return error_mark_node;
10714 op = RECUR (TREE_OPERAND (t, 0));
10716 switch (TREE_CODE (t))
10719 return build_functional_cast (type, op);
10720 case REINTERPRET_CAST_EXPR:
10721 return build_reinterpret_cast (type, op);
10722 case CONST_CAST_EXPR:
10723 return build_const_cast (type, op);
10724 case DYNAMIC_CAST_EXPR:
10725 return build_dynamic_cast (type, op);
10726 case STATIC_CAST_EXPR:
10727 return build_static_cast (type, op);
10729 gcc_unreachable ();
10733 case POSTDECREMENT_EXPR:
10734 case POSTINCREMENT_EXPR:
10735 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
10736 args, complain, in_decl);
10737 return build_x_unary_op (TREE_CODE (t), op1);
10739 case PREDECREMENT_EXPR:
10740 case PREINCREMENT_EXPR:
10744 case TRUTH_NOT_EXPR:
10745 case UNARY_PLUS_EXPR: /* Unary + */
10746 case REALPART_EXPR:
10747 case IMAGPART_EXPR:
10748 return build_x_unary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0)));
10751 op1 = TREE_OPERAND (t, 0);
10752 if (TREE_CODE (op1) == SCOPE_REF)
10753 op1 = tsubst_qualified_id (op1, args, complain, in_decl,
10754 /*done=*/true, /*address_p=*/true);
10756 op1 = tsubst_non_call_postfix_expression (op1, args, complain,
10758 if (TREE_CODE (op1) == LABEL_DECL)
10759 return finish_label_address_expr (DECL_NAME (op1));
10760 return build_x_unary_op (ADDR_EXPR, op1);
10765 case TRUNC_DIV_EXPR:
10766 case CEIL_DIV_EXPR:
10767 case FLOOR_DIV_EXPR:
10768 case ROUND_DIV_EXPR:
10769 case EXACT_DIV_EXPR:
10773 case TRUNC_MOD_EXPR:
10774 case FLOOR_MOD_EXPR:
10775 case TRUTH_ANDIF_EXPR:
10776 case TRUTH_ORIF_EXPR:
10777 case TRUTH_AND_EXPR:
10778 case TRUTH_OR_EXPR:
10793 return build_x_binary_op
10795 RECUR (TREE_OPERAND (t, 0)),
10796 (TREE_NO_WARNING (TREE_OPERAND (t, 0))
10798 : TREE_CODE (TREE_OPERAND (t, 0))),
10799 RECUR (TREE_OPERAND (t, 1)),
10800 (TREE_NO_WARNING (TREE_OPERAND (t, 1))
10802 : TREE_CODE (TREE_OPERAND (t, 1))),
10803 /*overloaded_p=*/NULL);
10806 return tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
10807 /*address_p=*/false);
10809 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
10810 args, complain, in_decl);
10811 return build_x_binary_op (ARRAY_REF, op1,
10812 (TREE_NO_WARNING (TREE_OPERAND (t, 0))
10814 : TREE_CODE (TREE_OPERAND (t, 0))),
10815 RECUR (TREE_OPERAND (t, 1)),
10816 (TREE_NO_WARNING (TREE_OPERAND (t, 1))
10818 : TREE_CODE (TREE_OPERAND (t, 1))),
10819 /*overloaded_p=*/NULL);
10822 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
10824 /* We only want to compute the number of arguments. */
10825 tree expanded = tsubst_pack_expansion (TREE_OPERAND (t, 0), args,
10826 complain, in_decl);
10827 if (expanded == error_mark_node)
10828 return error_mark_node;
10829 return build_int_cst (size_type_node, TREE_VEC_LENGTH (expanded));
10834 op1 = TREE_OPERAND (t, 0);
10837 /* When there are no ARGS, we are trying to evaluate a
10838 non-dependent expression from the parser. Trying to do
10839 the substitutions may not work. */
10841 op1 = TREE_TYPE (op1);
10846 op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
10847 /*function_p=*/false,
10848 /*integral_constant_expression_p=*/false);
10852 return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t), true);
10854 return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t));
10858 tree r = build_x_modify_expr
10859 (RECUR (TREE_OPERAND (t, 0)),
10860 TREE_CODE (TREE_OPERAND (t, 1)),
10861 RECUR (TREE_OPERAND (t, 2)));
10862 /* TREE_NO_WARNING must be set if either the expression was
10863 parenthesized or it uses an operator such as >>= rather
10864 than plain assignment. In the former case, it was already
10865 set and must be copied. In the latter case,
10866 build_x_modify_expr sets it and it must not be reset
10868 if (TREE_NO_WARNING (t))
10869 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
10874 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
10875 args, complain, in_decl);
10876 /* Remember that there was a reference to this entity. */
10879 return build_x_arrow (op1);
10883 tree init = RECUR (TREE_OPERAND (t, 3));
10885 if (TREE_OPERAND (t, 3) && !init)
10886 /* If there was an initializer in the the original tree, but
10887 it instantiated to an empty list, then we should pass on
10888 VOID_ZERO_NODE to tell build_new that it was an empty
10889 initializer () rather than no initializer. This can only
10890 happen when the initializer is a pack expansion whose
10891 parameter packs are of length zero. */
10892 init = void_zero_node;
10895 (RECUR (TREE_OPERAND (t, 0)),
10896 RECUR (TREE_OPERAND (t, 1)),
10897 RECUR (TREE_OPERAND (t, 2)),
10899 NEW_EXPR_USE_GLOBAL (t));
10903 return delete_sanity
10904 (RECUR (TREE_OPERAND (t, 0)),
10905 RECUR (TREE_OPERAND (t, 1)),
10906 DELETE_EXPR_USE_VEC (t),
10907 DELETE_EXPR_USE_GLOBAL (t));
10909 case COMPOUND_EXPR:
10910 return build_x_compound_expr (RECUR (TREE_OPERAND (t, 0)),
10911 RECUR (TREE_OPERAND (t, 1)));
10920 function = CALL_EXPR_FN (t);
10921 /* When we parsed the expression, we determined whether or
10922 not Koenig lookup should be performed. */
10923 koenig_p = KOENIG_LOOKUP_P (t);
10924 if (TREE_CODE (function) == SCOPE_REF)
10926 qualified_p = true;
10927 function = tsubst_qualified_id (function, args, complain, in_decl,
10929 /*address_p=*/false);
10933 if (TREE_CODE (function) == COMPONENT_REF)
10935 tree op = TREE_OPERAND (function, 1);
10937 qualified_p = (TREE_CODE (op) == SCOPE_REF
10938 || (BASELINK_P (op)
10939 && BASELINK_QUALIFIED_P (op)));
10942 qualified_p = false;
10944 function = tsubst_copy_and_build (function, args, complain,
10947 integral_constant_expression_p);
10949 if (BASELINK_P (function))
10950 qualified_p = true;
10953 /* FIXME: Rewrite this so as not to construct an arglist. */
10954 call_args = RECUR (CALL_EXPR_ARGS (t));
10956 /* We do not perform argument-dependent lookup if normal
10957 lookup finds a non-function, in accordance with the
10958 expected resolution of DR 218. */
10960 && ((is_overloaded_fn (function)
10961 /* If lookup found a member function, the Koenig lookup is
10962 not appropriate, even if an unqualified-name was used
10963 to denote the function. */
10964 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function)))
10965 || TREE_CODE (function) == IDENTIFIER_NODE))
10966 function = perform_koenig_lookup (function, call_args);
10968 if (TREE_CODE (function) == IDENTIFIER_NODE)
10970 unqualified_name_lookup_error (function);
10971 return error_mark_node;
10974 /* Remember that there was a reference to this entity. */
10975 if (DECL_P (function))
10976 mark_used (function);
10978 if (TREE_CODE (function) == OFFSET_REF)
10979 return build_offset_ref_call_from_tree (function, call_args);
10980 if (TREE_CODE (function) == COMPONENT_REF)
10982 if (!BASELINK_P (TREE_OPERAND (function, 1)))
10983 return finish_call_expr (function, call_args,
10984 /*disallow_virtual=*/false,
10985 /*koenig_p=*/false);
10987 return (build_new_method_call
10988 (TREE_OPERAND (function, 0),
10989 TREE_OPERAND (function, 1),
10990 call_args, NULL_TREE,
10991 qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL,
10994 return finish_call_expr (function, call_args,
10995 /*disallow_virtual=*/qualified_p,
11000 return build_x_conditional_expr
11001 (RECUR (TREE_OPERAND (t, 0)),
11002 RECUR (TREE_OPERAND (t, 1)),
11003 RECUR (TREE_OPERAND (t, 2)));
11005 case PSEUDO_DTOR_EXPR:
11006 return finish_pseudo_destructor_expr
11007 (RECUR (TREE_OPERAND (t, 0)),
11008 RECUR (TREE_OPERAND (t, 1)),
11009 RECUR (TREE_OPERAND (t, 2)));
11013 tree purpose, value, chain;
11015 if (t == void_list_node)
11018 if ((TREE_PURPOSE (t) && PACK_EXPANSION_P (TREE_PURPOSE (t)))
11019 || (TREE_VALUE (t) && PACK_EXPANSION_P (TREE_VALUE (t))))
11021 /* We have pack expansions, so expand those and
11022 create a new list out of it. */
11023 tree purposevec = NULL_TREE;
11024 tree valuevec = NULL_TREE;
11028 /* Expand the argument expressions. */
11029 if (TREE_PURPOSE (t))
11030 purposevec = tsubst_pack_expansion (TREE_PURPOSE (t), args,
11031 complain, in_decl);
11032 if (TREE_VALUE (t))
11033 valuevec = tsubst_pack_expansion (TREE_VALUE (t), args,
11034 complain, in_decl);
11036 /* Build the rest of the list. */
11037 chain = TREE_CHAIN (t);
11038 if (chain && chain != void_type_node)
11039 chain = RECUR (chain);
11041 /* Determine the number of arguments. */
11042 if (purposevec && TREE_CODE (purposevec) == TREE_VEC)
11044 len = TREE_VEC_LENGTH (purposevec);
11045 gcc_assert (!valuevec || len == TREE_VEC_LENGTH (valuevec));
11047 else if (TREE_CODE (valuevec) == TREE_VEC)
11048 len = TREE_VEC_LENGTH (valuevec);
11051 /* Since we only performed a partial substitution into
11052 the argument pack, we only return a single list
11054 if (purposevec == TREE_PURPOSE (t)
11055 && valuevec == TREE_VALUE (t)
11056 && chain == TREE_CHAIN (t))
11059 return tree_cons (purposevec, valuevec, chain);
11062 /* Convert the argument vectors into a TREE_LIST */
11066 /* Grab the Ith values. */
11068 purpose = purposevec ? TREE_VEC_ELT (purposevec, i)
11071 = valuevec ? convert_from_reference (TREE_VEC_ELT (valuevec, i))
11074 /* Build the list (backwards). */
11075 chain = tree_cons (purpose, value, chain);
11081 purpose = TREE_PURPOSE (t);
11083 purpose = RECUR (purpose);
11084 value = TREE_VALUE (t);
11086 value = RECUR (value);
11087 chain = TREE_CHAIN (t);
11088 if (chain && chain != void_type_node)
11089 chain = RECUR (chain);
11090 if (purpose == TREE_PURPOSE (t)
11091 && value == TREE_VALUE (t)
11092 && chain == TREE_CHAIN (t))
11094 return tree_cons (purpose, value, chain);
11097 case COMPONENT_REF:
11103 object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
11104 args, complain, in_decl);
11105 /* Remember that there was a reference to this entity. */
11106 if (DECL_P (object))
11107 mark_used (object);
11108 object_type = TREE_TYPE (object);
11110 member = TREE_OPERAND (t, 1);
11111 if (BASELINK_P (member))
11112 member = tsubst_baselink (member,
11113 non_reference (TREE_TYPE (object)),
11114 args, complain, in_decl);
11116 member = tsubst_copy (member, args, complain, in_decl);
11117 if (member == error_mark_node)
11118 return error_mark_node;
11120 if (object_type && !CLASS_TYPE_P (object_type))
11122 if (SCALAR_TYPE_P (object_type))
11124 tree s = NULL_TREE;
11125 tree dtor = member;
11127 if (TREE_CODE (dtor) == SCOPE_REF)
11129 s = TREE_OPERAND (dtor, 0);
11130 dtor = TREE_OPERAND (dtor, 1);
11132 if (TREE_CODE (dtor) == BIT_NOT_EXPR)
11134 dtor = TREE_OPERAND (dtor, 0);
11136 return finish_pseudo_destructor_expr (object, s, dtor);
11140 else if (TREE_CODE (member) == SCOPE_REF
11141 && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
11146 /* Lookup the template functions now that we know what the
11148 tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
11149 args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
11150 member = lookup_qualified_name (TREE_OPERAND (member, 0), tmpl,
11151 /*is_type_p=*/false,
11152 /*complain=*/false);
11153 if (BASELINK_P (member))
11155 BASELINK_FUNCTIONS (member)
11156 = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
11158 member = (adjust_result_of_qualified_name_lookup
11159 (member, BINFO_TYPE (BASELINK_BINFO (member)),
11164 qualified_name_lookup_error (object_type, tmpl, member);
11165 return error_mark_node;
11168 else if (TREE_CODE (member) == SCOPE_REF
11169 && !CLASS_TYPE_P (TREE_OPERAND (member, 0))
11170 && TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL)
11172 if (complain & tf_error)
11174 if (TYPE_P (TREE_OPERAND (member, 0)))
11175 error ("%qT is not a class or namespace",
11176 TREE_OPERAND (member, 0));
11178 error ("%qD is not a class or namespace",
11179 TREE_OPERAND (member, 0));
11181 return error_mark_node;
11183 else if (TREE_CODE (member) == FIELD_DECL)
11184 return finish_non_static_data_member (member, object, NULL_TREE);
11186 return finish_class_member_access_expr (object, member,
11187 /*template_p=*/false);
11192 (RECUR (TREE_OPERAND (t, 0)));
11196 VEC(constructor_elt,gc) *n;
11197 constructor_elt *ce;
11198 unsigned HOST_WIDE_INT idx;
11199 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
11200 bool process_index_p;
11202 bool need_copy_p = false;
11204 if (type == error_mark_node)
11205 return error_mark_node;
11207 /* digest_init will do the wrong thing if we let it. */
11208 if (type && TYPE_PTRMEMFUNC_P (type))
11211 /* We do not want to process the index of aggregate
11212 initializers as they are identifier nodes which will be
11213 looked up by digest_init. */
11214 process_index_p = !(type && MAYBE_CLASS_TYPE_P (type));
11216 n = VEC_copy (constructor_elt, gc, CONSTRUCTOR_ELTS (t));
11217 newlen = VEC_length (constructor_elt, n);
11218 for (idx = 0; VEC_iterate (constructor_elt, n, idx, ce); idx++)
11220 if (ce->index && process_index_p)
11221 ce->index = RECUR (ce->index);
11223 if (PACK_EXPANSION_P (ce->value))
11225 /* Substitute into the pack expansion. */
11226 ce->value = tsubst_pack_expansion (ce->value, args, complain,
11229 if (ce->value == error_mark_node)
11231 else if (TREE_VEC_LENGTH (ce->value) == 1)
11232 /* Just move the argument into place. */
11233 ce->value = TREE_VEC_ELT (ce->value, 0);
11236 /* Update the length of the final CONSTRUCTOR
11237 arguments vector, and note that we will need to
11239 newlen = newlen + TREE_VEC_LENGTH (ce->value) - 1;
11240 need_copy_p = true;
11244 ce->value = RECUR (ce->value);
11249 VEC(constructor_elt,gc) *old_n = n;
11251 n = VEC_alloc (constructor_elt, gc, newlen);
11252 for (idx = 0; VEC_iterate (constructor_elt, old_n, idx, ce);
11255 if (TREE_CODE (ce->value) == TREE_VEC)
11257 int i, len = TREE_VEC_LENGTH (ce->value);
11258 for (i = 0; i < len; ++i)
11259 CONSTRUCTOR_APPEND_ELT (n, 0,
11260 TREE_VEC_ELT (ce->value, i));
11263 CONSTRUCTOR_APPEND_ELT (n, 0, ce->value);
11267 if (TREE_HAS_CONSTRUCTOR (t))
11268 return finish_compound_literal (type, n);
11270 return build_constructor (NULL_TREE, n);
11275 tree operand_0 = RECUR (TREE_OPERAND (t, 0));
11276 if (TYPE_P (operand_0))
11277 return get_typeid (operand_0);
11278 return build_typeid (operand_0);
11288 tree r = tsubst_copy (t, args, complain, in_decl);
11290 if (TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
11291 /* If the original type was a reference, we'll be wrapped in
11292 the appropriate INDIRECT_REF. */
11293 r = convert_from_reference (r);
11298 return build_x_va_arg (RECUR (TREE_OPERAND (t, 0)),
11299 tsubst_copy (TREE_TYPE (t), args, complain,
11302 case OFFSETOF_EXPR:
11303 return finish_offsetof (RECUR (TREE_OPERAND (t, 0)));
11307 tree type1 = tsubst_copy (TRAIT_EXPR_TYPE1 (t), args,
11308 complain, in_decl);
11310 tree type2 = TRAIT_EXPR_TYPE2 (t);
11312 type2 = tsubst_copy (type2, args, complain, in_decl);
11314 return finish_trait_expr (TRAIT_EXPR_KIND (t), type1, type2);
11319 tree old_stmt_expr = cur_stmt_expr;
11320 tree stmt_expr = begin_stmt_expr ();
11322 cur_stmt_expr = stmt_expr;
11323 tsubst_expr (STMT_EXPR_STMT (t), args, complain, in_decl,
11324 integral_constant_expression_p);
11325 stmt_expr = finish_stmt_expr (stmt_expr, false);
11326 cur_stmt_expr = old_stmt_expr;
11332 t = tsubst_copy (t, args, complain, in_decl);
11333 /* As in finish_id_expression, we resolve enumeration constants
11334 to their underlying values. */
11335 if (TREE_CODE (t) == CONST_DECL)
11337 used_types_insert (TREE_TYPE (t));
11338 return DECL_INITIAL (t);
11343 /* Handle Objective-C++ constructs, if appropriate. */
11346 = objcp_tsubst_copy_and_build (t, args, complain,
11347 in_decl, /*function_p=*/false);
11351 return tsubst_copy (t, args, complain, in_decl);
11357 /* Verify that the instantiated ARGS are valid. For type arguments,
11358 make sure that the type's linkage is ok. For non-type arguments,
11359 make sure they are constants if they are integral or enumerations.
11360 Emit an error under control of COMPLAIN, and return TRUE on error. */
11363 check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain)
11365 int ix, len = DECL_NTPARMS (tmpl);
11366 bool result = false;
11368 for (ix = 0; ix != len; ix++)
11370 tree t = TREE_VEC_ELT (args, ix);
11374 /* [basic.link]: A name with no linkage (notably, the name
11375 of a class or enumeration declared in a local scope)
11376 shall not be used to declare an entity with linkage.
11377 This implies that names with no linkage cannot be used as
11378 template arguments. */
11379 tree nt = no_linkage_check (t, /*relaxed_p=*/false);
11383 /* DR 488 makes use of a type with no linkage cause
11384 type deduction to fail. */
11385 if (complain & tf_error)
11387 if (TYPE_ANONYMOUS_P (nt))
11388 error ("%qT is/uses anonymous type", t);
11390 error ("template argument for %qD uses local type %qT",
11395 /* In order to avoid all sorts of complications, we do not
11396 allow variably-modified types as template arguments. */
11397 else if (variably_modified_type_p (t, NULL_TREE))
11399 if (complain & tf_error)
11400 error ("%qT is a variably modified type", t);
11404 /* A non-type argument of integral or enumerated type must be a
11406 else if (TREE_TYPE (t)
11407 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t))
11408 && !TREE_CONSTANT (t))
11410 if (complain & tf_error)
11411 error ("integral expression %qE is not constant", t);
11415 if (result && (complain & tf_error))
11416 error (" trying to instantiate %qD", tmpl);
11420 /* Instantiate the indicated variable or function template TMPL with
11421 the template arguments in TARG_PTR. */
11424 instantiate_template (tree tmpl, tree targ_ptr, tsubst_flags_t complain)
11429 HOST_WIDE_INT saved_processing_template_decl;
11431 if (tmpl == error_mark_node)
11432 return error_mark_node;
11434 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
11436 /* If this function is a clone, handle it specially. */
11437 if (DECL_CLONED_FUNCTION_P (tmpl))
11442 spec = instantiate_template (DECL_CLONED_FUNCTION (tmpl), targ_ptr,
11444 if (spec == error_mark_node)
11445 return error_mark_node;
11447 /* Look for the clone. */
11448 FOR_EACH_CLONE (clone, spec)
11449 if (DECL_NAME (clone) == DECL_NAME (tmpl))
11451 /* We should always have found the clone by now. */
11452 gcc_unreachable ();
11456 /* Check to see if we already have this specialization. */
11457 spec = retrieve_specialization (tmpl, targ_ptr,
11458 /*class_specializations_p=*/false);
11459 if (spec != NULL_TREE)
11462 gen_tmpl = most_general_template (tmpl);
11463 if (tmpl != gen_tmpl)
11465 /* The TMPL is a partial instantiation. To get a full set of
11466 arguments we must add the arguments used to perform the
11467 partial instantiation. */
11468 targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl),
11471 /* Check to see if we already have this specialization. */
11472 spec = retrieve_specialization (gen_tmpl, targ_ptr,
11473 /*class_specializations_p=*/false);
11474 if (spec != NULL_TREE)
11478 if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr),
11480 return error_mark_node;
11482 /* We are building a FUNCTION_DECL, during which the access of its
11483 parameters and return types have to be checked. However this
11484 FUNCTION_DECL which is the desired context for access checking
11485 is not built yet. We solve this chicken-and-egg problem by
11486 deferring all checks until we have the FUNCTION_DECL. */
11487 push_deferring_access_checks (dk_deferred);
11489 /* Although PROCESSING_TEMPLATE_DECL may be true at this point
11490 (because, for example, we have encountered a non-dependent
11491 function call in the body of a template function and must now
11492 determine which of several overloaded functions will be called),
11493 within the instantiation itself we are not processing a
11495 saved_processing_template_decl = processing_template_decl;
11496 processing_template_decl = 0;
11497 /* Substitute template parameters to obtain the specialization. */
11498 fndecl = tsubst (DECL_TEMPLATE_RESULT (gen_tmpl),
11499 targ_ptr, complain, gen_tmpl);
11500 processing_template_decl = saved_processing_template_decl;
11501 if (fndecl == error_mark_node)
11502 return error_mark_node;
11504 /* Now we know the specialization, compute access previously
11506 push_access_scope (fndecl);
11507 perform_deferred_access_checks ();
11508 pop_access_scope (fndecl);
11509 pop_deferring_access_checks ();
11511 /* The DECL_TI_TEMPLATE should always be the immediate parent
11512 template, not the most general template. */
11513 DECL_TI_TEMPLATE (fndecl) = tmpl;
11515 /* If we've just instantiated the main entry point for a function,
11516 instantiate all the alternate entry points as well. We do this
11517 by cloning the instantiation of the main entry point, not by
11518 instantiating the template clones. */
11519 if (TREE_CHAIN (gen_tmpl) && DECL_CLONED_FUNCTION_P (TREE_CHAIN (gen_tmpl)))
11520 clone_function_decl (fndecl, /*update_method_vec_p=*/0);
11525 /* The FN is a TEMPLATE_DECL for a function. The ARGS are the
11526 arguments that are being used when calling it. TARGS is a vector
11527 into which the deduced template arguments are placed.
11529 Return zero for success, 2 for an incomplete match that doesn't resolve
11530 all the types, and 1 for complete failure. An error message will be
11531 printed only for an incomplete match.
11533 If FN is a conversion operator, or we are trying to produce a specific
11534 specialization, RETURN_TYPE is the return type desired.
11536 The EXPLICIT_TARGS are explicit template arguments provided via a
11539 The parameter STRICT is one of:
11542 We are deducing arguments for a function call, as in
11543 [temp.deduct.call].
11546 We are deducing arguments for a conversion function, as in
11547 [temp.deduct.conv].
11550 We are deducing arguments when doing an explicit instantiation
11551 as in [temp.explicit], when determining an explicit specialization
11552 as in [temp.expl.spec], or when taking the address of a function
11553 template, as in [temp.deduct.funcaddr]. */
11556 fn_type_unification (tree fn,
11557 tree explicit_targs,
11561 unification_kind_t strict,
11567 bool incomplete_argument_packs_p = false;
11569 gcc_assert (TREE_CODE (fn) == TEMPLATE_DECL);
11571 fntype = TREE_TYPE (fn);
11572 if (explicit_targs)
11576 The specified template arguments must match the template
11577 parameters in kind (i.e., type, nontype, template), and there
11578 must not be more arguments than there are parameters;
11579 otherwise type deduction fails.
11581 Nontype arguments must match the types of the corresponding
11582 nontype template parameters, or must be convertible to the
11583 types of the corresponding nontype parameters as specified in
11584 _temp.arg.nontype_, otherwise type deduction fails.
11586 All references in the function type of the function template
11587 to the corresponding template parameters are replaced by the
11588 specified template argument values. If a substitution in a
11589 template parameter or in the function type of the function
11590 template results in an invalid type, type deduction fails. */
11591 tree tparms = DECL_INNERMOST_TEMPLATE_PARMS (fn);
11592 int i, len = TREE_VEC_LENGTH (tparms);
11593 tree converted_args;
11594 bool incomplete = false;
11596 if (explicit_targs == error_mark_node)
11600 = (coerce_template_parms (tparms, explicit_targs, NULL_TREE, tf_none,
11601 /*require_all_args=*/false,
11602 /*use_default_args=*/false));
11603 if (converted_args == error_mark_node)
11606 /* Substitute the explicit args into the function type. This is
11607 necessary so that, for instance, explicitly declared function
11608 arguments can match null pointed constants. If we were given
11609 an incomplete set of explicit args, we must not do semantic
11610 processing during substitution as we could create partial
11612 for (i = 0; i < len; i++)
11614 tree parm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
11615 bool parameter_pack = false;
11617 /* Dig out the actual parm. */
11618 if (TREE_CODE (parm) == TYPE_DECL
11619 || TREE_CODE (parm) == TEMPLATE_DECL)
11621 parm = TREE_TYPE (parm);
11622 parameter_pack = TEMPLATE_TYPE_PARAMETER_PACK (parm);
11624 else if (TREE_CODE (parm) == PARM_DECL)
11626 parm = DECL_INITIAL (parm);
11627 parameter_pack = TEMPLATE_PARM_PARAMETER_PACK (parm);
11630 if (parameter_pack)
11634 template_parm_level_and_index (parm, &level, &idx);
11636 /* Mark the argument pack as "incomplete". We could
11637 still deduce more arguments during unification. */
11638 targ = TMPL_ARG (converted_args, level, idx);
11641 ARGUMENT_PACK_INCOMPLETE_P(targ) = 1;
11642 ARGUMENT_PACK_EXPLICIT_ARGS (targ)
11643 = ARGUMENT_PACK_ARGS (targ);
11646 /* We have some incomplete argument packs. */
11647 incomplete_argument_packs_p = true;
11651 if (incomplete_argument_packs_p)
11652 /* Any substitution is guaranteed to be incomplete if there
11653 are incomplete argument packs, because we can still deduce
11657 incomplete = NUM_TMPL_ARGS (explicit_targs) != NUM_TMPL_ARGS (targs);
11659 processing_template_decl += incomplete;
11660 fntype = tsubst (fntype, converted_args, tf_none, NULL_TREE);
11661 processing_template_decl -= incomplete;
11663 if (fntype == error_mark_node)
11666 /* Place the explicitly specified arguments in TARGS. */
11667 for (i = NUM_TMPL_ARGS (converted_args); i--;)
11668 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i);
11671 /* Never do unification on the 'this' parameter. */
11672 parms = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (fntype));
11676 parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms);
11677 args = tree_cons (NULL_TREE, return_type, args);
11680 /* We allow incomplete unification without an error message here
11681 because the standard doesn't seem to explicitly prohibit it. Our
11682 callers must be ready to deal with unification failures in any
11684 result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
11685 targs, parms, args, /*subr=*/0,
11688 if (result == 0 && incomplete_argument_packs_p)
11690 int i, len = NUM_TMPL_ARGS (targs);
11692 /* Clear the "incomplete" flags on all argument packs. */
11693 for (i = 0; i < len; i++)
11695 tree arg = TREE_VEC_ELT (targs, i);
11696 if (ARGUMENT_PACK_P (arg))
11698 ARGUMENT_PACK_INCOMPLETE_P (arg) = 0;
11699 ARGUMENT_PACK_EXPLICIT_ARGS (arg) = NULL_TREE;
11704 /* Now that we have bindings for all of the template arguments,
11705 ensure that the arguments deduced for the template template
11706 parameters have compatible template parameter lists. We cannot
11707 check this property before we have deduced all template
11708 arguments, because the template parameter types of a template
11709 template parameter might depend on prior template parameters
11710 deduced after the template template parameter. The following
11711 ill-formed example illustrates this issue:
11713 template<typename T, template<T> class C> void f(C<5>, T);
11715 template<int N> struct X {};
11718 f(X<5>(), 5l); // error: template argument deduction fails
11721 The template parameter list of 'C' depends on the template type
11722 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
11723 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
11724 time that we deduce 'C'. */
11726 && !template_template_parm_bindings_ok_p
11727 (DECL_INNERMOST_TEMPLATE_PARMS (fn), targs))
11731 /* All is well so far. Now, check:
11735 When all template arguments have been deduced, all uses of
11736 template parameters in nondeduced contexts are replaced with
11737 the corresponding deduced argument values. If the
11738 substitution results in an invalid type, as described above,
11739 type deduction fails. */
11740 if (tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE)
11741 == error_mark_node)
11747 /* Adjust types before performing type deduction, as described in
11748 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
11749 sections are symmetric. PARM is the type of a function parameter
11750 or the return type of the conversion function. ARG is the type of
11751 the argument passed to the call, or the type of the value
11752 initialized with the result of the conversion function.
11753 ARG_EXPR is the original argument expression, which may be null. */
11756 maybe_adjust_types_for_deduction (unification_kind_t strict,
11770 /* Swap PARM and ARG throughout the remainder of this
11771 function; the handling is precisely symmetric since PARM
11772 will initialize ARG rather than vice versa. */
11780 /* There is nothing to do in this case. */
11784 gcc_unreachable ();
11787 if (TREE_CODE (*parm) != REFERENCE_TYPE)
11789 /* [temp.deduct.call]
11791 If P is not a reference type:
11793 --If A is an array type, the pointer type produced by the
11794 array-to-pointer standard conversion (_conv.array_) is
11795 used in place of A for type deduction; otherwise,
11797 --If A is a function type, the pointer type produced by
11798 the function-to-pointer standard conversion
11799 (_conv.func_) is used in place of A for type deduction;
11802 --If A is a cv-qualified type, the top level
11803 cv-qualifiers of A's type are ignored for type
11805 if (TREE_CODE (*arg) == ARRAY_TYPE)
11806 *arg = build_pointer_type (TREE_TYPE (*arg));
11807 else if (TREE_CODE (*arg) == FUNCTION_TYPE)
11808 *arg = build_pointer_type (*arg);
11810 *arg = TYPE_MAIN_VARIANT (*arg);
11813 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
11814 of the form T&&, where T is a template parameter, and the argument
11815 is an lvalue, T is deduced as A& */
11816 if (TREE_CODE (*parm) == REFERENCE_TYPE
11817 && TYPE_REF_IS_RVALUE (*parm)
11818 && TREE_CODE (TREE_TYPE (*parm)) == TEMPLATE_TYPE_PARM
11819 && cp_type_quals (TREE_TYPE (*parm)) == TYPE_UNQUALIFIED
11820 && arg_expr && real_lvalue_p (arg_expr))
11821 *arg = build_reference_type (*arg);
11823 /* [temp.deduct.call]
11825 If P is a cv-qualified type, the top level cv-qualifiers
11826 of P's type are ignored for type deduction. If P is a
11827 reference type, the type referred to by P is used for
11829 *parm = TYPE_MAIN_VARIANT (*parm);
11830 if (TREE_CODE (*parm) == REFERENCE_TYPE)
11832 *parm = TREE_TYPE (*parm);
11833 result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
11836 /* DR 322. For conversion deduction, remove a reference type on parm
11837 too (which has been swapped into ARG). */
11838 if (strict == DEDUCE_CONV && TREE_CODE (*arg) == REFERENCE_TYPE)
11839 *arg = TREE_TYPE (*arg);
11844 /* Most parms like fn_type_unification.
11846 If SUBR is 1, we're being called recursively (to unify the
11847 arguments of a function or method parameter of a function
11851 type_unification_real (tree tparms,
11856 unification_kind_t strict,
11859 tree parm, arg, arg_expr;
11861 int ntparms = TREE_VEC_LENGTH (tparms);
11863 int saw_undeduced = 0;
11866 gcc_assert (TREE_CODE (tparms) == TREE_VEC);
11867 gcc_assert (xparms == NULL_TREE || TREE_CODE (xparms) == TREE_LIST);
11868 gcc_assert (!xargs || TREE_CODE (xargs) == TREE_LIST);
11869 gcc_assert (ntparms > 0);
11874 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL | UNIFY_ALLOW_MORE_CV_QUAL
11875 | UNIFY_ALLOW_DERIVED);
11879 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
11883 sub_strict = UNIFY_ALLOW_NONE;
11887 gcc_unreachable ();
11894 while (parms && parms != void_list_node
11895 && args && args != void_list_node)
11897 if (TREE_CODE (TREE_VALUE (parms)) == TYPE_PACK_EXPANSION)
11900 parm = TREE_VALUE (parms);
11901 parms = TREE_CHAIN (parms);
11902 arg = TREE_VALUE (args);
11903 args = TREE_CHAIN (args);
11906 if (arg == error_mark_node)
11908 if (arg == unknown_type_node)
11909 /* We can't deduce anything from this, but we might get all the
11910 template args from other function args. */
11913 /* Conversions will be performed on a function argument that
11914 corresponds with a function parameter that contains only
11915 non-deducible template parameters and explicitly specified
11916 template parameters. */
11917 if (!uses_template_parms (parm))
11922 type = TREE_TYPE (arg);
11926 if (same_type_p (parm, type))
11928 if (strict != DEDUCE_EXACT
11929 && can_convert_arg (parm, type, TYPE_P (arg) ? NULL_TREE : arg,
11938 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
11939 if (type_unknown_p (arg))
11941 /* [temp.deduct.type]
11943 A template-argument can be deduced from a pointer to
11944 function or pointer to member function argument if
11945 the set of overloaded functions does not contain
11946 function templates and at most one of a set of
11947 overloaded functions provides a unique match. */
11948 if (resolve_overloaded_unification
11949 (tparms, targs, parm, arg, strict, sub_strict))
11955 arg = unlowered_expr_type (arg);
11956 if (arg == error_mark_node)
11961 int arg_strict = sub_strict;
11964 arg_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg,
11967 if (unify (tparms, targs, parm, arg, arg_strict))
11974 && parms != void_list_node
11975 && TREE_CODE (TREE_VALUE (parms)) == TYPE_PACK_EXPANSION)
11977 /* Unify the remaining arguments with the pack expansion type. */
11979 tree parmvec = make_tree_vec (1);
11983 /* Count the number of arguments that remain. */
11984 for (t = args; t && t != void_list_node; t = TREE_CHAIN (t))
11987 /* Allocate a TREE_VEC and copy in all of the arguments */
11988 argvec = make_tree_vec (len);
11989 for (i = 0; args && args != void_list_node; args = TREE_CHAIN (args))
11991 TREE_VEC_ELT (argvec, i) = TREE_VALUE (args);
11995 /* Copy the parameter into parmvec. */
11996 TREE_VEC_ELT (parmvec, 0) = TREE_VALUE (parms);
11997 if (unify_pack_expansion (tparms, targs, parmvec, argvec, strict,
11998 /*call_args_p=*/true, /*subr=*/subr))
12001 /* Advance to the end of the list of parameters. */
12002 parms = TREE_CHAIN (parms);
12005 /* Fail if we've reached the end of the parm list, and more args
12006 are present, and the parm list isn't variadic. */
12007 if (args && args != void_list_node && parms == void_list_node)
12009 /* Fail if parms are left and they don't have default values. */
12010 if (parms && parms != void_list_node
12011 && TREE_PURPOSE (parms) == NULL_TREE)
12015 for (i = 0; i < ntparms; i++)
12016 if (!TREE_VEC_ELT (targs, i))
12020 if (TREE_VEC_ELT (tparms, i) == error_mark_node)
12023 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
12025 /* If this is an undeduced nontype parameter that depends on
12026 a type parameter, try another pass; its type may have been
12027 deduced from a later argument than the one from which
12028 this parameter can be deduced. */
12029 if (TREE_CODE (tparm) == PARM_DECL
12030 && uses_template_parms (TREE_TYPE (tparm))
12031 && !saw_undeduced++)
12034 /* Core issue #226 (C++0x) [temp.deduct]:
12036 If a template argument has not been deduced, its
12037 default template argument, if any, is used.
12039 When we are in C++98 mode, TREE_PURPOSE will either
12040 be NULL_TREE or ERROR_MARK_NODE, so we do not need
12041 to explicitly check cxx_dialect here. */
12042 if (TREE_PURPOSE (TREE_VEC_ELT (tparms, i)))
12044 tree arg = tsubst (TREE_PURPOSE (TREE_VEC_ELT (tparms, i)),
12045 targs, tf_none, NULL_TREE);
12046 if (arg == error_mark_node)
12050 TREE_VEC_ELT (targs, i) = arg;
12055 /* If the type parameter is a parameter pack, then it will
12056 be deduced to an empty parameter pack. */
12057 if (template_parameter_pack_p (tparm))
12061 if (TREE_CODE (tparm) == TEMPLATE_PARM_INDEX)
12063 arg = make_node (NONTYPE_ARGUMENT_PACK);
12064 TREE_TYPE (arg) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm));
12065 TREE_CONSTANT (arg) = 1;
12068 arg = make_node (TYPE_ARGUMENT_PACK);
12070 SET_ARGUMENT_PACK_ARGS (arg, make_tree_vec (0));
12072 TREE_VEC_ELT (targs, i) = arg;
12082 /* Subroutine of type_unification_real. Args are like the variables
12083 at the call site. ARG is an overloaded function (or template-id);
12084 we try deducing template args from each of the overloads, and if
12085 only one succeeds, we go with that. Modifies TARGS and returns
12086 true on success. */
12089 resolve_overloaded_unification (tree tparms,
12093 unification_kind_t strict,
12096 tree tempargs = copy_node (targs);
12100 if (TREE_CODE (arg) == ADDR_EXPR)
12102 arg = TREE_OPERAND (arg, 0);
12108 if (TREE_CODE (arg) == COMPONENT_REF)
12109 /* Handle `&x' where `x' is some static or non-static member
12111 arg = TREE_OPERAND (arg, 1);
12113 if (TREE_CODE (arg) == OFFSET_REF)
12114 arg = TREE_OPERAND (arg, 1);
12116 /* Strip baselink information. */
12117 if (BASELINK_P (arg))
12118 arg = BASELINK_FUNCTIONS (arg);
12120 if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
12122 /* If we got some explicit template args, we need to plug them into
12123 the affected templates before we try to unify, in case the
12124 explicit args will completely resolve the templates in question. */
12126 tree expl_subargs = TREE_OPERAND (arg, 1);
12127 arg = TREE_OPERAND (arg, 0);
12129 for (; arg; arg = OVL_NEXT (arg))
12131 tree fn = OVL_CURRENT (arg);
12132 tree subargs, elem;
12134 if (TREE_CODE (fn) != TEMPLATE_DECL)
12137 ++processing_template_decl;
12138 subargs = get_bindings (fn, DECL_TEMPLATE_RESULT (fn),
12139 expl_subargs, /*check_ret=*/false);
12142 elem = tsubst (TREE_TYPE (fn), subargs, tf_none, NULL_TREE);
12143 good += try_one_overload (tparms, targs, tempargs, parm,
12144 elem, strict, sub_strict, addr_p);
12146 --processing_template_decl;
12149 else if (TREE_CODE (arg) != OVERLOAD
12150 && TREE_CODE (arg) != FUNCTION_DECL)
12151 /* If ARG is, for example, "(0, &f)" then its type will be unknown
12152 -- but the deduction does not succeed because the expression is
12153 not just the function on its own. */
12156 for (; arg; arg = OVL_NEXT (arg))
12157 good += try_one_overload (tparms, targs, tempargs, parm,
12158 TREE_TYPE (OVL_CURRENT (arg)),
12159 strict, sub_strict, addr_p);
12161 /* [temp.deduct.type] A template-argument can be deduced from a pointer
12162 to function or pointer to member function argument if the set of
12163 overloaded functions does not contain function templates and at most
12164 one of a set of overloaded functions provides a unique match.
12166 So if we found multiple possibilities, we return success but don't
12167 deduce anything. */
12171 int i = TREE_VEC_LENGTH (targs);
12173 if (TREE_VEC_ELT (tempargs, i))
12174 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i);
12182 /* Subroutine of resolve_overloaded_unification; does deduction for a single
12183 overload. Fills TARGS with any deduced arguments, or error_mark_node if
12184 different overloads deduce different arguments for a given parm.
12185 ADDR_P is true if the expression for which deduction is being
12186 performed was of the form "& fn" rather than simply "fn".
12188 Returns 1 on success. */
12191 try_one_overload (tree tparms,
12196 unification_kind_t strict,
12204 /* [temp.deduct.type] A template-argument can be deduced from a pointer
12205 to function or pointer to member function argument if the set of
12206 overloaded functions does not contain function templates and at most
12207 one of a set of overloaded functions provides a unique match.
12209 So if this is a template, just return success. */
12211 if (uses_template_parms (arg))
12214 if (TREE_CODE (arg) == METHOD_TYPE)
12215 arg = build_ptrmemfunc_type (build_pointer_type (arg));
12217 arg = build_pointer_type (arg);
12219 sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg, NULL);
12221 /* We don't copy orig_targs for this because if we have already deduced
12222 some template args from previous args, unify would complain when we
12223 try to deduce a template parameter for the same argument, even though
12224 there isn't really a conflict. */
12225 nargs = TREE_VEC_LENGTH (targs);
12226 tempargs = make_tree_vec (nargs);
12228 if (unify (tparms, tempargs, parm, arg, sub_strict) != 0)
12231 /* First make sure we didn't deduce anything that conflicts with
12232 explicitly specified args. */
12233 for (i = nargs; i--; )
12235 tree elt = TREE_VEC_ELT (tempargs, i);
12236 tree oldelt = TREE_VEC_ELT (orig_targs, i);
12240 else if (uses_template_parms (elt))
12241 /* Since we're unifying against ourselves, we will fill in
12242 template args used in the function parm list with our own
12243 template parms. Discard them. */
12244 TREE_VEC_ELT (tempargs, i) = NULL_TREE;
12245 else if (oldelt && !template_args_equal (oldelt, elt))
12249 for (i = nargs; i--; )
12251 tree elt = TREE_VEC_ELT (tempargs, i);
12254 TREE_VEC_ELT (targs, i) = elt;
12260 /* PARM is a template class (perhaps with unbound template
12261 parameters). ARG is a fully instantiated type. If ARG can be
12262 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
12263 TARGS are as for unify. */
12266 try_class_unification (tree tparms, tree targs, tree parm, tree arg)
12268 tree copy_of_targs;
12270 if (!CLASSTYPE_TEMPLATE_INFO (arg)
12271 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg))
12272 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm))))
12275 /* We need to make a new template argument vector for the call to
12276 unify. If we used TARGS, we'd clutter it up with the result of
12277 the attempted unification, even if this class didn't work out.
12278 We also don't want to commit ourselves to all the unifications
12279 we've already done, since unification is supposed to be done on
12280 an argument-by-argument basis. In other words, consider the
12281 following pathological case:
12283 template <int I, int J, int K>
12286 template <int I, int J>
12287 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
12289 template <int I, int J, int K>
12290 void f(S<I, J, K>, S<I, I, I>);
12299 Now, by the time we consider the unification involving `s2', we
12300 already know that we must have `f<0, 0, 0>'. But, even though
12301 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
12302 because there are two ways to unify base classes of S<0, 1, 2>
12303 with S<I, I, I>. If we kept the already deduced knowledge, we
12304 would reject the possibility I=1. */
12305 copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs));
12307 /* If unification failed, we're done. */
12308 if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm),
12309 CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE))
12315 /* Given a template type PARM and a class type ARG, find the unique
12316 base type in ARG that is an instance of PARM. We do not examine
12317 ARG itself; only its base-classes. If there is not exactly one
12318 appropriate base class, return NULL_TREE. PARM may be the type of
12319 a partial specialization, as well as a plain template type. Used
12323 get_template_base (tree tparms, tree targs, tree parm, tree arg)
12325 tree rval = NULL_TREE;
12328 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg)));
12330 binfo = TYPE_BINFO (complete_type (arg));
12332 /* The type could not be completed. */
12335 /* Walk in inheritance graph order. The search order is not
12336 important, and this avoids multiple walks of virtual bases. */
12337 for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo))
12339 tree r = try_class_unification (tparms, targs, parm, BINFO_TYPE (binfo));
12343 /* If there is more than one satisfactory baseclass, then:
12347 If they yield more than one possible deduced A, the type
12351 if (rval && !same_type_p (r, rval))
12361 /* Returns the level of DECL, which declares a template parameter. */
12364 template_decl_level (tree decl)
12366 switch (TREE_CODE (decl))
12369 case TEMPLATE_DECL:
12370 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl));
12373 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
12376 gcc_unreachable ();
12381 /* Decide whether ARG can be unified with PARM, considering only the
12382 cv-qualifiers of each type, given STRICT as documented for unify.
12383 Returns nonzero iff the unification is OK on that basis. */
12386 check_cv_quals_for_unify (int strict, tree arg, tree parm)
12388 int arg_quals = cp_type_quals (arg);
12389 int parm_quals = cp_type_quals (parm);
12391 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
12392 && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
12394 /* Although a CVR qualifier is ignored when being applied to a
12395 substituted template parameter ([8.3.2]/1 for example), that
12396 does not apply during deduction [14.8.2.4]/1, (even though
12397 that is not explicitly mentioned, [14.8.2.4]/9 indicates
12398 this). Except when we're allowing additional CV qualifiers
12399 at the outer level [14.8.2.1]/3,1st bullet. */
12400 if ((TREE_CODE (arg) == REFERENCE_TYPE
12401 || TREE_CODE (arg) == FUNCTION_TYPE
12402 || TREE_CODE (arg) == METHOD_TYPE)
12403 && (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)))
12406 if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
12407 && (parm_quals & TYPE_QUAL_RESTRICT))
12411 if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
12412 && (arg_quals & parm_quals) != parm_quals)
12415 if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL))
12416 && (parm_quals & arg_quals) != arg_quals)
12422 /* Determines the LEVEL and INDEX for the template parameter PARM. */
12424 template_parm_level_and_index (tree parm, int* level, int* index)
12426 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
12427 || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
12428 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
12430 *index = TEMPLATE_TYPE_IDX (parm);
12431 *level = TEMPLATE_TYPE_LEVEL (parm);
12435 *index = TEMPLATE_PARM_IDX (parm);
12436 *level = TEMPLATE_PARM_LEVEL (parm);
12440 /* Unifies the remaining arguments in PACKED_ARGS with the pack
12441 expansion at the end of PACKED_PARMS. Returns 0 if the type
12442 deduction succeeds, 1 otherwise. STRICT is the same as in
12443 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
12444 call argument list. We'll need to adjust the arguments to make them
12445 types. SUBR tells us if this is from a recursive call to
12446 type_unification_real. */
12448 unify_pack_expansion (tree tparms, tree targs, tree packed_parms,
12449 tree packed_args, int strict, bool call_args_p,
12453 = TREE_VEC_ELT (packed_parms, TREE_VEC_LENGTH (packed_parms) - 1);
12454 tree pattern = PACK_EXPANSION_PATTERN (parm);
12455 tree pack, packs = NULL_TREE;
12456 int i, start = TREE_VEC_LENGTH (packed_parms) - 1;
12457 int len = TREE_VEC_LENGTH (packed_args);
12459 /* Determine the parameter packs we will be deducing from the
12460 pattern, and record their current deductions. */
12461 for (pack = PACK_EXPANSION_PARAMETER_PACKS (parm);
12462 pack; pack = TREE_CHAIN (pack))
12464 tree parm_pack = TREE_VALUE (pack);
12467 /* Determine the index and level of this parameter pack. */
12468 template_parm_level_and_index (parm_pack, &level, &idx);
12470 /* Keep track of the parameter packs and their corresponding
12472 packs = tree_cons (parm_pack, TMPL_ARG (targs, level, idx), packs);
12473 TREE_TYPE (packs) = make_tree_vec (len - start);
12476 /* Loop through all of the arguments that have not yet been
12477 unified and unify each with the pattern. */
12478 for (i = start; i < len; i++)
12480 tree parm = pattern;
12482 /* For each parameter pack, clear out the deduced value so that
12483 we can deduce it again. */
12484 for (pack = packs; pack; pack = TREE_CHAIN (pack))
12487 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12489 TMPL_ARG (targs, level, idx) = NULL_TREE;
12492 /* Unify the pattern with the current argument. */
12494 tree arg = TREE_VEC_ELT (packed_args, i);
12495 tree arg_expr = NULL_TREE;
12496 int arg_strict = strict;
12497 bool skip_arg_p = false;
12503 /* This mirrors what we do in type_unification_real. */
12507 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL
12508 | UNIFY_ALLOW_MORE_CV_QUAL
12509 | UNIFY_ALLOW_DERIVED);
12513 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
12517 sub_strict = UNIFY_ALLOW_NONE;
12521 gcc_unreachable ();
12526 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
12527 if (type_unknown_p (arg))
12529 /* [temp.deduct.type] A template-argument can be
12530 deduced from a pointer to function or pointer
12531 to member function argument if the set of
12532 overloaded functions does not contain function
12533 templates and at most one of a set of
12534 overloaded functions provides a unique
12537 if (resolve_overloaded_unification
12538 (tparms, targs, parm, arg, strict, sub_strict)
12547 arg = unlowered_expr_type (arg);
12548 if (arg == error_mark_node)
12553 arg_strict = sub_strict;
12557 maybe_adjust_types_for_deduction (strict, &parm, &arg,
12563 if (unify (tparms, targs, parm, arg, arg_strict))
12568 /* For each parameter pack, collect the deduced value. */
12569 for (pack = packs; pack; pack = TREE_CHAIN (pack))
12572 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12574 TREE_VEC_ELT (TREE_TYPE (pack), i - start) =
12575 TMPL_ARG (targs, level, idx);
12579 /* Verify that the results of unification with the parameter packs
12580 produce results consistent with what we've seen before, and make
12581 the deduced argument packs available. */
12582 for (pack = packs; pack; pack = TREE_CHAIN (pack))
12584 tree old_pack = TREE_VALUE (pack);
12585 tree new_args = TREE_TYPE (pack);
12586 int i, len = TREE_VEC_LENGTH (new_args);
12587 bool nondeduced_p = false;
12589 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
12590 actually deduce anything. */
12591 for (i = 0; i < len && !nondeduced_p; ++i)
12592 if (TREE_VEC_ELT (new_args, i) == NULL_TREE)
12593 nondeduced_p = true;
12597 if (old_pack && ARGUMENT_PACK_INCOMPLETE_P (old_pack))
12599 /* Prepend the explicit arguments onto NEW_ARGS. */
12600 tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
12601 tree old_args = new_args;
12602 int i, explicit_len = TREE_VEC_LENGTH (explicit_args);
12603 int len = explicit_len + TREE_VEC_LENGTH (old_args);
12605 /* Copy the explicit arguments. */
12606 new_args = make_tree_vec (len);
12607 for (i = 0; i < explicit_len; i++)
12608 TREE_VEC_ELT (new_args, i) = TREE_VEC_ELT (explicit_args, i);
12610 /* Copy the deduced arguments. */
12611 for (; i < len; i++)
12612 TREE_VEC_ELT (new_args, i) =
12613 TREE_VEC_ELT (old_args, i - explicit_len);
12621 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12623 /* Build the deduced *_ARGUMENT_PACK. */
12624 if (TREE_CODE (TREE_PURPOSE (pack)) == TEMPLATE_PARM_INDEX)
12626 result = make_node (NONTYPE_ARGUMENT_PACK);
12627 TREE_TYPE (result) =
12628 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack)));
12629 TREE_CONSTANT (result) = 1;
12632 result = make_node (TYPE_ARGUMENT_PACK);
12634 SET_ARGUMENT_PACK_ARGS (result, new_args);
12636 /* Note the deduced argument packs for this parameter
12638 TMPL_ARG (targs, level, idx) = result;
12640 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack)
12641 && (ARGUMENT_PACK_ARGS (old_pack)
12642 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack)))
12644 /* We only had the explicitly-provided arguments before, but
12645 now we have a complete set of arguments. */
12647 tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
12648 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12650 /* Keep the original deduced argument pack. */
12651 TMPL_ARG (targs, level, idx) = old_pack;
12653 SET_ARGUMENT_PACK_ARGS (old_pack, new_args);
12654 ARGUMENT_PACK_INCOMPLETE_P (old_pack) = 1;
12655 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack) = explicit_args;
12657 else if (!comp_template_args (ARGUMENT_PACK_ARGS (old_pack),
12659 /* Inconsistent unification of this parameter pack. */
12665 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12667 /* Keep the original deduced argument pack. */
12668 TMPL_ARG (targs, level, idx) = old_pack;
12675 /* Deduce the value of template parameters. TPARMS is the (innermost)
12676 set of template parameters to a template. TARGS is the bindings
12677 for those template parameters, as determined thus far; TARGS may
12678 include template arguments for outer levels of template parameters
12679 as well. PARM is a parameter to a template function, or a
12680 subcomponent of that parameter; ARG is the corresponding argument.
12681 This function attempts to match PARM with ARG in a manner
12682 consistent with the existing assignments in TARGS. If more values
12683 are deduced, then TARGS is updated.
12685 Returns 0 if the type deduction succeeds, 1 otherwise. The
12686 parameter STRICT is a bitwise or of the following flags:
12689 Require an exact match between PARM and ARG.
12690 UNIFY_ALLOW_MORE_CV_QUAL:
12691 Allow the deduced ARG to be more cv-qualified (by qualification
12692 conversion) than ARG.
12693 UNIFY_ALLOW_LESS_CV_QUAL:
12694 Allow the deduced ARG to be less cv-qualified than ARG.
12695 UNIFY_ALLOW_DERIVED:
12696 Allow the deduced ARG to be a template base class of ARG,
12697 or a pointer to a template base class of the type pointed to by
12699 UNIFY_ALLOW_INTEGER:
12700 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
12701 case for more information.
12702 UNIFY_ALLOW_OUTER_LEVEL:
12703 This is the outermost level of a deduction. Used to determine validity
12704 of qualification conversions. A valid qualification conversion must
12705 have const qualified pointers leading up to the inner type which
12706 requires additional CV quals, except at the outer level, where const
12707 is not required [conv.qual]. It would be normal to set this flag in
12708 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
12709 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
12710 This is the outermost level of a deduction, and PARM can be more CV
12711 qualified at this point.
12712 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
12713 This is the outermost level of a deduction, and PARM can be less CV
12714 qualified at this point. */
12717 unify (tree tparms, tree targs, tree parm, tree arg, int strict)
12722 int strict_in = strict;
12724 /* I don't think this will do the right thing with respect to types.
12725 But the only case I've seen it in so far has been array bounds, where
12726 signedness is the only information lost, and I think that will be
12728 while (TREE_CODE (parm) == NOP_EXPR)
12729 parm = TREE_OPERAND (parm, 0);
12731 if (arg == error_mark_node)
12733 if (arg == unknown_type_node)
12734 /* We can't deduce anything from this, but we might get all the
12735 template args from other function args. */
12738 /* If PARM uses template parameters, then we can't bail out here,
12739 even if ARG == PARM, since we won't record unifications for the
12740 template parameters. We might need them if we're trying to
12741 figure out which of two things is more specialized. */
12742 if (arg == parm && !uses_template_parms (parm))
12745 /* Immediately reject some pairs that won't unify because of
12746 cv-qualification mismatches. */
12747 if (TREE_CODE (arg) == TREE_CODE (parm)
12749 /* It is the elements of the array which hold the cv quals of an array
12750 type, and the elements might be template type parms. We'll check
12751 when we recurse. */
12752 && TREE_CODE (arg) != ARRAY_TYPE
12753 /* We check the cv-qualifiers when unifying with template type
12754 parameters below. We want to allow ARG `const T' to unify with
12755 PARM `T' for example, when computing which of two templates
12756 is more specialized, for example. */
12757 && TREE_CODE (arg) != TEMPLATE_TYPE_PARM
12758 && !check_cv_quals_for_unify (strict_in, arg, parm))
12761 if (!(strict & UNIFY_ALLOW_OUTER_LEVEL)
12762 && TYPE_P (parm) && !CP_TYPE_CONST_P (parm))
12763 strict &= ~UNIFY_ALLOW_MORE_CV_QUAL;
12764 strict &= ~UNIFY_ALLOW_OUTER_LEVEL;
12765 strict &= ~UNIFY_ALLOW_DERIVED;
12766 strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
12767 strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL;
12769 switch (TREE_CODE (parm))
12771 case TYPENAME_TYPE:
12773 case UNBOUND_CLASS_TEMPLATE:
12774 /* In a type which contains a nested-name-specifier, template
12775 argument values cannot be deduced for template parameters used
12776 within the nested-name-specifier. */
12779 case TEMPLATE_TYPE_PARM:
12780 case TEMPLATE_TEMPLATE_PARM:
12781 case BOUND_TEMPLATE_TEMPLATE_PARM:
12782 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
12783 if (tparm == error_mark_node)
12786 if (TEMPLATE_TYPE_LEVEL (parm)
12787 != template_decl_level (tparm))
12788 /* The PARM is not one we're trying to unify. Just check
12789 to see if it matches ARG. */
12790 return (TREE_CODE (arg) == TREE_CODE (parm)
12791 && same_type_p (parm, arg)) ? 0 : 1;
12792 idx = TEMPLATE_TYPE_IDX (parm);
12793 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
12794 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx));
12796 /* Check for mixed types and values. */
12797 if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
12798 && TREE_CODE (tparm) != TYPE_DECL)
12799 || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
12800 && TREE_CODE (tparm) != TEMPLATE_DECL))
12803 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
12805 /* ARG must be constructed from a template class or a template
12806 template parameter. */
12807 if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM
12808 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg))
12812 tree parmvec = TYPE_TI_ARGS (parm);
12813 tree argvec = INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg));
12815 = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_TI_TEMPLATE (arg));
12817 int parm_variadic_p = 0;
12819 /* The resolution to DR150 makes clear that default
12820 arguments for an N-argument may not be used to bind T
12821 to a template template parameter with fewer than N
12822 parameters. It is not safe to permit the binding of
12823 default arguments as an extension, as that may change
12824 the meaning of a conforming program. Consider:
12826 struct Dense { static const unsigned int dim = 1; };
12828 template <template <typename> class View,
12830 void operator+(float, View<Block> const&);
12832 template <typename Block,
12833 unsigned int Dim = Block::dim>
12834 struct Lvalue_proxy { operator float() const; };
12838 Lvalue_proxy<Dense> p;
12843 Here, if Lvalue_proxy is permitted to bind to View, then
12844 the global operator+ will be used; if they are not, the
12845 Lvalue_proxy will be converted to float. */
12846 if (coerce_template_parms (argtmplvec, parmvec,
12847 TYPE_TI_TEMPLATE (parm),
12849 /*require_all_args=*/true,
12850 /*use_default_args=*/false)
12851 == error_mark_node)
12854 /* Deduce arguments T, i from TT<T> or TT<i>.
12855 We check each element of PARMVEC and ARGVEC individually
12856 rather than the whole TREE_VEC since they can have
12857 different number of elements. */
12859 parmvec = expand_template_argument_pack (parmvec);
12860 argvec = expand_template_argument_pack (argvec);
12862 len = TREE_VEC_LENGTH (parmvec);
12864 /* Check if the parameters end in a pack, making them
12867 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec, len - 1)))
12868 parm_variadic_p = 1;
12870 if (TREE_VEC_LENGTH (argvec) < len - parm_variadic_p)
12873 for (i = 0; i < len - parm_variadic_p; ++i)
12875 if (unify (tparms, targs,
12876 TREE_VEC_ELT (parmvec, i),
12877 TREE_VEC_ELT (argvec, i),
12882 if (parm_variadic_p
12883 && unify_pack_expansion (tparms, targs,
12886 /*call_args_p=*/false,
12890 arg = TYPE_TI_TEMPLATE (arg);
12892 /* Fall through to deduce template name. */
12895 if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
12896 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
12898 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
12900 /* Simple cases: Value already set, does match or doesn't. */
12901 if (targ != NULL_TREE && template_args_equal (targ, arg))
12908 /* If PARM is `const T' and ARG is only `int', we don't have
12909 a match unless we are allowing additional qualification.
12910 If ARG is `const int' and PARM is just `T' that's OK;
12911 that binds `const int' to `T'. */
12912 if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL,
12916 /* Consider the case where ARG is `const volatile int' and
12917 PARM is `const T'. Then, T should be `volatile int'. */
12918 arg = cp_build_qualified_type_real
12919 (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
12920 if (arg == error_mark_node)
12923 /* Simple cases: Value already set, does match or doesn't. */
12924 if (targ != NULL_TREE && same_type_p (targ, arg))
12929 /* Make sure that ARG is not a variable-sized array. (Note
12930 that were talking about variable-sized arrays (like
12931 `int[n]'), rather than arrays of unknown size (like
12932 `int[]').) We'll get very confused by such a type since
12933 the bound of the array will not be computable in an
12934 instantiation. Besides, such types are not allowed in
12935 ISO C++, so we can do as we please here. */
12936 if (variably_modified_type_p (arg, NULL_TREE))
12940 /* If ARG is a parameter pack or an expansion, we cannot unify
12941 against it unless PARM is also a parameter pack. */
12942 if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
12943 && !template_parameter_pack_p (parm))
12946 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
12949 case TEMPLATE_PARM_INDEX:
12950 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
12951 if (tparm == error_mark_node)
12954 if (TEMPLATE_PARM_LEVEL (parm)
12955 != template_decl_level (tparm))
12956 /* The PARM is not one we're trying to unify. Just check
12957 to see if it matches ARG. */
12958 return !(TREE_CODE (arg) == TREE_CODE (parm)
12959 && cp_tree_equal (parm, arg));
12961 idx = TEMPLATE_PARM_IDX (parm);
12962 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
12965 return !cp_tree_equal (targ, arg);
12967 /* [temp.deduct.type] If, in the declaration of a function template
12968 with a non-type template-parameter, the non-type
12969 template-parameter is used in an expression in the function
12970 parameter-list and, if the corresponding template-argument is
12971 deduced, the template-argument type shall match the type of the
12972 template-parameter exactly, except that a template-argument
12973 deduced from an array bound may be of any integral type.
12974 The non-type parameter might use already deduced type parameters. */
12975 tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE);
12976 if (!TREE_TYPE (arg))
12977 /* Template-parameter dependent expression. Just accept it for now.
12978 It will later be processed in convert_template_argument. */
12980 else if (same_type_p (TREE_TYPE (arg), tparm))
12982 else if ((strict & UNIFY_ALLOW_INTEGER)
12983 && (TREE_CODE (tparm) == INTEGER_TYPE
12984 || TREE_CODE (tparm) == BOOLEAN_TYPE))
12985 /* Convert the ARG to the type of PARM; the deduced non-type
12986 template argument must exactly match the types of the
12987 corresponding parameter. */
12988 arg = fold (build_nop (TREE_TYPE (parm), arg));
12989 else if (uses_template_parms (tparm))
12990 /* We haven't deduced the type of this parameter yet. Try again
12996 /* If ARG is a parameter pack or an expansion, we cannot unify
12997 against it unless PARM is also a parameter pack. */
12998 if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
12999 && !TEMPLATE_PARM_PARAMETER_PACK (parm))
13002 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
13007 /* A pointer-to-member constant can be unified only with
13008 another constant. */
13009 if (TREE_CODE (arg) != PTRMEM_CST)
13012 /* Just unify the class member. It would be useless (and possibly
13013 wrong, depending on the strict flags) to unify also
13014 PTRMEM_CST_CLASS, because we want to be sure that both parm and
13015 arg refer to the same variable, even if through different
13016 classes. For instance:
13018 struct A { int x; };
13021 Unification of &A::x and &B::x must succeed. */
13022 return unify (tparms, targs, PTRMEM_CST_MEMBER (parm),
13023 PTRMEM_CST_MEMBER (arg), strict);
13028 if (TREE_CODE (arg) != POINTER_TYPE)
13031 /* [temp.deduct.call]
13033 A can be another pointer or pointer to member type that can
13034 be converted to the deduced A via a qualification
13035 conversion (_conv.qual_).
13037 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
13038 This will allow for additional cv-qualification of the
13039 pointed-to types if appropriate. */
13041 if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
13042 /* The derived-to-base conversion only persists through one
13043 level of pointers. */
13044 strict |= (strict_in & UNIFY_ALLOW_DERIVED);
13046 return unify (tparms, targs, TREE_TYPE (parm),
13047 TREE_TYPE (arg), strict);
13050 case REFERENCE_TYPE:
13051 if (TREE_CODE (arg) != REFERENCE_TYPE)
13053 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
13054 strict & UNIFY_ALLOW_MORE_CV_QUAL);
13057 if (TREE_CODE (arg) != ARRAY_TYPE)
13059 if ((TYPE_DOMAIN (parm) == NULL_TREE)
13060 != (TYPE_DOMAIN (arg) == NULL_TREE))
13062 if (TYPE_DOMAIN (parm) != NULL_TREE)
13069 /* Our representation of array types uses "N - 1" as the
13070 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
13071 not an integer constant. We cannot unify arbitrarily
13072 complex expressions, so we eliminate the MINUS_EXPRs
13074 parm_max = TYPE_MAX_VALUE (TYPE_DOMAIN (parm));
13075 parm_cst = TREE_CODE (parm_max) == INTEGER_CST;
13078 gcc_assert (TREE_CODE (parm_max) == MINUS_EXPR);
13079 parm_max = TREE_OPERAND (parm_max, 0);
13081 arg_max = TYPE_MAX_VALUE (TYPE_DOMAIN (arg));
13082 arg_cst = TREE_CODE (arg_max) == INTEGER_CST;
13085 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
13086 trying to unify the type of a variable with the type
13087 of a template parameter. For example:
13089 template <unsigned int N>
13090 void f (char (&) [N]);
13097 Here, the type of the ARG will be "int [g(i)]", and
13098 may be a SAVE_EXPR, etc. */
13099 if (TREE_CODE (arg_max) != MINUS_EXPR)
13101 arg_max = TREE_OPERAND (arg_max, 0);
13104 /* If only one of the bounds used a MINUS_EXPR, compensate
13105 by adding one to the other bound. */
13106 if (parm_cst && !arg_cst)
13107 parm_max = fold_build2 (PLUS_EXPR,
13111 else if (arg_cst && !parm_cst)
13112 arg_max = fold_build2 (PLUS_EXPR,
13117 if (unify (tparms, targs, parm_max, arg_max, UNIFY_ALLOW_INTEGER))
13120 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
13121 strict & UNIFY_ALLOW_MORE_CV_QUAL);
13128 case ENUMERAL_TYPE:
13130 if (TREE_CODE (arg) != TREE_CODE (parm))
13133 /* We have already checked cv-qualification at the top of the
13135 if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
13138 /* As far as unification is concerned, this wins. Later checks
13139 will invalidate it if necessary. */
13142 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
13143 /* Type INTEGER_CST can come from ordinary constant template args. */
13145 while (TREE_CODE (arg) == NOP_EXPR)
13146 arg = TREE_OPERAND (arg, 0);
13148 if (TREE_CODE (arg) != INTEGER_CST)
13150 return !tree_int_cst_equal (parm, arg);
13155 if (TREE_CODE (arg) != TREE_VEC)
13157 if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
13159 for (i = 0; i < TREE_VEC_LENGTH (parm); ++i)
13160 if (unify (tparms, targs,
13161 TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
13169 if (TREE_CODE (arg) != TREE_CODE (parm))
13172 if (TYPE_PTRMEMFUNC_P (parm))
13174 if (!TYPE_PTRMEMFUNC_P (arg))
13177 return unify (tparms, targs,
13178 TYPE_PTRMEMFUNC_FN_TYPE (parm),
13179 TYPE_PTRMEMFUNC_FN_TYPE (arg),
13183 if (CLASSTYPE_TEMPLATE_INFO (parm))
13185 tree t = NULL_TREE;
13187 if (strict_in & UNIFY_ALLOW_DERIVED)
13189 /* First, we try to unify the PARM and ARG directly. */
13190 t = try_class_unification (tparms, targs,
13195 /* Fallback to the special case allowed in
13196 [temp.deduct.call]:
13198 If P is a class, and P has the form
13199 template-id, then A can be a derived class of
13200 the deduced A. Likewise, if P is a pointer to
13201 a class of the form template-id, A can be a
13202 pointer to a derived class pointed to by the
13204 t = get_template_base (tparms, targs, parm, arg);
13210 else if (CLASSTYPE_TEMPLATE_INFO (arg)
13211 && (CLASSTYPE_TI_TEMPLATE (parm)
13212 == CLASSTYPE_TI_TEMPLATE (arg)))
13213 /* Perhaps PARM is something like S<U> and ARG is S<int>.
13214 Then, we should unify `int' and `U'. */
13217 /* There's no chance of unification succeeding. */
13220 return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
13221 CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE);
13223 else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
13228 case FUNCTION_TYPE:
13229 if (TREE_CODE (arg) != TREE_CODE (parm))
13232 /* CV qualifications for methods can never be deduced, they must
13233 match exactly. We need to check them explicitly here,
13234 because type_unification_real treats them as any other
13235 cvqualified parameter. */
13236 if (TREE_CODE (parm) == METHOD_TYPE
13237 && (!check_cv_quals_for_unify
13239 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (arg))),
13240 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (parm))))))
13243 if (unify (tparms, targs, TREE_TYPE (parm),
13244 TREE_TYPE (arg), UNIFY_ALLOW_NONE))
13246 return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
13247 TYPE_ARG_TYPES (arg), 1, DEDUCE_EXACT,
13251 /* Unify a pointer to member with a pointer to member function, which
13252 deduces the type of the member as a function type. */
13253 if (TYPE_PTRMEMFUNC_P (arg))
13257 cp_cv_quals cv_quals;
13259 /* Check top-level cv qualifiers */
13260 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE, arg, parm))
13263 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
13264 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg), UNIFY_ALLOW_NONE))
13267 /* Determine the type of the function we are unifying against. */
13268 method_type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (arg));
13270 build_function_type (TREE_TYPE (method_type),
13271 TREE_CHAIN (TYPE_ARG_TYPES (method_type)));
13273 /* Extract the cv-qualifiers of the member function from the
13274 implicit object parameter and place them on the function
13275 type to be restored later. */
13277 cp_type_quals(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (method_type))));
13278 fntype = build_qualified_type (fntype, cv_quals);
13279 return unify (tparms, targs, TREE_TYPE (parm), fntype, strict);
13282 if (TREE_CODE (arg) != OFFSET_TYPE)
13284 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
13285 TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE))
13287 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
13291 if (DECL_TEMPLATE_PARM_P (parm))
13292 return unify (tparms, targs, DECL_INITIAL (parm), arg, strict);
13293 if (arg != integral_constant_value (parm))
13298 case TEMPLATE_DECL:
13299 /* Matched cases are handled by the ARG == PARM test above. */
13302 case TYPE_ARGUMENT_PACK:
13303 case NONTYPE_ARGUMENT_PACK:
13305 tree packed_parms = ARGUMENT_PACK_ARGS (parm);
13306 tree packed_args = ARGUMENT_PACK_ARGS (arg);
13307 int i, len = TREE_VEC_LENGTH (packed_parms);
13308 int argslen = TREE_VEC_LENGTH (packed_args);
13309 int parm_variadic_p = 0;
13311 for (i = 0; i < len; ++i)
13313 if (PACK_EXPANSION_P (TREE_VEC_ELT (packed_parms, i)))
13316 /* We can unify against something with a trailing
13318 parm_variadic_p = 1;
13320 /* Since there is something following the pack
13321 expansion, we cannot unify this template argument
13328 /* If we don't have enough arguments to satisfy the parameters
13329 (not counting the pack expression at the end), or we have
13330 too many arguments for a parameter list that doesn't end in
13331 a pack expression, we can't unify. */
13332 if (argslen < (len - parm_variadic_p)
13333 || (argslen > len && !parm_variadic_p))
13336 /* Unify all of the parameters that precede the (optional)
13337 pack expression. */
13338 for (i = 0; i < len - parm_variadic_p; ++i)
13340 if (unify (tparms, targs, TREE_VEC_ELT (packed_parms, i),
13341 TREE_VEC_ELT (packed_args, i), strict))
13345 if (parm_variadic_p)
13346 return unify_pack_expansion (tparms, targs,
13347 packed_parms, packed_args,
13348 strict, /*call_args_p=*/false,
13356 case DECLTYPE_TYPE:
13357 /* Cannot deduce anything from TYPEOF_TYPE or DECLTYPE_TYPE
13362 /* Unification fails if we hit an error node. */
13366 gcc_assert (EXPR_P (parm));
13368 /* We must be looking at an expression. This can happen with
13372 void foo(S<I>, S<I + 2>);
13374 This is a "nondeduced context":
13378 The nondeduced contexts are:
13380 --A type that is a template-id in which one or more of
13381 the template-arguments is an expression that references
13382 a template-parameter.
13384 In these cases, we assume deduction succeeded, but don't
13385 actually infer any unifications. */
13387 if (!uses_template_parms (parm)
13388 && !template_args_equal (parm, arg))
13395 /* Note that DECL can be defined in this translation unit, if
13399 mark_definable (tree decl)
13402 DECL_NOT_REALLY_EXTERN (decl) = 1;
13403 FOR_EACH_CLONE (clone, decl)
13404 DECL_NOT_REALLY_EXTERN (clone) = 1;
13407 /* Called if RESULT is explicitly instantiated, or is a member of an
13408 explicitly instantiated class. */
13411 mark_decl_instantiated (tree result, int extern_p)
13413 SET_DECL_EXPLICIT_INSTANTIATION (result);
13415 /* If this entity has already been written out, it's too late to
13416 make any modifications. */
13417 if (TREE_ASM_WRITTEN (result))
13420 if (TREE_CODE (result) != FUNCTION_DECL)
13421 /* The TREE_PUBLIC flag for function declarations will have been
13422 set correctly by tsubst. */
13423 TREE_PUBLIC (result) = 1;
13425 /* This might have been set by an earlier implicit instantiation. */
13426 DECL_COMDAT (result) = 0;
13429 DECL_NOT_REALLY_EXTERN (result) = 0;
13432 mark_definable (result);
13433 /* Always make artificials weak. */
13434 if (DECL_ARTIFICIAL (result) && flag_weak)
13435 comdat_linkage (result);
13436 /* For WIN32 we also want to put explicit instantiations in
13437 linkonce sections. */
13438 else if (TREE_PUBLIC (result))
13439 maybe_make_one_only (result);
13442 /* If EXTERN_P, then this function will not be emitted -- unless
13443 followed by an explicit instantiation, at which point its linkage
13444 will be adjusted. If !EXTERN_P, then this function will be
13445 emitted here. In neither circumstance do we want
13446 import_export_decl to adjust the linkage. */
13447 DECL_INTERFACE_KNOWN (result) = 1;
13450 /* Given two function templates PAT1 and PAT2, return:
13452 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
13453 -1 if PAT2 is more specialized than PAT1.
13454 0 if neither is more specialized.
13456 LEN indicates the number of parameters we should consider
13457 (defaulted parameters should not be considered).
13459 The 1998 std underspecified function template partial ordering, and
13460 DR214 addresses the issue. We take pairs of arguments, one from
13461 each of the templates, and deduce them against each other. One of
13462 the templates will be more specialized if all the *other*
13463 template's arguments deduce against its arguments and at least one
13464 of its arguments *does* *not* deduce against the other template's
13465 corresponding argument. Deduction is done as for class templates.
13466 The arguments used in deduction have reference and top level cv
13467 qualifiers removed. Iff both arguments were originally reference
13468 types *and* deduction succeeds in both directions, the template
13469 with the more cv-qualified argument wins for that pairing (if
13470 neither is more cv-qualified, they both are equal). Unlike regular
13471 deduction, after all the arguments have been deduced in this way,
13472 we do *not* verify the deduced template argument values can be
13473 substituted into non-deduced contexts, nor do we have to verify
13474 that all template arguments have been deduced. */
13477 more_specialized_fn (tree pat1, tree pat2, int len)
13479 tree decl1 = DECL_TEMPLATE_RESULT (pat1);
13480 tree decl2 = DECL_TEMPLATE_RESULT (pat2);
13481 tree targs1 = make_tree_vec (DECL_NTPARMS (pat1));
13482 tree targs2 = make_tree_vec (DECL_NTPARMS (pat2));
13483 tree tparms1 = DECL_INNERMOST_TEMPLATE_PARMS (pat1);
13484 tree tparms2 = DECL_INNERMOST_TEMPLATE_PARMS (pat2);
13485 tree args1 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
13486 tree args2 = TYPE_ARG_TYPES (TREE_TYPE (decl2));
13490 /* Remove the this parameter from non-static member functions. If
13491 one is a non-static member function and the other is not a static
13492 member function, remove the first parameter from that function
13493 also. This situation occurs for operator functions where we
13494 locate both a member function (with this pointer) and non-member
13495 operator (with explicit first operand). */
13496 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1))
13498 len--; /* LEN is the number of significant arguments for DECL1 */
13499 args1 = TREE_CHAIN (args1);
13500 if (!DECL_STATIC_FUNCTION_P (decl2))
13501 args2 = TREE_CHAIN (args2);
13503 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2))
13505 args2 = TREE_CHAIN (args2);
13506 if (!DECL_STATIC_FUNCTION_P (decl1))
13509 args1 = TREE_CHAIN (args1);
13513 /* If only one is a conversion operator, they are unordered. */
13514 if (DECL_CONV_FN_P (decl1) != DECL_CONV_FN_P (decl2))
13517 /* Consider the return type for a conversion function */
13518 if (DECL_CONV_FN_P (decl1))
13520 args1 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl1)), args1);
13521 args2 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl2)), args2);
13525 processing_template_decl++;
13529 tree arg1 = TREE_VALUE (args1);
13530 tree arg2 = TREE_VALUE (args2);
13531 int deduce1, deduce2;
13535 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
13536 && TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
13538 /* When both arguments are pack expansions, we need only
13539 unify the patterns themselves. */
13540 arg1 = PACK_EXPANSION_PATTERN (arg1);
13541 arg2 = PACK_EXPANSION_PATTERN (arg2);
13543 /* This is the last comparison we need to do. */
13547 if (TREE_CODE (arg1) == REFERENCE_TYPE)
13549 arg1 = TREE_TYPE (arg1);
13550 quals1 = cp_type_quals (arg1);
13553 if (TREE_CODE (arg2) == REFERENCE_TYPE)
13555 arg2 = TREE_TYPE (arg2);
13556 quals2 = cp_type_quals (arg2);
13559 if ((quals1 < 0) != (quals2 < 0))
13561 /* Only of the args is a reference, see if we should apply
13562 array/function pointer decay to it. This is not part of
13563 DR214, but is, IMHO, consistent with the deduction rules
13564 for the function call itself, and with our earlier
13565 implementation of the underspecified partial ordering
13566 rules. (nathan). */
13569 switch (TREE_CODE (arg1))
13572 arg1 = TREE_TYPE (arg1);
13574 case FUNCTION_TYPE:
13575 arg1 = build_pointer_type (arg1);
13584 switch (TREE_CODE (arg2))
13587 arg2 = TREE_TYPE (arg2);
13589 case FUNCTION_TYPE:
13590 arg2 = build_pointer_type (arg2);
13599 arg1 = TYPE_MAIN_VARIANT (arg1);
13600 arg2 = TYPE_MAIN_VARIANT (arg2);
13602 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION)
13604 int i, len2 = list_length (args2);
13605 tree parmvec = make_tree_vec (1);
13606 tree argvec = make_tree_vec (len2);
13609 /* Setup the parameter vector, which contains only ARG1. */
13610 TREE_VEC_ELT (parmvec, 0) = arg1;
13612 /* Setup the argument vector, which contains the remaining
13614 for (i = 0; i < len2; i++, ta = TREE_CHAIN (ta))
13615 TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
13617 deduce1 = !unify_pack_expansion (tparms1, targs1, parmvec,
13618 argvec, UNIFY_ALLOW_NONE,
13619 /*call_args_p=*/false,
13622 /* We cannot deduce in the other direction, because ARG1 is
13623 a pack expansion but ARG2 is not. */
13626 else if (TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
13628 int i, len1 = list_length (args1);
13629 tree parmvec = make_tree_vec (1);
13630 tree argvec = make_tree_vec (len1);
13633 /* Setup the parameter vector, which contains only ARG1. */
13634 TREE_VEC_ELT (parmvec, 0) = arg2;
13636 /* Setup the argument vector, which contains the remaining
13638 for (i = 0; i < len1; i++, ta = TREE_CHAIN (ta))
13639 TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
13641 deduce2 = !unify_pack_expansion (tparms2, targs2, parmvec,
13642 argvec, UNIFY_ALLOW_NONE,
13643 /*call_args_p=*/false,
13646 /* We cannot deduce in the other direction, because ARG2 is
13647 a pack expansion but ARG1 is not.*/
13653 /* The normal case, where neither argument is a pack
13655 deduce1 = !unify (tparms1, targs1, arg1, arg2, UNIFY_ALLOW_NONE);
13656 deduce2 = !unify (tparms2, targs2, arg2, arg1, UNIFY_ALLOW_NONE);
13663 if (better1 < 0 && better2 < 0)
13664 /* We've failed to deduce something in either direction.
13665 These must be unordered. */
13668 if (deduce1 && deduce2 && quals1 >= 0 && quals2 >= 0)
13670 /* Deduces in both directions, see if quals can
13671 disambiguate. Pretend the worse one failed to deduce. */
13672 if ((quals1 & quals2) == quals2)
13674 if ((quals1 & quals2) == quals1)
13677 if (deduce1 && !deduce2 && !better2)
13679 if (deduce2 && !deduce1 && !better1)
13682 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
13683 || TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
13684 /* We have already processed all of the arguments in our
13685 handing of the pack expansion type. */
13688 args1 = TREE_CHAIN (args1);
13689 args2 = TREE_CHAIN (args2);
13691 /* Stop when an ellipsis is seen. */
13692 if (args1 == NULL_TREE || args2 == NULL_TREE)
13696 processing_template_decl--;
13698 /* All things being equal, if the next argument is a pack expansion
13699 for one function but not for the other, prefer the
13700 non-variadic function. */
13701 if ((better1 > 0) - (better2 > 0) == 0
13702 && args1 && TREE_VALUE (args1)
13703 && args2 && TREE_VALUE (args2))
13705 if (TREE_CODE (TREE_VALUE (args1)) == TYPE_PACK_EXPANSION)
13706 return TREE_CODE (TREE_VALUE (args2)) == TYPE_PACK_EXPANSION ? 0 : -1;
13707 else if (TREE_CODE (TREE_VALUE (args2)) == TYPE_PACK_EXPANSION)
13711 return (better1 > 0) - (better2 > 0);
13714 /* Determine which of two partial specializations is more specialized.
13716 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
13717 to the first partial specialization. The TREE_VALUE is the
13718 innermost set of template parameters for the partial
13719 specialization. PAT2 is similar, but for the second template.
13721 Return 1 if the first partial specialization is more specialized;
13722 -1 if the second is more specialized; 0 if neither is more
13725 See [temp.class.order] for information about determining which of
13726 two templates is more specialized. */
13729 more_specialized_class (tree pat1, tree pat2)
13734 bool any_deductions = false;
13736 tmpl1 = TREE_TYPE (pat1);
13737 tmpl2 = TREE_TYPE (pat2);
13739 /* Just like what happens for functions, if we are ordering between
13740 different class template specializations, we may encounter dependent
13741 types in the arguments, and we need our dependency check functions
13742 to behave correctly. */
13743 ++processing_template_decl;
13744 targs = get_class_bindings (TREE_VALUE (pat1),
13745 CLASSTYPE_TI_ARGS (tmpl1),
13746 CLASSTYPE_TI_ARGS (tmpl2));
13750 any_deductions = true;
13753 targs = get_class_bindings (TREE_VALUE (pat2),
13754 CLASSTYPE_TI_ARGS (tmpl2),
13755 CLASSTYPE_TI_ARGS (tmpl1));
13759 any_deductions = true;
13761 --processing_template_decl;
13763 /* In the case of a tie where at least one of the class templates
13764 has a parameter pack at the end, the template with the most
13765 non-packed parameters wins. */
13768 && (template_args_variadic_p (TREE_PURPOSE (pat1))
13769 || template_args_variadic_p (TREE_PURPOSE (pat2))))
13771 tree args1 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1));
13772 tree args2 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2));
13773 int len1 = TREE_VEC_LENGTH (args1);
13774 int len2 = TREE_VEC_LENGTH (args2);
13776 /* We don't count the pack expansion at the end. */
13777 if (template_args_variadic_p (TREE_PURPOSE (pat1)))
13779 if (template_args_variadic_p (TREE_PURPOSE (pat2)))
13784 else if (len1 < len2)
13791 /* Return the template arguments that will produce the function signature
13792 DECL from the function template FN, with the explicit template
13793 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
13794 also match. Return NULL_TREE if no satisfactory arguments could be
13798 get_bindings (tree fn, tree decl, tree explicit_args, bool check_rettype)
13800 int ntparms = DECL_NTPARMS (fn);
13801 tree targs = make_tree_vec (ntparms);
13803 tree decl_arg_types;
13805 /* Substitute the explicit template arguments into the type of DECL.
13806 The call to fn_type_unification will handle substitution into the
13808 decl_type = TREE_TYPE (decl);
13809 if (explicit_args && uses_template_parms (decl_type))
13812 tree converted_args;
13814 if (DECL_TEMPLATE_INFO (decl))
13815 tmpl = DECL_TI_TEMPLATE (decl);
13817 /* We can get here for some invalid specializations. */
13821 = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
13822 explicit_args, NULL_TREE,
13824 /*require_all_args=*/false,
13825 /*use_default_args=*/false);
13826 if (converted_args == error_mark_node)
13829 decl_type = tsubst (decl_type, converted_args, tf_none, NULL_TREE);
13830 if (decl_type == error_mark_node)
13834 /* Never do unification on the 'this' parameter. */
13835 decl_arg_types = skip_artificial_parms_for (decl,
13836 TYPE_ARG_TYPES (decl_type));
13838 if (fn_type_unification (fn, explicit_args, targs,
13840 (check_rettype || DECL_CONV_FN_P (fn)
13841 ? TREE_TYPE (decl_type) : NULL_TREE),
13842 DEDUCE_EXACT, LOOKUP_NORMAL))
13848 /* Return the innermost template arguments that, when applied to a
13849 template specialization whose innermost template parameters are
13850 TPARMS, and whose specialization arguments are PARMS, yield the
13853 For example, suppose we have:
13855 template <class T, class U> struct S {};
13856 template <class T> struct S<T*, int> {};
13858 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
13859 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
13860 int}. The resulting vector will be {double}, indicating that `T'
13861 is bound to `double'. */
13864 get_class_bindings (tree tparms, tree spec_args, tree args)
13866 int i, ntparms = TREE_VEC_LENGTH (tparms);
13868 tree innermost_deduced_args;
13870 innermost_deduced_args = make_tree_vec (ntparms);
13871 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
13873 deduced_args = copy_node (args);
13874 SET_TMPL_ARGS_LEVEL (deduced_args,
13875 TMPL_ARGS_DEPTH (deduced_args),
13876 innermost_deduced_args);
13879 deduced_args = innermost_deduced_args;
13881 if (unify (tparms, deduced_args,
13882 INNERMOST_TEMPLATE_ARGS (spec_args),
13883 INNERMOST_TEMPLATE_ARGS (args),
13887 for (i = 0; i < ntparms; ++i)
13888 if (! TREE_VEC_ELT (innermost_deduced_args, i))
13891 /* Verify that nondeduced template arguments agree with the type
13892 obtained from argument deduction.
13896 struct A { typedef int X; };
13897 template <class T, class U> struct C {};
13898 template <class T> struct C<T, typename T::X> {};
13900 Then with the instantiation `C<A, int>', we can deduce that
13901 `T' is `A' but unify () does not check whether `typename T::X'
13903 spec_args = tsubst (spec_args, deduced_args, tf_none, NULL_TREE);
13904 if (spec_args == error_mark_node
13905 /* We only need to check the innermost arguments; the other
13906 arguments will always agree. */
13907 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args),
13908 INNERMOST_TEMPLATE_ARGS (args)))
13911 /* Now that we have bindings for all of the template arguments,
13912 ensure that the arguments deduced for the template template
13913 parameters have compatible template parameter lists. See the use
13914 of template_template_parm_bindings_ok_p in fn_type_unification
13915 for more information. */
13916 if (!template_template_parm_bindings_ok_p (tparms, deduced_args))
13919 return deduced_args;
13922 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
13923 Return the TREE_LIST node with the most specialized template, if
13924 any. If there is no most specialized template, the error_mark_node
13927 Note that this function does not look at, or modify, the
13928 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
13929 returned is one of the elements of INSTANTIATIONS, callers may
13930 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
13931 and retrieve it from the value returned. */
13934 most_specialized_instantiation (tree templates)
13938 ++processing_template_decl;
13941 for (fn = TREE_CHAIN (templates); fn; fn = TREE_CHAIN (fn))
13945 if (get_bindings (TREE_VALUE (champ),
13946 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
13947 NULL_TREE, /*check_ret=*/false))
13950 if (get_bindings (TREE_VALUE (fn),
13951 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
13952 NULL_TREE, /*check_ret=*/false))
13959 /* Equally specialized, move to next function. If there
13960 is no next function, nothing's most specialized. */
13961 fn = TREE_CHAIN (fn);
13969 /* Now verify that champ is better than everything earlier in the
13970 instantiation list. */
13971 for (fn = templates; fn != champ; fn = TREE_CHAIN (fn))
13972 if (get_bindings (TREE_VALUE (champ),
13973 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
13974 NULL_TREE, /*check_ret=*/false)
13975 || !get_bindings (TREE_VALUE (fn),
13976 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
13977 NULL_TREE, /*check_ret=*/false))
13983 processing_template_decl--;
13986 return error_mark_node;
13991 /* If DECL is a specialization of some template, return the most
13992 general such template. Otherwise, returns NULL_TREE.
13994 For example, given:
13996 template <class T> struct S { template <class U> void f(U); };
13998 if TMPL is `template <class U> void S<int>::f(U)' this will return
13999 the full template. This function will not trace past partial
14000 specializations, however. For example, given in addition:
14002 template <class T> struct S<T*> { template <class U> void f(U); };
14004 if TMPL is `template <class U> void S<int*>::f(U)' this will return
14005 `template <class T> template <class U> S<T*>::f(U)'. */
14008 most_general_template (tree decl)
14010 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
14011 an immediate specialization. */
14012 if (TREE_CODE (decl) == FUNCTION_DECL)
14014 if (DECL_TEMPLATE_INFO (decl)) {
14015 decl = DECL_TI_TEMPLATE (decl);
14017 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
14018 template friend. */
14019 if (TREE_CODE (decl) != TEMPLATE_DECL)
14025 /* Look for more and more general templates. */
14026 while (DECL_TEMPLATE_INFO (decl))
14028 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
14029 (See cp-tree.h for details.) */
14030 if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
14033 if (CLASS_TYPE_P (TREE_TYPE (decl))
14034 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
14037 /* Stop if we run into an explicitly specialized class template. */
14038 if (!DECL_NAMESPACE_SCOPE_P (decl)
14039 && DECL_CONTEXT (decl)
14040 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl)))
14043 decl = DECL_TI_TEMPLATE (decl);
14049 /* Return the most specialized of the class template partial
14050 specializations of TMPL which can produce TYPE, a specialization of
14051 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
14052 a _TYPE node corresponding to the partial specialization, while the
14053 TREE_PURPOSE is the set of template arguments that must be
14054 substituted into the TREE_TYPE in order to generate TYPE.
14056 If the choice of partial specialization is ambiguous, a diagnostic
14057 is issued, and the error_mark_node is returned. If there are no
14058 partial specializations of TMPL matching TYPE, then NULL_TREE is
14062 most_specialized_class (tree type, tree tmpl)
14064 tree list = NULL_TREE;
14070 tree outer_args = NULL_TREE;
14072 tmpl = most_general_template (tmpl);
14073 args = CLASSTYPE_TI_ARGS (type);
14075 /* For determining which partial specialization to use, only the
14076 innermost args are interesting. */
14077 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
14079 outer_args = strip_innermost_template_args (args, 1);
14080 args = INNERMOST_TEMPLATE_ARGS (args);
14083 for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t))
14085 tree partial_spec_args;
14087 tree parms = TREE_VALUE (t);
14089 partial_spec_args = CLASSTYPE_TI_ARGS (TREE_TYPE (t));
14094 ++processing_template_decl;
14096 /* Discard the outer levels of args, and then substitute in the
14097 template args from the enclosing class. */
14098 partial_spec_args = INNERMOST_TEMPLATE_ARGS (partial_spec_args);
14099 partial_spec_args = tsubst_template_args
14100 (partial_spec_args, outer_args, tf_none, NULL_TREE);
14102 /* PARMS already refers to just the innermost parms, but the
14103 template parms in partial_spec_args had their levels lowered
14104 by tsubst, so we need to do the same for the parm list. We
14105 can't just tsubst the TREE_VEC itself, as tsubst wants to
14106 treat a TREE_VEC as an argument vector. */
14107 parms = copy_node (parms);
14108 for (i = TREE_VEC_LENGTH (parms) - 1; i >= 0; --i)
14109 TREE_VEC_ELT (parms, i) =
14110 tsubst (TREE_VEC_ELT (parms, i), outer_args, tf_none, NULL_TREE);
14112 --processing_template_decl;
14114 spec_args = get_class_bindings (parms,
14120 spec_args = add_to_template_args (outer_args, spec_args);
14121 list = tree_cons (spec_args, TREE_VALUE (t), list);
14122 TREE_TYPE (list) = TREE_TYPE (t);
14129 ambiguous_p = false;
14132 t = TREE_CHAIN (t);
14133 for (; t; t = TREE_CHAIN (t))
14135 fate = more_specialized_class (champ, t);
14142 t = TREE_CHAIN (t);
14145 ambiguous_p = true;
14154 for (t = list; t && t != champ; t = TREE_CHAIN (t))
14156 fate = more_specialized_class (champ, t);
14159 ambiguous_p = true;
14166 const char *str = "candidates are:";
14167 error ("ambiguous class template instantiation for %q#T", type);
14168 for (t = list; t; t = TREE_CHAIN (t))
14170 error ("%s %+#T", str, TREE_TYPE (t));
14173 return error_mark_node;
14179 /* Explicitly instantiate DECL. */
14182 do_decl_instantiation (tree decl, tree storage)
14184 tree result = NULL_TREE;
14187 if (!decl || decl == error_mark_node)
14188 /* An error occurred, for which grokdeclarator has already issued
14189 an appropriate message. */
14191 else if (! DECL_LANG_SPECIFIC (decl))
14193 error ("explicit instantiation of non-template %q#D", decl);
14196 else if (TREE_CODE (decl) == VAR_DECL)
14198 /* There is an asymmetry here in the way VAR_DECLs and
14199 FUNCTION_DECLs are handled by grokdeclarator. In the case of
14200 the latter, the DECL we get back will be marked as a
14201 template instantiation, and the appropriate
14202 DECL_TEMPLATE_INFO will be set up. This does not happen for
14203 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
14204 should handle VAR_DECLs as it currently handles
14206 if (!DECL_CLASS_SCOPE_P (decl))
14208 error ("%qD is not a static data member of a class template", decl);
14211 result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false);
14212 if (!result || TREE_CODE (result) != VAR_DECL)
14214 error ("no matching template for %qD found", decl);
14217 if (!same_type_p (TREE_TYPE (result), TREE_TYPE (decl)))
14219 error ("type %qT for explicit instantiation %qD does not match "
14220 "declared type %qT", TREE_TYPE (result), decl,
14225 else if (TREE_CODE (decl) != FUNCTION_DECL)
14227 error ("explicit instantiation of %q#D", decl);
14233 /* Check for various error cases. Note that if the explicit
14234 instantiation is valid the RESULT will currently be marked as an
14235 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
14236 until we get here. */
14238 if (DECL_TEMPLATE_SPECIALIZATION (result))
14240 /* DR 259 [temp.spec].
14242 Both an explicit instantiation and a declaration of an explicit
14243 specialization shall not appear in a program unless the explicit
14244 instantiation follows a declaration of the explicit specialization.
14246 For a given set of template parameters, if an explicit
14247 instantiation of a template appears after a declaration of an
14248 explicit specialization for that template, the explicit
14249 instantiation has no effect. */
14252 else if (DECL_EXPLICIT_INSTANTIATION (result))
14256 No program shall explicitly instantiate any template more
14259 We check DECL_NOT_REALLY_EXTERN so as not to complain when
14260 the first instantiation was `extern' and the second is not,
14261 and EXTERN_P for the opposite case. */
14262 if (DECL_NOT_REALLY_EXTERN (result) && !extern_p)
14263 pedwarn ("duplicate explicit instantiation of %q#D", result);
14264 /* If an "extern" explicit instantiation follows an ordinary
14265 explicit instantiation, the template is instantiated. */
14269 else if (!DECL_IMPLICIT_INSTANTIATION (result))
14271 error ("no matching template for %qD found", result);
14274 else if (!DECL_TEMPLATE_INFO (result))
14276 pedwarn ("explicit instantiation of non-template %q#D", result);
14280 if (storage == NULL_TREE)
14282 else if (storage == ridpointers[(int) RID_EXTERN])
14284 if (pedantic && !in_system_header)
14285 pedwarn ("ISO C++ forbids the use of %<extern%> on explicit "
14290 error ("storage class %qD applied to template instantiation", storage);
14292 check_explicit_instantiation_namespace (result);
14293 mark_decl_instantiated (result, extern_p);
14295 instantiate_decl (result, /*defer_ok=*/1,
14296 /*expl_inst_class_mem_p=*/false);
14300 mark_class_instantiated (tree t, int extern_p)
14302 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
14303 SET_CLASSTYPE_INTERFACE_KNOWN (t);
14304 CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
14305 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
14308 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
14309 rest_of_type_compilation (t, 1);
14313 /* Called from do_type_instantiation through binding_table_foreach to
14314 do recursive instantiation for the type bound in ENTRY. */
14316 bt_instantiate_type_proc (binding_entry entry, void *data)
14318 tree storage = *(tree *) data;
14320 if (MAYBE_CLASS_TYPE_P (entry->type)
14321 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type)))
14322 do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0);
14325 /* Called from do_type_instantiation to instantiate a member
14326 (a member function or a static member variable) of an
14327 explicitly instantiated class template. */
14329 instantiate_class_member (tree decl, int extern_p)
14331 mark_decl_instantiated (decl, extern_p);
14333 instantiate_decl (decl, /*defer_ok=*/1,
14334 /*expl_inst_class_mem_p=*/true);
14337 /* Perform an explicit instantiation of template class T. STORAGE, if
14338 non-null, is the RID for extern, inline or static. COMPLAIN is
14339 nonzero if this is called from the parser, zero if called recursively,
14340 since the standard is unclear (as detailed below). */
14343 do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
14348 int previous_instantiation_extern_p = 0;
14350 if (TREE_CODE (t) == TYPE_DECL)
14353 if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t))
14355 error ("explicit instantiation of non-template type %qT", t);
14361 if (!COMPLETE_TYPE_P (t))
14363 if (complain & tf_error)
14364 error ("explicit instantiation of %q#T before definition of template",
14369 if (storage != NULL_TREE)
14371 if (pedantic && !in_system_header)
14372 pedwarn("ISO C++ forbids the use of %qE on explicit instantiations",
14375 if (storage == ridpointers[(int) RID_INLINE])
14377 else if (storage == ridpointers[(int) RID_EXTERN])
14379 else if (storage == ridpointers[(int) RID_STATIC])
14383 error ("storage class %qD applied to template instantiation",
14389 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
14391 /* DR 259 [temp.spec].
14393 Both an explicit instantiation and a declaration of an explicit
14394 specialization shall not appear in a program unless the explicit
14395 instantiation follows a declaration of the explicit specialization.
14397 For a given set of template parameters, if an explicit
14398 instantiation of a template appears after a declaration of an
14399 explicit specialization for that template, the explicit
14400 instantiation has no effect. */
14403 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t))
14407 No program shall explicitly instantiate any template more
14410 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
14411 instantiation was `extern'. If EXTERN_P then the second is.
14412 These cases are OK. */
14413 previous_instantiation_extern_p = CLASSTYPE_INTERFACE_ONLY (t);
14415 if (!previous_instantiation_extern_p && !extern_p
14416 && (complain & tf_error))
14417 pedwarn ("duplicate explicit instantiation of %q#T", t);
14419 /* If we've already instantiated the template, just return now. */
14420 if (!CLASSTYPE_INTERFACE_ONLY (t))
14424 check_explicit_instantiation_namespace (TYPE_NAME (t));
14425 mark_class_instantiated (t, extern_p);
14433 /* In contrast to implicit instantiation, where only the
14434 declarations, and not the definitions, of members are
14435 instantiated, we have here:
14439 The explicit instantiation of a class template specialization
14440 implies the instantiation of all of its members not
14441 previously explicitly specialized in the translation unit
14442 containing the explicit instantiation.
14444 Of course, we can't instantiate member template classes, since
14445 we don't have any arguments for them. Note that the standard
14446 is unclear on whether the instantiation of the members are
14447 *explicit* instantiations or not. However, the most natural
14448 interpretation is that it should be an explicit instantiation. */
14451 for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp))
14452 if (TREE_CODE (tmp) == FUNCTION_DECL
14453 && DECL_TEMPLATE_INSTANTIATION (tmp))
14454 instantiate_class_member (tmp, extern_p);
14456 for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp))
14457 if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp))
14458 instantiate_class_member (tmp, extern_p);
14460 if (CLASSTYPE_NESTED_UTDS (t))
14461 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t),
14462 bt_instantiate_type_proc, &storage);
14466 /* Given a function DECL, which is a specialization of TMPL, modify
14467 DECL to be a re-instantiation of TMPL with the same template
14468 arguments. TMPL should be the template into which tsubst'ing
14469 should occur for DECL, not the most general template.
14471 One reason for doing this is a scenario like this:
14474 void f(const T&, int i);
14476 void g() { f(3, 7); }
14479 void f(const T& t, const int i) { }
14481 Note that when the template is first instantiated, with
14482 instantiate_template, the resulting DECL will have no name for the
14483 first parameter, and the wrong type for the second. So, when we go
14484 to instantiate the DECL, we regenerate it. */
14487 regenerate_decl_from_template (tree decl, tree tmpl)
14489 /* The arguments used to instantiate DECL, from the most general
14494 args = DECL_TI_ARGS (decl);
14495 code_pattern = DECL_TEMPLATE_RESULT (tmpl);
14497 /* Make sure that we can see identifiers, and compute access
14499 push_access_scope (decl);
14501 if (TREE_CODE (decl) == FUNCTION_DECL)
14509 args_depth = TMPL_ARGS_DEPTH (args);
14510 parms_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
14511 if (args_depth > parms_depth)
14512 args = get_innermost_template_args (args, parms_depth);
14514 specs = tsubst_exception_specification (TREE_TYPE (code_pattern),
14515 args, tf_error, NULL_TREE);
14517 TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl),
14520 /* Merge parameter declarations. */
14521 decl_parm = skip_artificial_parms_for (decl,
14522 DECL_ARGUMENTS (decl));
14524 = skip_artificial_parms_for (code_pattern,
14525 DECL_ARGUMENTS (code_pattern));
14526 while (decl_parm && !FUNCTION_PARAMETER_PACK_P (pattern_parm))
14531 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
14532 DECL_NAME (decl_parm) = DECL_NAME (pattern_parm);
14533 parm_type = tsubst (TREE_TYPE (pattern_parm), args, tf_error,
14535 parm_type = type_decays_to (parm_type);
14536 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
14537 TREE_TYPE (decl_parm) = parm_type;
14538 attributes = DECL_ATTRIBUTES (pattern_parm);
14539 if (DECL_ATTRIBUTES (decl_parm) != attributes)
14541 DECL_ATTRIBUTES (decl_parm) = attributes;
14542 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
14544 decl_parm = TREE_CHAIN (decl_parm);
14545 pattern_parm = TREE_CHAIN (pattern_parm);
14547 /* Merge any parameters that match with the function parameter
14549 if (pattern_parm && FUNCTION_PARAMETER_PACK_P (pattern_parm))
14552 tree expanded_types;
14553 /* Expand the TYPE_PACK_EXPANSION that provides the types for
14554 the parameters in this function parameter pack. */
14555 expanded_types = tsubst_pack_expansion (TREE_TYPE (pattern_parm),
14556 args, tf_error, NULL_TREE);
14557 len = TREE_VEC_LENGTH (expanded_types);
14558 for (i = 0; i < len; i++)
14563 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
14564 /* Rename the parameter to include the index. */
14565 DECL_NAME (decl_parm) =
14566 make_ith_pack_parameter_name (DECL_NAME (pattern_parm), i);
14567 parm_type = TREE_VEC_ELT (expanded_types, i);
14568 parm_type = type_decays_to (parm_type);
14569 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
14570 TREE_TYPE (decl_parm) = parm_type;
14571 attributes = DECL_ATTRIBUTES (pattern_parm);
14572 if (DECL_ATTRIBUTES (decl_parm) != attributes)
14574 DECL_ATTRIBUTES (decl_parm) = attributes;
14575 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
14577 decl_parm = TREE_CHAIN (decl_parm);
14580 /* Merge additional specifiers from the CODE_PATTERN. */
14581 if (DECL_DECLARED_INLINE_P (code_pattern)
14582 && !DECL_DECLARED_INLINE_P (decl))
14583 DECL_DECLARED_INLINE_P (decl) = 1;
14584 if (DECL_INLINE (code_pattern) && !DECL_INLINE (decl))
14585 DECL_INLINE (decl) = 1;
14587 else if (TREE_CODE (decl) == VAR_DECL)
14588 DECL_INITIAL (decl) =
14589 tsubst_expr (DECL_INITIAL (code_pattern), args,
14590 tf_error, DECL_TI_TEMPLATE (decl),
14591 /*integral_constant_expression_p=*/false);
14593 gcc_unreachable ();
14595 pop_access_scope (decl);
14598 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
14599 substituted to get DECL. */
14602 template_for_substitution (tree decl)
14604 tree tmpl = DECL_TI_TEMPLATE (decl);
14606 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
14607 for the instantiation. This is not always the most general
14608 template. Consider, for example:
14611 struct S { template <class U> void f();
14612 template <> void f<int>(); };
14614 and an instantiation of S<double>::f<int>. We want TD to be the
14615 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
14616 while (/* An instantiation cannot have a definition, so we need a
14617 more general template. */
14618 DECL_TEMPLATE_INSTANTIATION (tmpl)
14619 /* We must also deal with friend templates. Given:
14621 template <class T> struct S {
14622 template <class U> friend void f() {};
14625 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
14626 so far as the language is concerned, but that's still
14627 where we get the pattern for the instantiation from. On
14628 other hand, if the definition comes outside the class, say:
14630 template <class T> struct S {
14631 template <class U> friend void f();
14633 template <class U> friend void f() {}
14635 we don't need to look any further. That's what the check for
14636 DECL_INITIAL is for. */
14637 || (TREE_CODE (decl) == FUNCTION_DECL
14638 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl)
14639 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl))))
14641 /* The present template, TD, should not be a definition. If it
14642 were a definition, we should be using it! Note that we
14643 cannot restructure the loop to just keep going until we find
14644 a template with a definition, since that might go too far if
14645 a specialization was declared, but not defined. */
14646 gcc_assert (TREE_CODE (decl) != VAR_DECL
14647 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl)));
14649 /* Fetch the more general template. */
14650 tmpl = DECL_TI_TEMPLATE (tmpl);
14656 /* Produce the definition of D, a _DECL generated from a template. If
14657 DEFER_OK is nonzero, then we don't have to actually do the
14658 instantiation now; we just have to do it sometime. Normally it is
14659 an error if this is an explicit instantiation but D is undefined.
14660 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
14661 explicitly instantiated class template. */
14664 instantiate_decl (tree d, int defer_ok,
14665 bool expl_inst_class_mem_p)
14667 tree tmpl = DECL_TI_TEMPLATE (d);
14674 bool pattern_defined;
14676 location_t saved_loc = input_location;
14677 int saved_in_system_header = in_system_header;
14680 /* This function should only be used to instantiate templates for
14681 functions and static member variables. */
14682 gcc_assert (TREE_CODE (d) == FUNCTION_DECL
14683 || TREE_CODE (d) == VAR_DECL);
14685 /* Variables are never deferred; if instantiation is required, they
14686 are instantiated right away. That allows for better code in the
14687 case that an expression refers to the value of the variable --
14688 if the variable has a constant value the referring expression can
14689 take advantage of that fact. */
14690 if (TREE_CODE (d) == VAR_DECL)
14693 /* Don't instantiate cloned functions. Instead, instantiate the
14694 functions they cloned. */
14695 if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d))
14696 d = DECL_CLONED_FUNCTION (d);
14698 if (DECL_TEMPLATE_INSTANTIATED (d))
14699 /* D has already been instantiated. It might seem reasonable to
14700 check whether or not D is an explicit instantiation, and, if so,
14701 stop here. But when an explicit instantiation is deferred
14702 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
14703 is set, even though we still need to do the instantiation. */
14706 /* If we already have a specialization of this declaration, then
14707 there's no reason to instantiate it. Note that
14708 retrieve_specialization gives us both instantiations and
14709 specializations, so we must explicitly check
14710 DECL_TEMPLATE_SPECIALIZATION. */
14711 gen_tmpl = most_general_template (tmpl);
14712 gen_args = DECL_TI_ARGS (d);
14713 spec = retrieve_specialization (gen_tmpl, gen_args,
14714 /*class_specializations_p=*/false);
14715 if (spec != NULL_TREE && DECL_TEMPLATE_SPECIALIZATION (spec))
14718 /* This needs to happen before any tsubsting. */
14719 if (! push_tinst_level (d))
14722 timevar_push (TV_PARSE);
14724 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
14725 for the instantiation. */
14726 td = template_for_substitution (d);
14727 code_pattern = DECL_TEMPLATE_RESULT (td);
14729 /* We should never be trying to instantiate a member of a class
14730 template or partial specialization. */
14731 gcc_assert (d != code_pattern);
14733 if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d))
14734 || DECL_TEMPLATE_SPECIALIZATION (td))
14735 /* In the case of a friend template whose definition is provided
14736 outside the class, we may have too many arguments. Drop the
14737 ones we don't need. The same is true for specializations. */
14738 args = get_innermost_template_args
14739 (gen_args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td)));
14743 if (TREE_CODE (d) == FUNCTION_DECL)
14744 pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE);
14746 pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
14748 /* We may be in the middle of deferred access check. Disable it now. */
14749 push_deferring_access_checks (dk_no_deferred);
14751 /* Unless an explicit instantiation directive has already determined
14752 the linkage of D, remember that a definition is available for
14754 if (pattern_defined
14755 && !DECL_INTERFACE_KNOWN (d)
14756 && !DECL_NOT_REALLY_EXTERN (d))
14757 mark_definable (d);
14759 input_location = DECL_SOURCE_LOCATION (d);
14760 in_system_header = DECL_IN_SYSTEM_HEADER (d);
14762 /* If D is a member of an explicitly instantiated class template,
14763 and no definition is available, treat it like an implicit
14765 if (!pattern_defined && expl_inst_class_mem_p
14766 && DECL_EXPLICIT_INSTANTIATION (d))
14768 DECL_NOT_REALLY_EXTERN (d) = 0;
14769 DECL_INTERFACE_KNOWN (d) = 0;
14770 SET_DECL_IMPLICIT_INSTANTIATION (d);
14775 /* Recheck the substitutions to obtain any warning messages
14776 about ignoring cv qualifiers. */
14777 tree gen = DECL_TEMPLATE_RESULT (gen_tmpl);
14778 tree type = TREE_TYPE (gen);
14780 /* Make sure that we can see identifiers, and compute access
14781 correctly. D is already the target FUNCTION_DECL with the
14783 push_access_scope (d);
14785 if (TREE_CODE (gen) == FUNCTION_DECL)
14787 tsubst (DECL_ARGUMENTS (gen), gen_args, tf_warning_or_error, d);
14788 tsubst_exception_specification (type, gen_args, tf_warning_or_error,
14790 /* Don't simply tsubst the function type, as that will give
14791 duplicate warnings about poor parameter qualifications.
14792 The function arguments are the same as the decl_arguments
14793 without the top level cv qualifiers. */
14794 type = TREE_TYPE (type);
14796 tsubst (type, gen_args, tf_warning_or_error, d);
14798 pop_access_scope (d);
14801 /* Check to see whether we know that this template will be
14802 instantiated in some other file, as with "extern template"
14804 external_p = (DECL_INTERFACE_KNOWN (d) && DECL_REALLY_EXTERN (d));
14805 /* In general, we do not instantiate such templates... */
14807 /* ... but we instantiate inline functions so that we can inline
14809 && ! (TREE_CODE (d) == FUNCTION_DECL && DECL_INLINE (d))
14810 /* ... we instantiate static data members whose values are
14811 needed in integral constant expressions. */
14812 && ! (TREE_CODE (d) == VAR_DECL
14813 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (d)))
14815 /* Defer all other templates, unless we have been explicitly
14816 forbidden from doing so. */
14817 if (/* If there is no definition, we cannot instantiate the
14820 /* If it's OK to postpone instantiation, do so. */
14822 /* If this is a static data member that will be defined
14823 elsewhere, we don't want to instantiate the entire data
14824 member, but we do want to instantiate the initializer so that
14825 we can substitute that elsewhere. */
14826 || (external_p && TREE_CODE (d) == VAR_DECL))
14828 /* The definition of the static data member is now required so
14829 we must substitute the initializer. */
14830 if (TREE_CODE (d) == VAR_DECL
14831 && !DECL_INITIAL (d)
14832 && DECL_INITIAL (code_pattern))
14837 ns = decl_namespace_context (d);
14838 push_nested_namespace (ns);
14839 push_nested_class (DECL_CONTEXT (d));
14840 init = tsubst_expr (DECL_INITIAL (code_pattern),
14842 tf_warning_or_error, NULL_TREE,
14843 /*integral_constant_expression_p=*/false);
14844 cp_finish_decl (d, init, /*init_const_expr_p=*/false,
14845 /*asmspec_tree=*/NULL_TREE,
14846 LOOKUP_ONLYCONVERTING);
14847 pop_nested_class ();
14848 pop_nested_namespace (ns);
14851 /* We restore the source position here because it's used by
14852 add_pending_template. */
14853 input_location = saved_loc;
14855 if (at_eof && !pattern_defined
14856 && DECL_EXPLICIT_INSTANTIATION (d))
14859 The definition of a non-exported function template, a
14860 non-exported member function template, or a non-exported
14861 member function or static data member of a class template
14862 shall be present in every translation unit in which it is
14863 explicitly instantiated. */
14865 ("explicit instantiation of %qD but no definition available", d);
14867 /* ??? Historically, we have instantiated inline functions, even
14868 when marked as "extern template". */
14869 if (!(external_p && TREE_CODE (d) == VAR_DECL))
14870 add_pending_template (d);
14873 /* Tell the repository that D is available in this translation unit
14874 -- and see if it is supposed to be instantiated here. */
14875 if (TREE_PUBLIC (d) && !DECL_REALLY_EXTERN (d) && !repo_emit_p (d))
14877 /* In a PCH file, despite the fact that the repository hasn't
14878 requested instantiation in the PCH it is still possible that
14879 an instantiation will be required in a file that includes the
14882 add_pending_template (d);
14883 /* Instantiate inline functions so that the inliner can do its
14884 job, even though we'll not be emitting a copy of this
14886 if (!(TREE_CODE (d) == FUNCTION_DECL
14887 && flag_inline_trees
14888 && DECL_DECLARED_INLINE_P (d)))
14892 need_push = !cfun || !global_bindings_p ();
14894 push_to_top_level ();
14896 /* Mark D as instantiated so that recursive calls to
14897 instantiate_decl do not try to instantiate it again. */
14898 DECL_TEMPLATE_INSTANTIATED (d) = 1;
14900 /* Regenerate the declaration in case the template has been modified
14901 by a subsequent redeclaration. */
14902 regenerate_decl_from_template (d, td);
14904 /* We already set the file and line above. Reset them now in case
14905 they changed as a result of calling regenerate_decl_from_template. */
14906 input_location = DECL_SOURCE_LOCATION (d);
14908 if (TREE_CODE (d) == VAR_DECL)
14912 /* Clear out DECL_RTL; whatever was there before may not be right
14913 since we've reset the type of the declaration. */
14914 SET_DECL_RTL (d, NULL_RTX);
14915 DECL_IN_AGGR_P (d) = 0;
14917 /* The initializer is placed in DECL_INITIAL by
14918 regenerate_decl_from_template. Pull it out so that
14919 finish_decl can process it. */
14920 init = DECL_INITIAL (d);
14921 DECL_INITIAL (d) = NULL_TREE;
14922 DECL_INITIALIZED_P (d) = 0;
14924 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
14925 initializer. That function will defer actual emission until
14926 we have a chance to determine linkage. */
14927 DECL_EXTERNAL (d) = 0;
14929 /* Enter the scope of D so that access-checking works correctly. */
14930 push_nested_class (DECL_CONTEXT (d));
14931 finish_decl (d, init, NULL_TREE);
14932 pop_nested_class ();
14934 else if (TREE_CODE (d) == FUNCTION_DECL)
14936 htab_t saved_local_specializations;
14941 /* Save away the current list, in case we are instantiating one
14942 template from within the body of another. */
14943 saved_local_specializations = local_specializations;
14945 /* Set up the list of local specializations. */
14946 local_specializations = htab_create (37,
14947 hash_local_specialization,
14948 eq_local_specializations,
14951 /* Set up context. */
14952 start_preparsed_function (d, NULL_TREE, SF_PRE_PARSED);
14954 /* Create substitution entries for the parameters. */
14955 subst_decl = DECL_TEMPLATE_RESULT (template_for_substitution (d));
14956 tmpl_parm = DECL_ARGUMENTS (subst_decl);
14957 spec_parm = DECL_ARGUMENTS (d);
14958 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d))
14960 register_local_specialization (spec_parm, tmpl_parm);
14961 spec_parm = skip_artificial_parms_for (d, spec_parm);
14962 tmpl_parm = skip_artificial_parms_for (subst_decl, tmpl_parm);
14964 while (tmpl_parm && !FUNCTION_PARAMETER_PACK_P (tmpl_parm))
14966 register_local_specialization (spec_parm, tmpl_parm);
14967 tmpl_parm = TREE_CHAIN (tmpl_parm);
14968 spec_parm = TREE_CHAIN (spec_parm);
14970 if (tmpl_parm && FUNCTION_PARAMETER_PACK_P (tmpl_parm))
14972 /* Collect all of the extra "packed" parameters into an
14976 tree argpack = make_node (NONTYPE_ARGUMENT_PACK);
14977 tree argtypepack = make_node (TYPE_ARGUMENT_PACK);
14981 /* Count how many parameters remain. */
14982 for (t = spec_parm; t; t = TREE_CHAIN (t))
14985 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
14986 parmvec = make_tree_vec (len);
14987 parmtypevec = make_tree_vec (len);
14988 for(i = 0; i < len; i++, spec_parm = TREE_CHAIN (spec_parm))
14990 TREE_VEC_ELT (parmvec, i) = spec_parm;
14991 TREE_VEC_ELT (parmtypevec, i) = TREE_TYPE (spec_parm);
14994 /* Build the argument packs. */
14995 SET_ARGUMENT_PACK_ARGS (argpack, parmvec);
14996 SET_ARGUMENT_PACK_ARGS (argtypepack, parmtypevec);
14997 TREE_TYPE (argpack) = argtypepack;
14999 /* Register the (value) argument pack as a specialization of
15000 TMPL_PARM, then move on. */
15001 register_local_specialization (argpack, tmpl_parm);
15002 tmpl_parm = TREE_CHAIN (tmpl_parm);
15004 gcc_assert (!spec_parm);
15006 /* Substitute into the body of the function. */
15007 tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
15008 tf_warning_or_error, tmpl,
15009 /*integral_constant_expression_p=*/false);
15011 /* Set the current input_location to the end of the function
15012 so that finish_function knows where we are. */
15013 input_location = DECL_STRUCT_FUNCTION (code_pattern)->function_end_locus;
15015 /* We don't need the local specializations any more. */
15016 htab_delete (local_specializations);
15017 local_specializations = saved_local_specializations;
15019 /* Finish the function. */
15020 d = finish_function (0);
15021 expand_or_defer_fn (d);
15024 /* We're not deferring instantiation any more. */
15025 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
15028 pop_from_top_level ();
15031 input_location = saved_loc;
15032 in_system_header = saved_in_system_header;
15033 pop_deferring_access_checks ();
15034 pop_tinst_level ();
15036 timevar_pop (TV_PARSE);
15041 /* Run through the list of templates that we wish we could
15042 instantiate, and instantiate any we can. RETRIES is the
15043 number of times we retry pending template instantiation. */
15046 instantiate_pending_templates (int retries)
15049 location_t saved_loc = input_location;
15050 int saved_in_system_header = in_system_header;
15052 /* Instantiating templates may trigger vtable generation. This in turn
15053 may require further template instantiations. We place a limit here
15054 to avoid infinite loop. */
15055 if (pending_templates && retries >= max_tinst_depth)
15057 tree decl = pending_templates->tinst->decl;
15059 error ("template instantiation depth exceeds maximum of %d"
15060 " instantiating %q+D, possibly from virtual table generation"
15061 " (use -ftemplate-depth-NN to increase the maximum)",
15062 max_tinst_depth, decl);
15063 if (TREE_CODE (decl) == FUNCTION_DECL)
15064 /* Pretend that we defined it. */
15065 DECL_INITIAL (decl) = error_mark_node;
15071 struct pending_template **t = &pending_templates;
15072 struct pending_template *last = NULL;
15076 tree instantiation = reopen_tinst_level ((*t)->tinst);
15077 bool complete = false;
15079 if (TYPE_P (instantiation))
15083 if (!COMPLETE_TYPE_P (instantiation))
15085 instantiate_class_template (instantiation);
15086 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
15087 for (fn = TYPE_METHODS (instantiation);
15089 fn = TREE_CHAIN (fn))
15090 if (! DECL_ARTIFICIAL (fn))
15091 instantiate_decl (fn,
15093 /*expl_inst_class_mem_p=*/false);
15094 if (COMPLETE_TYPE_P (instantiation))
15098 complete = COMPLETE_TYPE_P (instantiation);
15102 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation)
15103 && !DECL_TEMPLATE_INSTANTIATED (instantiation))
15106 = instantiate_decl (instantiation,
15108 /*expl_inst_class_mem_p=*/false);
15109 if (DECL_TEMPLATE_INSTANTIATED (instantiation))
15113 complete = (DECL_TEMPLATE_SPECIALIZATION (instantiation)
15114 || DECL_TEMPLATE_INSTANTIATED (instantiation));
15118 /* If INSTANTIATION has been instantiated, then we don't
15119 need to consider it again in the future. */
15127 current_tinst_level = NULL;
15129 last_pending_template = last;
15131 while (reconsider);
15133 input_location = saved_loc;
15134 in_system_header = saved_in_system_header;
15137 /* Substitute ARGVEC into T, which is a list of initializers for
15138 either base class or a non-static data member. The TREE_PURPOSEs
15139 are DECLs, and the TREE_VALUEs are the initializer values. Used by
15140 instantiate_decl. */
15143 tsubst_initializer_list (tree t, tree argvec)
15145 tree inits = NULL_TREE;
15147 for (; t; t = TREE_CHAIN (t))
15151 tree expanded_bases = NULL_TREE;
15152 tree expanded_arguments = NULL_TREE;
15155 if (TREE_CODE (TREE_PURPOSE (t)) == TYPE_PACK_EXPANSION)
15160 /* Expand the base class expansion type into separate base
15162 expanded_bases = tsubst_pack_expansion (TREE_PURPOSE (t), argvec,
15163 tf_warning_or_error,
15165 if (expanded_bases == error_mark_node)
15168 /* We'll be building separate TREE_LISTs of arguments for
15170 len = TREE_VEC_LENGTH (expanded_bases);
15171 expanded_arguments = make_tree_vec (len);
15172 for (i = 0; i < len; i++)
15173 TREE_VEC_ELT (expanded_arguments, i) = NULL_TREE;
15175 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
15176 expand each argument in the TREE_VALUE of t. */
15177 expr = make_node (EXPR_PACK_EXPANSION);
15178 PACK_EXPANSION_PARAMETER_PACKS (expr) =
15179 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t));
15181 if (TREE_VALUE (t) == void_type_node)
15182 /* VOID_TYPE_NODE is used to indicate
15183 value-initialization. */
15185 for (i = 0; i < len; i++)
15186 TREE_VEC_ELT (expanded_arguments, i) = void_type_node;
15190 /* Substitute parameter packs into each argument in the
15192 in_base_initializer = 1;
15193 for (arg = TREE_VALUE (t); arg; arg = TREE_CHAIN (arg))
15195 tree expanded_exprs;
15197 /* Expand the argument. */
15198 SET_PACK_EXPANSION_PATTERN (expr, TREE_VALUE (arg));
15200 = tsubst_pack_expansion (expr, argvec,
15201 tf_warning_or_error,
15204 /* Prepend each of the expanded expressions to the
15205 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
15206 for (i = 0; i < len; i++)
15208 TREE_VEC_ELT (expanded_arguments, i) =
15209 tree_cons (NULL_TREE,
15210 TREE_VEC_ELT (expanded_exprs, i),
15211 TREE_VEC_ELT (expanded_arguments, i));
15214 in_base_initializer = 0;
15216 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
15217 since we built them backwards. */
15218 for (i = 0; i < len; i++)
15220 TREE_VEC_ELT (expanded_arguments, i) =
15221 nreverse (TREE_VEC_ELT (expanded_arguments, i));
15226 for (i = 0; i < len; ++i)
15228 if (expanded_bases)
15230 decl = TREE_VEC_ELT (expanded_bases, i);
15231 decl = expand_member_init (decl);
15232 init = TREE_VEC_ELT (expanded_arguments, i);
15236 decl = tsubst_copy (TREE_PURPOSE (t), argvec,
15237 tf_warning_or_error, NULL_TREE);
15239 decl = expand_member_init (decl);
15240 if (decl && !DECL_P (decl))
15241 in_base_initializer = 1;
15243 init = tsubst_expr (TREE_VALUE (t), argvec,
15244 tf_warning_or_error, NULL_TREE,
15245 /*integral_constant_expression_p=*/false);
15246 in_base_initializer = 0;
15251 init = build_tree_list (decl, init);
15252 TREE_CHAIN (init) = inits;
15260 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
15263 set_current_access_from_decl (tree decl)
15265 if (TREE_PRIVATE (decl))
15266 current_access_specifier = access_private_node;
15267 else if (TREE_PROTECTED (decl))
15268 current_access_specifier = access_protected_node;
15270 current_access_specifier = access_public_node;
15273 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
15274 is the instantiation (which should have been created with
15275 start_enum) and ARGS are the template arguments to use. */
15278 tsubst_enum (tree tag, tree newtag, tree args)
15282 for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
15287 decl = TREE_VALUE (e);
15288 /* Note that in a template enum, the TREE_VALUE is the
15289 CONST_DECL, not the corresponding INTEGER_CST. */
15290 value = tsubst_expr (DECL_INITIAL (decl),
15291 args, tf_warning_or_error, NULL_TREE,
15292 /*integral_constant_expression_p=*/true);
15294 /* Give this enumeration constant the correct access. */
15295 set_current_access_from_decl (decl);
15297 /* Actually build the enumerator itself. */
15298 build_enumerator (DECL_NAME (decl), value, newtag);
15301 finish_enum (newtag);
15302 DECL_SOURCE_LOCATION (TYPE_NAME (newtag))
15303 = DECL_SOURCE_LOCATION (TYPE_NAME (tag));
15306 /* DECL is a FUNCTION_DECL that is a template specialization. Return
15307 its type -- but without substituting the innermost set of template
15308 arguments. So, innermost set of template parameters will appear in
15312 get_mostly_instantiated_function_type (tree decl)
15320 tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
15321 targs = DECL_TI_ARGS (decl);
15322 tparms = DECL_TEMPLATE_PARMS (tmpl);
15323 parm_depth = TMPL_PARMS_DEPTH (tparms);
15325 /* There should be as many levels of arguments as there are levels
15327 gcc_assert (parm_depth == TMPL_ARGS_DEPTH (targs));
15329 fn_type = TREE_TYPE (tmpl);
15331 if (parm_depth == 1)
15332 /* No substitution is necessary. */
15336 int i, save_access_control;
15339 /* Replace the innermost level of the TARGS with NULL_TREEs to
15340 let tsubst know not to substitute for those parameters. */
15341 partial_args = make_tree_vec (TREE_VEC_LENGTH (targs));
15342 for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i)
15343 SET_TMPL_ARGS_LEVEL (partial_args, i,
15344 TMPL_ARGS_LEVEL (targs, i));
15345 SET_TMPL_ARGS_LEVEL (partial_args,
15346 TMPL_ARGS_DEPTH (targs),
15347 make_tree_vec (DECL_NTPARMS (tmpl)));
15349 /* Disable access control as this function is used only during
15351 save_access_control = flag_access_control;
15352 flag_access_control = 0;
15354 ++processing_template_decl;
15355 /* Now, do the (partial) substitution to figure out the
15356 appropriate function type. */
15357 fn_type = tsubst (fn_type, partial_args, tf_error, NULL_TREE);
15358 --processing_template_decl;
15360 /* Substitute into the template parameters to obtain the real
15361 innermost set of parameters. This step is important if the
15362 innermost set of template parameters contains value
15363 parameters whose types depend on outer template parameters. */
15364 TREE_VEC_LENGTH (partial_args)--;
15365 tparms = tsubst_template_parms (tparms, partial_args, tf_error);
15367 flag_access_control = save_access_control;
15373 /* Return truthvalue if we're processing a template different from
15374 the last one involved in diagnostics. */
15376 problematic_instantiation_changed (void)
15378 return last_template_error_tick != tinst_level_tick;
15381 /* Remember current template involved in diagnostics. */
15383 record_last_problematic_instantiation (void)
15385 last_template_error_tick = tinst_level_tick;
15388 struct tinst_level *
15389 current_instantiation (void)
15391 return current_tinst_level;
15394 /* [temp.param] Check that template non-type parm TYPE is of an allowable
15395 type. Return zero for ok, nonzero for disallowed. Issue error and
15396 warning messages under control of COMPLAIN. */
15399 invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain)
15401 if (INTEGRAL_TYPE_P (type))
15403 else if (POINTER_TYPE_P (type))
15405 else if (TYPE_PTR_TO_MEMBER_P (type))
15407 else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
15409 else if (TREE_CODE (type) == TYPENAME_TYPE)
15412 if (complain & tf_error)
15413 error ("%q#T is not a valid type for a template constant parameter", type);
15417 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
15418 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
15421 dependent_type_p_r (tree type)
15427 A type is dependent if it is:
15429 -- a template parameter. Template template parameters are types
15430 for us (since TYPE_P holds true for them) so we handle
15432 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
15433 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
15435 /* -- a qualified-id with a nested-name-specifier which contains a
15436 class-name that names a dependent type or whose unqualified-id
15437 names a dependent type. */
15438 if (TREE_CODE (type) == TYPENAME_TYPE)
15440 /* -- a cv-qualified type where the cv-unqualified type is
15442 type = TYPE_MAIN_VARIANT (type);
15443 /* -- a compound type constructed from any dependent type. */
15444 if (TYPE_PTR_TO_MEMBER_P (type))
15445 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type))
15446 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
15448 else if (TREE_CODE (type) == POINTER_TYPE
15449 || TREE_CODE (type) == REFERENCE_TYPE)
15450 return dependent_type_p (TREE_TYPE (type));
15451 else if (TREE_CODE (type) == FUNCTION_TYPE
15452 || TREE_CODE (type) == METHOD_TYPE)
15456 if (dependent_type_p (TREE_TYPE (type)))
15458 for (arg_type = TYPE_ARG_TYPES (type);
15460 arg_type = TREE_CHAIN (arg_type))
15461 if (dependent_type_p (TREE_VALUE (arg_type)))
15465 /* -- an array type constructed from any dependent type or whose
15466 size is specified by a constant expression that is
15467 value-dependent. */
15468 if (TREE_CODE (type) == ARRAY_TYPE)
15470 if (TYPE_DOMAIN (type)
15471 && dependent_type_p (TYPE_DOMAIN (type)))
15473 return dependent_type_p (TREE_TYPE (type));
15475 else if (TREE_CODE (type) == INTEGER_TYPE
15476 && !TREE_CONSTANT (TYPE_MAX_VALUE (type)))
15478 /* If this is the TYPE_DOMAIN of an array type, consider it
15480 return (value_dependent_expression_p (TYPE_MAX_VALUE (type))
15481 || type_dependent_expression_p (TYPE_MAX_VALUE (type)));
15484 /* -- a template-id in which either the template name is a template
15486 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
15488 /* ... or any of the template arguments is a dependent type or
15489 an expression that is type-dependent or value-dependent. */
15490 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
15491 && (any_dependent_template_arguments_p
15492 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
15495 /* All TYPEOF_TYPEs and DECLTYPE_TYPEs are dependent; if the
15496 argument of the `typeof' expression is not type-dependent, then
15497 it should already been have resolved. */
15498 if (TREE_CODE (type) == TYPEOF_TYPE
15499 || TREE_CODE (type) == DECLTYPE_TYPE)
15502 /* A template argument pack is dependent if any of its packed
15504 if (TREE_CODE (type) == TYPE_ARGUMENT_PACK)
15506 tree args = ARGUMENT_PACK_ARGS (type);
15507 int i, len = TREE_VEC_LENGTH (args);
15508 for (i = 0; i < len; ++i)
15509 if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
15513 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
15514 be template parameters. */
15515 if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
15518 /* The standard does not specifically mention types that are local
15519 to template functions or local classes, but they should be
15520 considered dependent too. For example:
15522 template <int I> void f() {
15527 The size of `E' cannot be known until the value of `I' has been
15528 determined. Therefore, `E' must be considered dependent. */
15529 scope = TYPE_CONTEXT (type);
15530 if (scope && TYPE_P (scope))
15531 return dependent_type_p (scope);
15532 else if (scope && TREE_CODE (scope) == FUNCTION_DECL)
15533 return type_dependent_expression_p (scope);
15535 /* Other types are non-dependent. */
15539 /* Returns TRUE if TYPE is dependent, in the sense of
15540 [temp.dep.type]. */
15543 dependent_type_p (tree type)
15545 /* If there are no template parameters in scope, then there can't be
15546 any dependent types. */
15547 if (!processing_template_decl)
15549 /* If we are not processing a template, then nobody should be
15550 providing us with a dependent type. */
15552 gcc_assert (TREE_CODE (type) != TEMPLATE_TYPE_PARM);
15556 /* If the type is NULL, we have not computed a type for the entity
15557 in question; in that case, the type is dependent. */
15561 /* Erroneous types can be considered non-dependent. */
15562 if (type == error_mark_node)
15565 /* If we have not already computed the appropriate value for TYPE,
15567 if (!TYPE_DEPENDENT_P_VALID (type))
15569 TYPE_DEPENDENT_P (type) = dependent_type_p_r (type);
15570 TYPE_DEPENDENT_P_VALID (type) = 1;
15573 return TYPE_DEPENDENT_P (type);
15576 /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
15579 dependent_scope_ref_p (tree expression, bool criterion (tree))
15584 gcc_assert (TREE_CODE (expression) == SCOPE_REF);
15586 if (!TYPE_P (TREE_OPERAND (expression, 0)))
15589 scope = TREE_OPERAND (expression, 0);
15590 name = TREE_OPERAND (expression, 1);
15594 An id-expression is type-dependent if it contains a
15595 nested-name-specifier that contains a class-name that names a
15597 /* The suggested resolution to Core Issue 2 implies that if the
15598 qualifying type is the current class, then we must peek
15601 && currently_open_class (scope)
15602 && !criterion (name))
15604 if (dependent_type_p (scope))
15610 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
15611 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
15615 value_dependent_expression_p (tree expression)
15617 if (!processing_template_decl)
15620 /* A name declared with a dependent type. */
15621 if (DECL_P (expression) && type_dependent_expression_p (expression))
15624 switch (TREE_CODE (expression))
15626 case IDENTIFIER_NODE:
15627 /* A name that has not been looked up -- must be dependent. */
15630 case TEMPLATE_PARM_INDEX:
15631 /* A non-type template parm. */
15635 /* A non-type template parm. */
15636 if (DECL_TEMPLATE_PARM_P (expression))
15638 return value_dependent_expression_p (DECL_INITIAL (expression));
15641 /* A constant with integral or enumeration type and is initialized
15642 with an expression that is value-dependent. */
15643 if (DECL_INITIAL (expression)
15644 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression))
15645 && value_dependent_expression_p (DECL_INITIAL (expression)))
15649 case DYNAMIC_CAST_EXPR:
15650 case STATIC_CAST_EXPR:
15651 case CONST_CAST_EXPR:
15652 case REINTERPRET_CAST_EXPR:
15654 /* These expressions are value-dependent if the type to which
15655 the cast occurs is dependent or the expression being casted
15656 is value-dependent. */
15658 tree type = TREE_TYPE (expression);
15660 if (dependent_type_p (type))
15663 /* A functional cast has a list of operands. */
15664 expression = TREE_OPERAND (expression, 0);
15667 /* If there are no operands, it must be an expression such
15668 as "int()". This should not happen for aggregate types
15669 because it would form non-constant expressions. */
15670 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
15675 if (TREE_CODE (expression) == TREE_LIST)
15676 return any_value_dependent_elements_p (expression);
15678 return value_dependent_expression_p (expression);
15683 /* A `sizeof' expression is value-dependent if the operand is
15684 type-dependent or is a pack expansion. */
15685 expression = TREE_OPERAND (expression, 0);
15686 if (PACK_EXPANSION_P (expression))
15688 else if (TYPE_P (expression))
15689 return dependent_type_p (expression);
15690 return type_dependent_expression_p (expression);
15693 return dependent_scope_ref_p (expression, value_dependent_expression_p);
15695 case COMPONENT_REF:
15696 return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
15697 || value_dependent_expression_p (TREE_OPERAND (expression, 1)));
15700 /* A CALL_EXPR may appear in a constant expression if it is a
15701 call to a builtin function, e.g., __builtin_constant_p. All
15702 such calls are value-dependent. */
15705 case NONTYPE_ARGUMENT_PACK:
15706 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
15707 is value-dependent. */
15709 tree values = ARGUMENT_PACK_ARGS (expression);
15710 int i, len = TREE_VEC_LENGTH (values);
15712 for (i = 0; i < len; ++i)
15713 if (value_dependent_expression_p (TREE_VEC_ELT (values, i)))
15721 tree type2 = TRAIT_EXPR_TYPE2 (expression);
15722 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression))
15723 || (type2 ? dependent_type_p (type2) : false));
15727 return ((value_dependent_expression_p (TREE_OPERAND (expression, 0)))
15728 || (value_dependent_expression_p (TREE_OPERAND (expression, 2))));
15731 /* A constant expression is value-dependent if any subexpression is
15732 value-dependent. */
15733 switch (TREE_CODE_CLASS (TREE_CODE (expression)))
15735 case tcc_reference:
15737 return (value_dependent_expression_p
15738 (TREE_OPERAND (expression, 0)));
15740 case tcc_comparison:
15742 return ((value_dependent_expression_p
15743 (TREE_OPERAND (expression, 0)))
15744 || (value_dependent_expression_p
15745 (TREE_OPERAND (expression, 1))));
15747 case tcc_expression:
15751 for (i = 0; i < TREE_OPERAND_LENGTH (expression); ++i)
15752 /* In some cases, some of the operands may be missing.
15753 (For example, in the case of PREDECREMENT_EXPR, the
15754 amount to increment by may be missing.) That doesn't
15755 make the expression dependent. */
15756 if (TREE_OPERAND (expression, i)
15757 && (value_dependent_expression_p
15758 (TREE_OPERAND (expression, i))))
15768 /* The expression is not value-dependent. */
15772 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
15773 [temp.dep.expr]. */
15776 type_dependent_expression_p (tree expression)
15778 if (!processing_template_decl)
15781 if (expression == error_mark_node)
15784 /* An unresolved name is always dependent. */
15785 if (TREE_CODE (expression) == IDENTIFIER_NODE
15786 || TREE_CODE (expression) == USING_DECL)
15789 /* Some expression forms are never type-dependent. */
15790 if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR
15791 || TREE_CODE (expression) == SIZEOF_EXPR
15792 || TREE_CODE (expression) == ALIGNOF_EXPR
15793 || TREE_CODE (expression) == TRAIT_EXPR
15794 || TREE_CODE (expression) == TYPEID_EXPR
15795 || TREE_CODE (expression) == DELETE_EXPR
15796 || TREE_CODE (expression) == VEC_DELETE_EXPR
15797 || TREE_CODE (expression) == THROW_EXPR)
15800 /* The types of these expressions depends only on the type to which
15801 the cast occurs. */
15802 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
15803 || TREE_CODE (expression) == STATIC_CAST_EXPR
15804 || TREE_CODE (expression) == CONST_CAST_EXPR
15805 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
15806 || TREE_CODE (expression) == CAST_EXPR)
15807 return dependent_type_p (TREE_TYPE (expression));
15809 /* The types of these expressions depends only on the type created
15810 by the expression. */
15811 if (TREE_CODE (expression) == NEW_EXPR
15812 || TREE_CODE (expression) == VEC_NEW_EXPR)
15814 /* For NEW_EXPR tree nodes created inside a template, either
15815 the object type itself or a TREE_LIST may appear as the
15817 tree type = TREE_OPERAND (expression, 1);
15818 if (TREE_CODE (type) == TREE_LIST)
15819 /* This is an array type. We need to check array dimensions
15821 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type)))
15822 || value_dependent_expression_p
15823 (TREE_OPERAND (TREE_VALUE (type), 1));
15825 return dependent_type_p (type);
15828 if (TREE_CODE (expression) == SCOPE_REF
15829 && dependent_scope_ref_p (expression,
15830 type_dependent_expression_p))
15833 if (TREE_CODE (expression) == FUNCTION_DECL
15834 && DECL_LANG_SPECIFIC (expression)
15835 && DECL_TEMPLATE_INFO (expression)
15836 && (any_dependent_template_arguments_p
15837 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
15840 if (TREE_CODE (expression) == TEMPLATE_DECL
15841 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression))
15844 if (TREE_CODE (expression) == STMT_EXPR)
15845 expression = stmt_expr_value_expr (expression);
15847 if (TREE_TYPE (expression) == unknown_type_node)
15849 if (TREE_CODE (expression) == ADDR_EXPR)
15850 return type_dependent_expression_p (TREE_OPERAND (expression, 0));
15851 if (TREE_CODE (expression) == COMPONENT_REF
15852 || TREE_CODE (expression) == OFFSET_REF)
15854 if (type_dependent_expression_p (TREE_OPERAND (expression, 0)))
15856 expression = TREE_OPERAND (expression, 1);
15857 if (TREE_CODE (expression) == IDENTIFIER_NODE)
15860 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
15861 if (TREE_CODE (expression) == SCOPE_REF)
15864 if (TREE_CODE (expression) == BASELINK)
15865 expression = BASELINK_FUNCTIONS (expression);
15867 if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
15869 if (any_dependent_template_arguments_p
15870 (TREE_OPERAND (expression, 1)))
15872 expression = TREE_OPERAND (expression, 0);
15874 gcc_assert (TREE_CODE (expression) == OVERLOAD
15875 || TREE_CODE (expression) == FUNCTION_DECL);
15879 if (type_dependent_expression_p (OVL_CURRENT (expression)))
15881 expression = OVL_NEXT (expression);
15886 gcc_assert (TREE_CODE (expression) != TYPE_DECL);
15888 return (dependent_type_p (TREE_TYPE (expression)));
15891 /* Returns TRUE if ARGS (a TREE_LIST of arguments to a function call)
15892 contains a type-dependent expression. */
15895 any_type_dependent_arguments_p (const_tree args)
15899 tree arg = TREE_VALUE (args);
15901 if (type_dependent_expression_p (arg))
15903 args = TREE_CHAIN (args);
15908 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
15909 expressions) contains any value-dependent expressions. */
15912 any_value_dependent_elements_p (const_tree list)
15914 for (; list; list = TREE_CHAIN (list))
15915 if (value_dependent_expression_p (TREE_VALUE (list)))
15921 /* Returns TRUE if the ARG (a template argument) is dependent. */
15924 dependent_template_arg_p (tree arg)
15926 if (!processing_template_decl)
15929 if (TREE_CODE (arg) == TEMPLATE_DECL
15930 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
15931 return dependent_template_p (arg);
15932 else if (ARGUMENT_PACK_P (arg))
15934 tree args = ARGUMENT_PACK_ARGS (arg);
15935 int i, len = TREE_VEC_LENGTH (args);
15936 for (i = 0; i < len; ++i)
15938 if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
15944 else if (TYPE_P (arg))
15945 return dependent_type_p (arg);
15947 return (type_dependent_expression_p (arg)
15948 || value_dependent_expression_p (arg));
15951 /* Returns true if ARGS (a collection of template arguments) contains
15952 any types that require structural equality testing. */
15955 any_template_arguments_need_structural_equality_p (tree args)
15962 if (args == error_mark_node)
15965 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
15967 tree level = TMPL_ARGS_LEVEL (args, i + 1);
15968 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
15970 tree arg = TREE_VEC_ELT (level, j);
15971 tree packed_args = NULL_TREE;
15974 if (ARGUMENT_PACK_P (arg))
15976 /* Look inside the argument pack. */
15977 packed_args = ARGUMENT_PACK_ARGS (arg);
15978 len = TREE_VEC_LENGTH (packed_args);
15981 for (k = 0; k < len; ++k)
15984 arg = TREE_VEC_ELT (packed_args, k);
15986 if (error_operand_p (arg))
15988 else if (TREE_CODE (arg) == TEMPLATE_DECL
15989 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
15991 else if (TYPE_P (arg) && TYPE_STRUCTURAL_EQUALITY_P (arg))
15993 else if (!TYPE_P (arg) && TREE_TYPE (arg)
15994 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg)))
16003 /* Returns true if ARGS (a collection of template arguments) contains
16004 any dependent arguments. */
16007 any_dependent_template_arguments_p (const_tree args)
16014 if (args == error_mark_node)
16017 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
16019 const_tree level = TMPL_ARGS_LEVEL (args, i + 1);
16020 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
16021 if (dependent_template_arg_p (TREE_VEC_ELT (level, j)))
16028 /* Returns TRUE if the template TMPL is dependent. */
16031 dependent_template_p (tree tmpl)
16033 if (TREE_CODE (tmpl) == OVERLOAD)
16037 if (dependent_template_p (OVL_FUNCTION (tmpl)))
16039 tmpl = OVL_CHAIN (tmpl);
16044 /* Template template parameters are dependent. */
16045 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
16046 || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
16048 /* So are names that have not been looked up. */
16049 if (TREE_CODE (tmpl) == SCOPE_REF
16050 || TREE_CODE (tmpl) == IDENTIFIER_NODE)
16052 /* So are member templates of dependent classes. */
16053 if (TYPE_P (CP_DECL_CONTEXT (tmpl)))
16054 return dependent_type_p (DECL_CONTEXT (tmpl));
16058 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
16061 dependent_template_id_p (tree tmpl, tree args)
16063 return (dependent_template_p (tmpl)
16064 || any_dependent_template_arguments_p (args));
16067 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
16068 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
16069 no such TYPE can be found. Note that this function peers inside
16070 uninstantiated templates and therefore should be used only in
16071 extremely limited situations. ONLY_CURRENT_P restricts this
16072 peering to the currently open classes hierarchy (which is required
16073 when comparing types). */
16076 resolve_typename_type (tree type, bool only_current_p)
16085 gcc_assert (TREE_CODE (type) == TYPENAME_TYPE);
16087 scope = TYPE_CONTEXT (type);
16088 name = TYPE_IDENTIFIER (type);
16090 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
16091 it first before we can figure out what NAME refers to. */
16092 if (TREE_CODE (scope) == TYPENAME_TYPE)
16093 scope = resolve_typename_type (scope, only_current_p);
16094 /* If we don't know what SCOPE refers to, then we cannot resolve the
16096 if (TREE_CODE (scope) == TYPENAME_TYPE)
16098 /* If the SCOPE is a template type parameter, we have no way of
16099 resolving the name. */
16100 if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
16102 /* If the SCOPE is not the current instantiation, there's no reason
16103 to look inside it. */
16104 if (only_current_p && !currently_open_class (scope))
16106 /* If SCOPE isn't the template itself, it will not have a valid
16107 TYPE_FIELDS list. */
16108 if (same_type_p (scope, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope)))
16109 /* scope is either the template itself or a compatible instantiation
16110 like X<T>, so look up the name in the original template. */
16111 scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope);
16113 /* scope is a partial instantiation, so we can't do the lookup or we
16114 will lose the template arguments. */
16116 /* Enter the SCOPE so that name lookup will be resolved as if we
16117 were in the class definition. In particular, SCOPE will no
16118 longer be considered a dependent type. */
16119 pushed_scope = push_scope (scope);
16120 /* Look up the declaration. */
16121 decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true);
16123 result = NULL_TREE;
16125 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
16126 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
16129 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE
16130 && TREE_CODE (decl) == TYPE_DECL)
16132 result = TREE_TYPE (decl);
16133 if (result == error_mark_node)
16134 result = NULL_TREE;
16136 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR
16137 && DECL_CLASS_TEMPLATE_P (decl))
16141 /* Obtain the template and the arguments. */
16142 tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0);
16143 args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1);
16144 /* Instantiate the template. */
16145 result = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE,
16146 /*entering_scope=*/0,
16147 tf_error | tf_user);
16148 if (result == error_mark_node)
16149 result = NULL_TREE;
16152 /* Leave the SCOPE. */
16154 pop_scope (pushed_scope);
16156 /* If we failed to resolve it, return the original typename. */
16160 /* If lookup found a typename type, resolve that too. */
16161 if (TREE_CODE (result) == TYPENAME_TYPE && !TYPENAME_IS_RESOLVING_P (result))
16163 /* Ill-formed programs can cause infinite recursion here, so we
16164 must catch that. */
16165 TYPENAME_IS_RESOLVING_P (type) = 1;
16166 result = resolve_typename_type (result, only_current_p);
16167 TYPENAME_IS_RESOLVING_P (type) = 0;
16170 /* Qualify the resulting type. */
16171 quals = cp_type_quals (type);
16173 result = cp_build_qualified_type (result, cp_type_quals (result) | quals);
16178 /* EXPR is an expression which is not type-dependent. Return a proxy
16179 for EXPR that can be used to compute the types of larger
16180 expressions containing EXPR. */
16183 build_non_dependent_expr (tree expr)
16187 /* Preserve null pointer constants so that the type of things like
16188 "p == 0" where "p" is a pointer can be determined. */
16189 if (null_ptr_cst_p (expr))
16191 /* Preserve OVERLOADs; the functions must be available to resolve
16194 if (TREE_CODE (inner_expr) == STMT_EXPR)
16195 inner_expr = stmt_expr_value_expr (inner_expr);
16196 if (TREE_CODE (inner_expr) == ADDR_EXPR)
16197 inner_expr = TREE_OPERAND (inner_expr, 0);
16198 if (TREE_CODE (inner_expr) == COMPONENT_REF)
16199 inner_expr = TREE_OPERAND (inner_expr, 1);
16200 if (is_overloaded_fn (inner_expr)
16201 || TREE_CODE (inner_expr) == OFFSET_REF)
16203 /* There is no need to return a proxy for a variable. */
16204 if (TREE_CODE (expr) == VAR_DECL)
16206 /* Preserve string constants; conversions from string constants to
16207 "char *" are allowed, even though normally a "const char *"
16208 cannot be used to initialize a "char *". */
16209 if (TREE_CODE (expr) == STRING_CST)
16211 /* Preserve arithmetic constants, as an optimization -- there is no
16212 reason to create a new node. */
16213 if (TREE_CODE (expr) == INTEGER_CST || TREE_CODE (expr) == REAL_CST)
16215 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
16216 There is at least one place where we want to know that a
16217 particular expression is a throw-expression: when checking a ?:
16218 expression, there are special rules if the second or third
16219 argument is a throw-expression. */
16220 if (TREE_CODE (expr) == THROW_EXPR)
16223 if (TREE_CODE (expr) == COND_EXPR)
16224 return build3 (COND_EXPR,
16226 TREE_OPERAND (expr, 0),
16227 (TREE_OPERAND (expr, 1)
16228 ? build_non_dependent_expr (TREE_OPERAND (expr, 1))
16229 : build_non_dependent_expr (TREE_OPERAND (expr, 0))),
16230 build_non_dependent_expr (TREE_OPERAND (expr, 2)));
16231 if (TREE_CODE (expr) == COMPOUND_EXPR
16232 && !COMPOUND_EXPR_OVERLOADED (expr))
16233 return build2 (COMPOUND_EXPR,
16235 TREE_OPERAND (expr, 0),
16236 build_non_dependent_expr (TREE_OPERAND (expr, 1)));
16238 /* If the type is unknown, it can't really be non-dependent */
16239 gcc_assert (TREE_TYPE (expr) != unknown_type_node);
16241 /* Otherwise, build a NON_DEPENDENT_EXPR.
16243 REFERENCE_TYPEs are not stripped for expressions in templates
16244 because doing so would play havoc with mangling. Consider, for
16247 template <typename T> void f<T& g>() { g(); }
16249 In the body of "f", the expression for "g" will have
16250 REFERENCE_TYPE, even though the standard says that it should
16251 not. The reason is that we must preserve the syntactic form of
16252 the expression so that mangling (say) "f<g>" inside the body of
16253 "f" works out correctly. Therefore, the REFERENCE_TYPE is
16255 return build1 (NON_DEPENDENT_EXPR, non_reference (TREE_TYPE (expr)), expr);
16258 /* ARGS is a TREE_LIST of expressions as arguments to a function call.
16259 Return a new TREE_LIST with the various arguments replaced with
16260 equivalent non-dependent expressions. */
16263 build_non_dependent_args (tree args)
16268 new_args = NULL_TREE;
16269 for (a = args; a; a = TREE_CHAIN (a))
16270 new_args = tree_cons (NULL_TREE,
16271 build_non_dependent_expr (TREE_VALUE (a)),
16273 return nreverse (new_args);
16276 #include "gt-cp-pt.h"