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 (IS_AGGR_TYPE (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 && !cp_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 = make_aggr_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 = make_aggr_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 && IS_AGGR_TYPE (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) && IS_AGGR_TYPE (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_aggr_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 (! IS_AGGR_TYPE (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 #ifdef USE_MAPPED_LOCATION
9160 && last_loc != input_location
9162 && (last_loc.line != input_line
9163 || last_loc.file != input_filename)
9167 if (TREE_CODE (type) == VOID_TYPE)
9168 error ("forming reference to void");
9170 error ("forming %s to reference type %qT",
9171 (code == POINTER_TYPE) ? "pointer" : "reference",
9173 last_loc = input_location;
9176 return error_mark_node;
9178 else if (code == POINTER_TYPE)
9180 r = build_pointer_type (type);
9181 if (TREE_CODE (type) == METHOD_TYPE)
9182 r = build_ptrmemfunc_type (r);
9184 else if (TREE_CODE (type) == REFERENCE_TYPE)
9185 /* In C++0x, during template argument substitution, when there is an
9186 attempt to create a reference to a reference type, reference
9187 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
9189 "If a template-argument for a template-parameter T names a type
9190 that is a reference to a type A, an attempt to create the type
9191 'lvalue reference to cv T' creates the type 'lvalue reference to
9192 A,' while an attempt to create the type type rvalue reference to
9193 cv T' creates the type T"
9195 r = cp_build_reference_type
9197 TYPE_REF_IS_RVALUE (t) && TYPE_REF_IS_RVALUE (type));
9199 r = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
9200 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
9202 if (r != error_mark_node)
9203 /* Will this ever be needed for TYPE_..._TO values? */
9210 r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
9211 if (r == error_mark_node || !IS_AGGR_TYPE (r))
9215 Type deduction may fail for any of the following
9218 -- Attempting to create "pointer to member of T" when T
9219 is not a class type. */
9220 if (complain & tf_error)
9221 error ("creating pointer to member of non-class type %qT", r);
9222 return error_mark_node;
9224 if (TREE_CODE (type) == REFERENCE_TYPE)
9226 if (complain & tf_error)
9227 error ("creating pointer to member reference type %qT", type);
9228 return error_mark_node;
9230 if (TREE_CODE (type) == VOID_TYPE)
9232 if (complain & tf_error)
9233 error ("creating pointer to member of type void");
9234 return error_mark_node;
9236 gcc_assert (TREE_CODE (type) != METHOD_TYPE);
9237 if (TREE_CODE (type) == FUNCTION_TYPE)
9239 /* The type of the implicit object parameter gets its
9240 cv-qualifiers from the FUNCTION_TYPE. */
9242 tree this_type = cp_build_qualified_type (TYPE_MAIN_VARIANT (r),
9243 cp_type_quals (type));
9245 method_type = build_method_type_directly (this_type,
9247 TYPE_ARG_TYPES (type));
9248 memptr = build_ptrmemfunc_type (build_pointer_type (method_type));
9249 return cp_build_qualified_type_real (memptr, cp_type_quals (t),
9253 return cp_build_qualified_type_real (build_ptrmem_type (r, type),
9262 fntype = tsubst_function_type (t, args, complain, in_decl);
9263 if (fntype == error_mark_node)
9264 return error_mark_node;
9266 /* Substitute the exception specification. */
9267 specs = tsubst_exception_specification (t, args, complain,
9269 if (specs == error_mark_node)
9270 return error_mark_node;
9272 fntype = build_exception_variant (fntype, specs);
9277 tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
9278 if (domain == error_mark_node)
9279 return error_mark_node;
9281 /* As an optimization, we avoid regenerating the array type if
9282 it will obviously be the same as T. */
9283 if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
9286 /* These checks should match the ones in grokdeclarator.
9290 The deduction may fail for any of the following reasons:
9292 -- Attempting to create an array with an element type that
9293 is void, a function type, or a reference type, or [DR337]
9294 an abstract class type. */
9295 if (TREE_CODE (type) == VOID_TYPE
9296 || TREE_CODE (type) == FUNCTION_TYPE
9297 || TREE_CODE (type) == REFERENCE_TYPE)
9299 if (complain & tf_error)
9300 error ("creating array of %qT", type);
9301 return error_mark_node;
9303 if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
9305 if (complain & tf_error)
9306 error ("creating array of %qT, which is an abstract class type",
9308 return error_mark_node;
9311 r = build_cplus_array_type (type, domain);
9313 if (TYPE_USER_ALIGN (t))
9315 TYPE_ALIGN (r) = TYPE_ALIGN (t);
9316 TYPE_USER_ALIGN (r) = 1;
9325 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
9326 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
9328 if (e1 == error_mark_node || e2 == error_mark_node)
9329 return error_mark_node;
9331 return fold_build2 (TREE_CODE (t), TREE_TYPE (t), e1, e2);
9337 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
9338 if (e == error_mark_node)
9339 return error_mark_node;
9341 return fold_build1 (TREE_CODE (t), TREE_TYPE (t), e);
9346 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
9347 in_decl, /*entering_scope=*/1);
9348 tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
9351 if (ctx == error_mark_node || f == error_mark_node)
9352 return error_mark_node;
9354 if (!IS_AGGR_TYPE (ctx))
9356 if (complain & tf_error)
9357 error ("%qT is not a class, struct, or union type", ctx);
9358 return error_mark_node;
9360 else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
9362 /* Normally, make_typename_type does not require that the CTX
9363 have complete type in order to allow things like:
9365 template <class T> struct S { typename S<T>::X Y; };
9367 But, such constructs have already been resolved by this
9368 point, so here CTX really should have complete type, unless
9369 it's a partial instantiation. */
9370 ctx = complete_type (ctx);
9371 if (!COMPLETE_TYPE_P (ctx))
9373 if (complain & tf_error)
9374 cxx_incomplete_type_error (NULL_TREE, ctx);
9375 return error_mark_node;
9379 f = make_typename_type (ctx, f, typename_type,
9380 (complain & tf_error) | tf_keep_type_decl);
9381 if (f == error_mark_node)
9383 if (TREE_CODE (f) == TYPE_DECL)
9385 complain |= tf_ignore_bad_quals;
9389 if (TREE_CODE (f) != TYPENAME_TYPE)
9391 if (TYPENAME_IS_ENUM_P (t) && TREE_CODE (f) != ENUMERAL_TYPE)
9392 error ("%qT resolves to %qT, which is not an enumeration type",
9394 else if (TYPENAME_IS_CLASS_P (t) && !CLASS_TYPE_P (f))
9395 error ("%qT resolves to %qT, which is is not a class type",
9399 return cp_build_qualified_type_real
9400 (f, cp_type_quals (f) | cp_type_quals (t), complain);
9403 case UNBOUND_CLASS_TEMPLATE:
9405 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
9406 in_decl, /*entering_scope=*/1);
9407 tree name = TYPE_IDENTIFIER (t);
9408 tree parm_list = DECL_TEMPLATE_PARMS (TYPE_NAME (t));
9410 if (ctx == error_mark_node || name == error_mark_node)
9411 return error_mark_node;
9414 parm_list = tsubst_template_parms (parm_list, args, complain);
9415 return make_unbound_class_template (ctx, name, parm_list, complain);
9425 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
9426 tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl,
9427 /*integral_constant_expression_p=*/false);
9428 if (e1 == error_mark_node || e2 == error_mark_node)
9429 return error_mark_node;
9431 return build_nt (ARRAY_REF, e1, e2, NULL_TREE, NULL_TREE);
9436 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
9437 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
9438 if (e1 == error_mark_node || e2 == error_mark_node)
9439 return error_mark_node;
9441 return build_qualified_name (/*type=*/NULL_TREE,
9442 e1, e2, QUALIFIED_NAME_IS_TEMPLATE (t));
9449 type = finish_typeof (tsubst_expr
9450 (TYPEOF_TYPE_EXPR (t), args,
9452 /*integral_constant_expression_p=*/false));
9453 return cp_build_qualified_type_real (type,
9455 | cp_type_quals (type),
9464 finish_decltype_type (tsubst_expr
9465 (DECLTYPE_TYPE_EXPR (t), args,
9467 /*integral_constant_expression_p=*/false),
9468 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t));
9469 return cp_build_qualified_type_real (type,
9471 | cp_type_quals (type),
9475 case TYPE_ARGUMENT_PACK:
9476 case NONTYPE_ARGUMENT_PACK:
9478 tree r = make_node (TREE_CODE (t));
9480 tsubst_template_args (ARGUMENT_PACK_ARGS (t),
9484 SET_ARGUMENT_PACK_ARGS (r, packed_out);
9486 /* For template nontype argument packs, also substitute into
9488 if (TREE_CODE (t) == NONTYPE_ARGUMENT_PACK)
9489 TREE_TYPE (r) = tsubst (TREE_TYPE (t), args, complain, in_decl);
9496 sorry ("use of %qs in template",
9497 tree_code_name [(int) TREE_CODE (t)]);
9498 return error_mark_node;
9502 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
9503 type of the expression on the left-hand side of the "." or "->"
9507 tsubst_baselink (tree baselink, tree object_type,
9508 tree args, tsubst_flags_t complain, tree in_decl)
9511 tree qualifying_scope;
9514 tree template_args = 0;
9515 bool template_id_p = false;
9517 /* A baselink indicates a function from a base class. Both the
9518 BASELINK_ACCESS_BINFO and the base class referenced may
9519 indicate bases of the template class, rather than the
9520 instantiated class. In addition, lookups that were not
9521 ambiguous before may be ambiguous now. Therefore, we perform
9522 the lookup again. */
9523 qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink));
9524 qualifying_scope = tsubst (qualifying_scope, args,
9526 fns = BASELINK_FUNCTIONS (baselink);
9527 optype = BASELINK_OPTYPE (baselink);
9528 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
9530 template_id_p = true;
9531 template_args = TREE_OPERAND (fns, 1);
9532 fns = TREE_OPERAND (fns, 0);
9534 template_args = tsubst_template_args (template_args, args,
9537 name = DECL_NAME (get_first_fn (fns));
9538 baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1);
9540 /* If lookup found a single function, mark it as used at this
9541 point. (If it lookup found multiple functions the one selected
9542 later by overload resolution will be marked as used at that
9544 if (BASELINK_P (baselink))
9545 fns = BASELINK_FUNCTIONS (baselink);
9546 if (!template_id_p && !really_overloaded_fn (fns))
9547 mark_used (OVL_CURRENT (fns));
9549 /* Add back the template arguments, if present. */
9550 if (BASELINK_P (baselink) && template_id_p)
9551 BASELINK_FUNCTIONS (baselink)
9552 = build_nt (TEMPLATE_ID_EXPR,
9553 BASELINK_FUNCTIONS (baselink),
9555 /* Update the conversion operator type. */
9556 BASELINK_OPTYPE (baselink)
9557 = tsubst (optype, args, complain, in_decl);
9560 object_type = current_class_type;
9561 return adjust_result_of_qualified_name_lookup (baselink,
9566 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
9567 true if the qualified-id will be a postfix-expression in-and-of
9568 itself; false if more of the postfix-expression follows the
9569 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
9573 tsubst_qualified_id (tree qualified_id, tree args,
9574 tsubst_flags_t complain, tree in_decl,
9575 bool done, bool address_p)
9583 gcc_assert (TREE_CODE (qualified_id) == SCOPE_REF);
9585 /* Figure out what name to look up. */
9586 name = TREE_OPERAND (qualified_id, 1);
9587 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
9590 template_args = TREE_OPERAND (name, 1);
9592 template_args = tsubst_template_args (template_args, args,
9594 name = TREE_OPERAND (name, 0);
9598 is_template = false;
9599 template_args = NULL_TREE;
9602 /* Substitute into the qualifying scope. When there are no ARGS, we
9603 are just trying to simplify a non-dependent expression. In that
9604 case the qualifying scope may be dependent, and, in any case,
9605 substituting will not help. */
9606 scope = TREE_OPERAND (qualified_id, 0);
9609 scope = tsubst (scope, args, complain, in_decl);
9610 expr = tsubst_copy (name, args, complain, in_decl);
9615 if (dependent_type_p (scope))
9616 return build_qualified_name (/*type=*/NULL_TREE,
9618 QUALIFIED_NAME_IS_TEMPLATE (qualified_id));
9620 if (!BASELINK_P (name) && !DECL_P (expr))
9622 if (TREE_CODE (expr) == BIT_NOT_EXPR)
9623 /* If this were actually a destructor call, it would have been
9624 parsed as such by the parser. */
9625 expr = error_mark_node;
9627 expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0, false);
9628 if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL
9629 ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL)
9631 if (complain & tf_error)
9633 error ("dependent-name %qE is parsed as a non-type, but "
9634 "instantiation yields a type", qualified_id);
9635 inform ("say %<typename %E%> if a type is meant", qualified_id);
9637 return error_mark_node;
9643 check_accessibility_of_qualified_id (expr, /*object_type=*/NULL_TREE,
9645 /* Remember that there was a reference to this entity. */
9649 if (expr == error_mark_node || TREE_CODE (expr) == TREE_LIST)
9651 if (complain & tf_error)
9652 qualified_name_lookup_error (scope,
9653 TREE_OPERAND (qualified_id, 1),
9655 return error_mark_node;
9659 expr = lookup_template_function (expr, template_args);
9661 if (expr == error_mark_node && complain & tf_error)
9662 qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1),
9664 else if (TYPE_P (scope))
9666 expr = (adjust_result_of_qualified_name_lookup
9667 (expr, scope, current_class_type));
9668 expr = (finish_qualified_id_expr
9669 (scope, expr, done, address_p,
9670 QUALIFIED_NAME_IS_TEMPLATE (qualified_id),
9671 /*template_arg_p=*/false));
9674 /* Expressions do not generally have reference type. */
9675 if (TREE_CODE (expr) != SCOPE_REF
9676 /* However, if we're about to form a pointer-to-member, we just
9677 want the referenced member referenced. */
9678 && TREE_CODE (expr) != OFFSET_REF)
9679 expr = convert_from_reference (expr);
9684 /* Like tsubst, but deals with expressions. This function just replaces
9685 template parms; to finish processing the resultant expression, use
9689 tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
9691 enum tree_code code;
9694 if (t == NULL_TREE || t == error_mark_node)
9697 code = TREE_CODE (t);
9702 r = retrieve_local_specialization (t);
9703 gcc_assert (r != NULL);
9704 if (TREE_CODE (r) == ARGUMENT_PACK_SELECT)
9705 r = ARGUMENT_PACK_SELECT_ARG (r);
9714 if (DECL_TEMPLATE_PARM_P (t))
9715 return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
9716 /* There is no need to substitute into namespace-scope
9718 if (DECL_NAMESPACE_SCOPE_P (t))
9720 /* If ARGS is NULL, then T is known to be non-dependent. */
9721 if (args == NULL_TREE)
9722 return integral_constant_value (t);
9724 /* Unfortunately, we cannot just call lookup_name here.
9727 template <int I> int f() {
9729 struct S { void g() { E e = a; } };
9732 When we instantiate f<7>::S::g(), say, lookup_name is not
9733 clever enough to find f<7>::a. */
9735 = tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl,
9736 /*entering_scope=*/0);
9738 for (v = TYPE_VALUES (enum_type);
9741 if (TREE_PURPOSE (v) == DECL_NAME (t))
9742 return TREE_VALUE (v);
9744 /* We didn't find the name. That should never happen; if
9745 name-lookup found it during preliminary parsing, we
9746 should find it again here during instantiation. */
9752 if (DECL_CONTEXT (t))
9756 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
9757 /*entering_scope=*/1);
9758 if (ctx != DECL_CONTEXT (t))
9760 tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
9763 if (complain & tf_error)
9764 error ("using invalid field %qD", t);
9765 return error_mark_node;
9775 if ((DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
9776 || local_variable_p (t))
9777 t = tsubst (t, args, complain, in_decl);
9782 return tsubst_baselink (t, current_class_type, args, complain, in_decl);
9785 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
9786 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
9787 args, complain, in_decl);
9788 else if (DECL_FUNCTION_TEMPLATE_P (t) && DECL_MEMBER_TEMPLATE_P (t))
9789 return tsubst (t, args, complain, in_decl);
9790 else if (DECL_CLASS_SCOPE_P (t)
9791 && uses_template_parms (DECL_CONTEXT (t)))
9793 /* Template template argument like the following example need
9796 template <template <class> class TT> struct C {};
9797 template <class T> struct D {
9798 template <class U> struct E {};
9803 We are processing the template argument `E' in #1 for
9804 the template instantiation #2. Originally, `E' is a
9805 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
9806 have to substitute this with one having context `D<int>'. */
9808 tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
9809 return lookup_field (context, DECL_NAME(t), 0, false);
9812 /* Ordinary template template argument. */
9816 case REINTERPRET_CAST_EXPR:
9817 case CONST_CAST_EXPR:
9818 case STATIC_CAST_EXPR:
9819 case DYNAMIC_CAST_EXPR:
9822 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
9823 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
9826 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
9828 /* We only want to compute the number of arguments. */
9829 tree expanded = tsubst_pack_expansion (TREE_OPERAND (t, 0), args,
9831 if (expanded == error_mark_node)
9832 return error_mark_node;
9833 return build_int_cst (size_type_node, TREE_VEC_LENGTH (expanded));
9839 case TRUTH_NOT_EXPR:
9842 case UNARY_PLUS_EXPR: /* Unary + */
9850 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
9851 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
9858 object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
9859 name = TREE_OPERAND (t, 1);
9860 if (TREE_CODE (name) == BIT_NOT_EXPR)
9862 name = tsubst_copy (TREE_OPERAND (name, 0), args,
9864 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
9866 else if (TREE_CODE (name) == SCOPE_REF
9867 && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
9869 tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
9871 name = TREE_OPERAND (name, 1);
9872 name = tsubst_copy (TREE_OPERAND (name, 0), args,
9874 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
9875 name = build_qualified_name (/*type=*/NULL_TREE,
9877 /*template_p=*/false);
9879 else if (TREE_CODE (name) == BASELINK)
9880 name = tsubst_baselink (name,
9881 non_reference (TREE_TYPE (object)),
9885 name = tsubst_copy (name, args, complain, in_decl);
9886 return build_nt (COMPONENT_REF, object, name, NULL_TREE);
9892 case TRUNC_DIV_EXPR:
9894 case FLOOR_DIV_EXPR:
9895 case ROUND_DIV_EXPR:
9896 case EXACT_DIV_EXPR:
9900 case TRUNC_MOD_EXPR:
9901 case FLOOR_MOD_EXPR:
9902 case TRUTH_ANDIF_EXPR:
9903 case TRUTH_ORIF_EXPR:
9904 case TRUTH_AND_EXPR:
9921 case PREDECREMENT_EXPR:
9922 case PREINCREMENT_EXPR:
9923 case POSTDECREMENT_EXPR:
9924 case POSTINCREMENT_EXPR:
9926 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9927 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
9930 return build_qualified_name (/*type=*/NULL_TREE,
9931 tsubst_copy (TREE_OPERAND (t, 0),
9932 args, complain, in_decl),
9933 tsubst_copy (TREE_OPERAND (t, 1),
9934 args, complain, in_decl),
9935 QUALIFIED_NAME_IS_TEMPLATE (t));
9940 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9941 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
9942 NULL_TREE, NULL_TREE);
9946 int n = VL_EXP_OPERAND_LENGTH (t);
9947 tree result = build_vl_exp (CALL_EXPR, n);
9949 for (i = 0; i < n; i++)
9950 TREE_OPERAND (t, i) = tsubst_copy (TREE_OPERAND (t, i), args,
9957 case PSEUDO_DTOR_EXPR:
9960 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9961 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
9962 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
9963 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
9970 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9971 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
9972 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
9973 NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
9980 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9981 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
9982 DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
9983 DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
9987 case TEMPLATE_ID_EXPR:
9989 /* Substituted template arguments */
9990 tree fn = TREE_OPERAND (t, 0);
9991 tree targs = TREE_OPERAND (t, 1);
9993 fn = tsubst_copy (fn, args, complain, in_decl);
9995 targs = tsubst_template_args (targs, args, complain, in_decl);
9997 return lookup_template_function (fn, targs);
10002 tree purpose, value, chain;
10004 if (t == void_list_node)
10007 purpose = TREE_PURPOSE (t);
10009 purpose = tsubst_copy (purpose, args, complain, in_decl);
10010 value = TREE_VALUE (t);
10012 value = tsubst_copy (value, args, complain, in_decl);
10013 chain = TREE_CHAIN (t);
10014 if (chain && chain != void_type_node)
10015 chain = tsubst_copy (chain, args, complain, in_decl);
10016 if (purpose == TREE_PURPOSE (t)
10017 && value == TREE_VALUE (t)
10018 && chain == TREE_CHAIN (t))
10020 return tree_cons (purpose, value, chain);
10025 case ENUMERAL_TYPE:
10027 case TEMPLATE_TYPE_PARM:
10028 case TEMPLATE_TEMPLATE_PARM:
10029 case BOUND_TEMPLATE_TEMPLATE_PARM:
10030 case TEMPLATE_PARM_INDEX:
10032 case REFERENCE_TYPE:
10034 case FUNCTION_TYPE:
10037 case TYPENAME_TYPE:
10038 case UNBOUND_CLASS_TEMPLATE:
10040 case DECLTYPE_TYPE:
10042 return tsubst (t, args, complain, in_decl);
10044 case IDENTIFIER_NODE:
10045 if (IDENTIFIER_TYPENAME_P (t))
10047 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10048 return mangle_conv_op_name_for_type (new_type);
10054 /* This is handled by tsubst_copy_and_build. */
10055 gcc_unreachable ();
10058 return build_x_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain,
10060 tsubst (TREE_TYPE (t), args, complain, in_decl));
10062 case CLEANUP_POINT_EXPR:
10063 /* We shouldn't have built any of these during initial template
10064 generation. Instead, they should be built during instantiation
10065 in response to the saved STMT_IS_FULL_EXPR_P setting. */
10066 gcc_unreachable ();
10069 mark_used (TREE_OPERAND (t, 1));
10072 case EXPR_PACK_EXPANSION:
10073 error ("invalid use of pack expansion expression");
10074 return error_mark_node;
10076 case NONTYPE_ARGUMENT_PACK:
10077 error ("use %<...%> to expand argument pack");
10078 return error_mark_node;
10085 /* Like tsubst_copy, but specifically for OpenMP clauses. */
10088 tsubst_omp_clauses (tree clauses, tree args, tsubst_flags_t complain,
10091 tree new_clauses = NULL, nc, oc;
10093 for (oc = clauses; oc ; oc = OMP_CLAUSE_CHAIN (oc))
10095 nc = copy_node (oc);
10096 OMP_CLAUSE_CHAIN (nc) = new_clauses;
10099 switch (OMP_CLAUSE_CODE (nc))
10101 case OMP_CLAUSE_PRIVATE:
10102 case OMP_CLAUSE_SHARED:
10103 case OMP_CLAUSE_FIRSTPRIVATE:
10104 case OMP_CLAUSE_LASTPRIVATE:
10105 case OMP_CLAUSE_REDUCTION:
10106 case OMP_CLAUSE_COPYIN:
10107 case OMP_CLAUSE_COPYPRIVATE:
10108 case OMP_CLAUSE_IF:
10109 case OMP_CLAUSE_NUM_THREADS:
10110 case OMP_CLAUSE_SCHEDULE:
10111 OMP_CLAUSE_OPERAND (nc, 0)
10112 = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 0), args, complain,
10113 in_decl, /*integral_constant_expression_p=*/false);
10115 case OMP_CLAUSE_NOWAIT:
10116 case OMP_CLAUSE_ORDERED:
10117 case OMP_CLAUSE_DEFAULT:
10120 gcc_unreachable ();
10124 return finish_omp_clauses (nreverse (new_clauses));
10127 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
10130 tsubst_copy_asm_operands (tree t, tree args, tsubst_flags_t complain,
10133 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
10135 tree purpose, value, chain;
10140 if (TREE_CODE (t) != TREE_LIST)
10141 return tsubst_copy_and_build (t, args, complain, in_decl,
10142 /*function_p=*/false,
10143 /*integral_constant_expression_p=*/false);
10145 if (t == void_list_node)
10148 purpose = TREE_PURPOSE (t);
10150 purpose = RECUR (purpose);
10151 value = TREE_VALUE (t);
10153 value = RECUR (value);
10154 chain = TREE_CHAIN (t);
10155 if (chain && chain != void_type_node)
10156 chain = RECUR (chain);
10157 return tree_cons (purpose, value, chain);
10161 /* Like tsubst_copy for expressions, etc. but also does semantic
10165 tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl,
10166 bool integral_constant_expression_p)
10168 #define RECUR(NODE) \
10169 tsubst_expr ((NODE), args, complain, in_decl, \
10170 integral_constant_expression_p)
10174 if (t == NULL_TREE || t == error_mark_node)
10177 if (EXPR_HAS_LOCATION (t))
10178 input_location = EXPR_LOCATION (t);
10179 if (STATEMENT_CODE_P (TREE_CODE (t)))
10180 current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
10182 switch (TREE_CODE (t))
10184 case STATEMENT_LIST:
10186 tree_stmt_iterator i;
10187 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
10188 RECUR (tsi_stmt (i));
10192 case CTOR_INITIALIZER:
10193 finish_mem_initializers (tsubst_initializer_list
10194 (TREE_OPERAND (t, 0), args));
10198 finish_return_stmt (RECUR (TREE_OPERAND (t, 0)));
10202 tmp = RECUR (EXPR_STMT_EXPR (t));
10203 if (EXPR_STMT_STMT_EXPR_RESULT (t))
10204 finish_stmt_expr_expr (tmp, cur_stmt_expr);
10206 finish_expr_stmt (tmp);
10210 do_using_directive (RECUR (USING_STMT_NAMESPACE (t)));
10218 decl = DECL_EXPR_DECL (t);
10219 if (TREE_CODE (decl) == LABEL_DECL)
10220 finish_label_decl (DECL_NAME (decl));
10221 else if (TREE_CODE (decl) == USING_DECL)
10223 tree scope = USING_DECL_SCOPE (decl);
10224 tree name = DECL_NAME (decl);
10227 scope = RECUR (scope);
10228 decl = lookup_qualified_name (scope, name,
10229 /*is_type_p=*/false,
10230 /*complain=*/false);
10231 if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
10232 qualified_name_lookup_error (scope, name, decl);
10234 do_local_using_decl (decl, scope, name);
10238 init = DECL_INITIAL (decl);
10239 decl = tsubst (decl, args, complain, in_decl);
10240 if (decl != error_mark_node)
10242 /* By marking the declaration as instantiated, we avoid
10243 trying to instantiate it. Since instantiate_decl can't
10244 handle local variables, and since we've already done
10245 all that needs to be done, that's the right thing to
10247 if (TREE_CODE (decl) == VAR_DECL)
10248 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
10249 if (TREE_CODE (decl) == VAR_DECL
10250 && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
10251 /* Anonymous aggregates are a special case. */
10252 finish_anon_union (decl);
10255 maybe_push_decl (decl);
10256 if (TREE_CODE (decl) == VAR_DECL
10257 && DECL_PRETTY_FUNCTION_P (decl))
10259 /* For __PRETTY_FUNCTION__ we have to adjust the
10261 const char *const name
10262 = cxx_printable_name (current_function_decl, 2);
10263 init = cp_fname_init (name, &TREE_TYPE (decl));
10267 tree t = RECUR (init);
10270 /* If we had an initializer but it
10271 instantiated to nothing,
10272 value-initialize the object. This will
10273 only occur when the initializer was a
10274 pack expansion where the parameter packs
10275 used in that expansion were of length
10277 init = build_default_init (TREE_TYPE (decl),
10283 finish_decl (decl, init, NULL_TREE);
10288 /* A DECL_EXPR can also be used as an expression, in the condition
10289 clause of an if/for/while construct. */
10294 stmt = begin_for_stmt ();
10295 RECUR (FOR_INIT_STMT (t));
10296 finish_for_init_stmt (stmt);
10297 tmp = RECUR (FOR_COND (t));
10298 finish_for_cond (tmp, stmt);
10299 tmp = RECUR (FOR_EXPR (t));
10300 finish_for_expr (tmp, stmt);
10301 RECUR (FOR_BODY (t));
10302 finish_for_stmt (stmt);
10306 stmt = begin_while_stmt ();
10307 tmp = RECUR (WHILE_COND (t));
10308 finish_while_stmt_cond (tmp, stmt);
10309 RECUR (WHILE_BODY (t));
10310 finish_while_stmt (stmt);
10314 stmt = begin_do_stmt ();
10315 RECUR (DO_BODY (t));
10316 finish_do_body (stmt);
10317 tmp = RECUR (DO_COND (t));
10318 finish_do_stmt (tmp, stmt);
10322 stmt = begin_if_stmt ();
10323 tmp = RECUR (IF_COND (t));
10324 finish_if_stmt_cond (tmp, stmt);
10325 RECUR (THEN_CLAUSE (t));
10326 finish_then_clause (stmt);
10328 if (ELSE_CLAUSE (t))
10330 begin_else_clause (stmt);
10331 RECUR (ELSE_CLAUSE (t));
10332 finish_else_clause (stmt);
10335 finish_if_stmt (stmt);
10339 if (BIND_EXPR_BODY_BLOCK (t))
10340 stmt = begin_function_body ();
10342 stmt = begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t)
10343 ? BCS_TRY_BLOCK : 0);
10345 RECUR (BIND_EXPR_BODY (t));
10347 if (BIND_EXPR_BODY_BLOCK (t))
10348 finish_function_body (stmt);
10350 finish_compound_stmt (stmt);
10354 finish_break_stmt ();
10357 case CONTINUE_STMT:
10358 finish_continue_stmt ();
10362 stmt = begin_switch_stmt ();
10363 tmp = RECUR (SWITCH_STMT_COND (t));
10364 finish_switch_cond (tmp, stmt);
10365 RECUR (SWITCH_STMT_BODY (t));
10366 finish_switch_stmt (stmt);
10369 case CASE_LABEL_EXPR:
10370 finish_case_label (RECUR (CASE_LOW (t)),
10371 RECUR (CASE_HIGH (t)));
10375 finish_label_stmt (DECL_NAME (LABEL_EXPR_LABEL (t)));
10379 tmp = GOTO_DESTINATION (t);
10380 if (TREE_CODE (tmp) != LABEL_DECL)
10381 /* Computed goto's must be tsubst'd into. On the other hand,
10382 non-computed gotos must not be; the identifier in question
10383 will have no binding. */
10386 tmp = DECL_NAME (tmp);
10387 finish_goto_stmt (tmp);
10391 tmp = finish_asm_stmt
10392 (ASM_VOLATILE_P (t),
10393 RECUR (ASM_STRING (t)),
10394 tsubst_copy_asm_operands (ASM_OUTPUTS (t), args, complain, in_decl),
10395 tsubst_copy_asm_operands (ASM_INPUTS (t), args, complain, in_decl),
10396 tsubst_copy_asm_operands (ASM_CLOBBERS (t), args, complain, in_decl));
10398 tree asm_expr = tmp;
10399 if (TREE_CODE (asm_expr) == CLEANUP_POINT_EXPR)
10400 asm_expr = TREE_OPERAND (asm_expr, 0);
10401 ASM_INPUT_P (asm_expr) = ASM_INPUT_P (t);
10408 stmt = begin_try_block ();
10409 RECUR (TRY_STMTS (t));
10410 finish_cleanup_try_block (stmt);
10411 finish_cleanup (RECUR (TRY_HANDLERS (t)), stmt);
10415 tree compound_stmt = NULL_TREE;
10417 if (FN_TRY_BLOCK_P (t))
10418 stmt = begin_function_try_block (&compound_stmt);
10420 stmt = begin_try_block ();
10422 RECUR (TRY_STMTS (t));
10424 if (FN_TRY_BLOCK_P (t))
10425 finish_function_try_block (stmt);
10427 finish_try_block (stmt);
10429 RECUR (TRY_HANDLERS (t));
10430 if (FN_TRY_BLOCK_P (t))
10431 finish_function_handler_sequence (stmt, compound_stmt);
10433 finish_handler_sequence (stmt);
10439 tree decl = HANDLER_PARMS (t);
10443 decl = tsubst (decl, args, complain, in_decl);
10444 /* Prevent instantiate_decl from trying to instantiate
10445 this variable. We've already done all that needs to be
10447 if (decl != error_mark_node)
10448 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
10450 stmt = begin_handler ();
10451 finish_handler_parms (decl, stmt);
10452 RECUR (HANDLER_BODY (t));
10453 finish_handler (stmt);
10458 tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
10461 case STATIC_ASSERT:
10464 tsubst_expr (STATIC_ASSERT_CONDITION (t),
10467 /*integral_constant_expression_p=*/true);
10468 finish_static_assert (condition,
10469 STATIC_ASSERT_MESSAGE (t),
10470 STATIC_ASSERT_SOURCE_LOCATION (t),
10471 /*member_p=*/false);
10476 tmp = tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t),
10477 args, complain, in_decl);
10478 stmt = begin_omp_parallel ();
10479 RECUR (OMP_PARALLEL_BODY (t));
10480 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp, stmt))
10481 = OMP_PARALLEL_COMBINED (t);
10486 tree clauses, decl, init, cond, incr, body, pre_body;
10488 clauses = tsubst_omp_clauses (OMP_FOR_CLAUSES (t),
10489 args, complain, in_decl);
10490 init = OMP_FOR_INIT (t);
10491 gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
10492 decl = RECUR (TREE_OPERAND (init, 0));
10493 init = RECUR (TREE_OPERAND (init, 1));
10494 cond = RECUR (OMP_FOR_COND (t));
10495 incr = RECUR (OMP_FOR_INCR (t));
10497 stmt = begin_omp_structured_block ();
10499 pre_body = push_stmt_list ();
10500 RECUR (OMP_FOR_PRE_BODY (t));
10501 pre_body = pop_stmt_list (pre_body);
10503 body = push_stmt_list ();
10504 RECUR (OMP_FOR_BODY (t));
10505 body = pop_stmt_list (body);
10507 t = finish_omp_for (EXPR_LOCATION (t), decl, init, cond, incr, body,
10510 OMP_FOR_CLAUSES (t) = clauses;
10512 add_stmt (finish_omp_structured_block (stmt));
10518 tmp = tsubst_omp_clauses (OMP_CLAUSES (t), args, complain, in_decl);
10519 stmt = push_stmt_list ();
10520 RECUR (OMP_BODY (t));
10521 stmt = pop_stmt_list (stmt);
10524 OMP_BODY (t) = stmt;
10525 OMP_CLAUSES (t) = tmp;
10533 stmt = push_stmt_list ();
10534 RECUR (OMP_BODY (t));
10535 stmt = pop_stmt_list (stmt);
10538 OMP_BODY (t) = stmt;
10543 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t));
10545 tree op1 = TREE_OPERAND (t, 1);
10546 tree lhs = RECUR (TREE_OPERAND (op1, 0));
10547 tree rhs = RECUR (TREE_OPERAND (op1, 1));
10548 finish_omp_atomic (TREE_CODE (op1), lhs, rhs);
10552 case EXPR_PACK_EXPANSION:
10553 error ("invalid use of pack expansion expression");
10554 return error_mark_node;
10556 case NONTYPE_ARGUMENT_PACK:
10557 error ("use %<...%> to expand argument pack");
10558 return error_mark_node;
10561 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t)));
10563 return tsubst_copy_and_build (t, args, complain, in_decl,
10564 /*function_p=*/false,
10565 integral_constant_expression_p);
10572 /* T is a postfix-expression that is not being used in a function
10573 call. Return the substituted version of T. */
10576 tsubst_non_call_postfix_expression (tree t, tree args,
10577 tsubst_flags_t complain,
10580 if (TREE_CODE (t) == SCOPE_REF)
10581 t = tsubst_qualified_id (t, args, complain, in_decl,
10582 /*done=*/false, /*address_p=*/false);
10584 t = tsubst_copy_and_build (t, args, complain, in_decl,
10585 /*function_p=*/false,
10586 /*integral_constant_expression_p=*/false);
10591 /* Like tsubst but deals with expressions and performs semantic
10592 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
10595 tsubst_copy_and_build (tree t,
10597 tsubst_flags_t complain,
10600 bool integral_constant_expression_p)
10602 #define RECUR(NODE) \
10603 tsubst_copy_and_build (NODE, args, complain, in_decl, \
10604 /*function_p=*/false, \
10605 integral_constant_expression_p)
10609 if (t == NULL_TREE || t == error_mark_node)
10612 switch (TREE_CODE (t))
10616 /* Fall through. */
10617 case IDENTIFIER_NODE:
10621 bool non_integral_constant_expression_p;
10622 const char *error_msg;
10624 if (IDENTIFIER_TYPENAME_P (t))
10626 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10627 t = mangle_conv_op_name_for_type (new_type);
10630 /* Look up the name. */
10631 decl = lookup_name (t);
10633 /* By convention, expressions use ERROR_MARK_NODE to indicate
10634 failure, not NULL_TREE. */
10635 if (decl == NULL_TREE)
10636 decl = error_mark_node;
10638 decl = finish_id_expression (t, decl, NULL_TREE,
10640 integral_constant_expression_p,
10641 /*allow_non_integral_constant_expression_p=*/false,
10642 &non_integral_constant_expression_p,
10643 /*template_p=*/false,
10645 /*address_p=*/false,
10646 /*template_arg_p=*/false,
10650 if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE)
10651 decl = unqualified_name_lookup_error (decl);
10655 case TEMPLATE_ID_EXPR:
10658 tree template = RECUR (TREE_OPERAND (t, 0));
10659 tree targs = TREE_OPERAND (t, 1);
10662 targs = tsubst_template_args (targs, args, complain, in_decl);
10664 if (TREE_CODE (template) == COMPONENT_REF)
10666 object = TREE_OPERAND (template, 0);
10667 template = TREE_OPERAND (template, 1);
10670 object = NULL_TREE;
10671 template = lookup_template_function (template, targs);
10674 return build3 (COMPONENT_REF, TREE_TYPE (template),
10675 object, template, NULL_TREE);
10677 return baselink_for_fns (template);
10682 tree r = RECUR (TREE_OPERAND (t, 0));
10684 if (REFERENCE_REF_P (t))
10686 /* A type conversion to reference type will be enclosed in
10687 such an indirect ref, but the substitution of the cast
10688 will have also added such an indirect ref. */
10689 if (TREE_CODE (TREE_TYPE (r)) == REFERENCE_TYPE)
10690 r = convert_from_reference (r);
10693 r = build_x_indirect_ref (r, "unary *");
10699 (tsubst (TREE_TYPE (t), args, complain, in_decl),
10700 RECUR (TREE_OPERAND (t, 0)));
10703 case REINTERPRET_CAST_EXPR:
10704 case CONST_CAST_EXPR:
10705 case DYNAMIC_CAST_EXPR:
10706 case STATIC_CAST_EXPR:
10711 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10712 if (integral_constant_expression_p
10713 && !cast_valid_in_integral_constant_expression_p (type))
10715 error ("a cast to a type other than an integral or "
10716 "enumeration type cannot appear in a constant-expression");
10717 return error_mark_node;
10720 op = RECUR (TREE_OPERAND (t, 0));
10722 switch (TREE_CODE (t))
10725 return build_functional_cast (type, op);
10726 case REINTERPRET_CAST_EXPR:
10727 return build_reinterpret_cast (type, op);
10728 case CONST_CAST_EXPR:
10729 return build_const_cast (type, op);
10730 case DYNAMIC_CAST_EXPR:
10731 return build_dynamic_cast (type, op);
10732 case STATIC_CAST_EXPR:
10733 return build_static_cast (type, op);
10735 gcc_unreachable ();
10739 case POSTDECREMENT_EXPR:
10740 case POSTINCREMENT_EXPR:
10741 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
10742 args, complain, in_decl);
10743 return build_x_unary_op (TREE_CODE (t), op1);
10745 case PREDECREMENT_EXPR:
10746 case PREINCREMENT_EXPR:
10750 case TRUTH_NOT_EXPR:
10751 case UNARY_PLUS_EXPR: /* Unary + */
10752 case REALPART_EXPR:
10753 case IMAGPART_EXPR:
10754 return build_x_unary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0)));
10757 op1 = TREE_OPERAND (t, 0);
10758 if (TREE_CODE (op1) == SCOPE_REF)
10759 op1 = tsubst_qualified_id (op1, args, complain, in_decl,
10760 /*done=*/true, /*address_p=*/true);
10762 op1 = tsubst_non_call_postfix_expression (op1, args, complain,
10764 if (TREE_CODE (op1) == LABEL_DECL)
10765 return finish_label_address_expr (DECL_NAME (op1));
10766 return build_x_unary_op (ADDR_EXPR, op1);
10771 case TRUNC_DIV_EXPR:
10772 case CEIL_DIV_EXPR:
10773 case FLOOR_DIV_EXPR:
10774 case ROUND_DIV_EXPR:
10775 case EXACT_DIV_EXPR:
10779 case TRUNC_MOD_EXPR:
10780 case FLOOR_MOD_EXPR:
10781 case TRUTH_ANDIF_EXPR:
10782 case TRUTH_ORIF_EXPR:
10783 case TRUTH_AND_EXPR:
10784 case TRUTH_OR_EXPR:
10799 return build_x_binary_op
10801 RECUR (TREE_OPERAND (t, 0)),
10802 (TREE_NO_WARNING (TREE_OPERAND (t, 0))
10804 : TREE_CODE (TREE_OPERAND (t, 0))),
10805 RECUR (TREE_OPERAND (t, 1)),
10806 (TREE_NO_WARNING (TREE_OPERAND (t, 1))
10808 : TREE_CODE (TREE_OPERAND (t, 1))),
10809 /*overloaded_p=*/NULL);
10812 return tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
10813 /*address_p=*/false);
10815 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
10816 args, complain, in_decl);
10817 return build_x_binary_op (ARRAY_REF, op1,
10818 (TREE_NO_WARNING (TREE_OPERAND (t, 0))
10820 : TREE_CODE (TREE_OPERAND (t, 0))),
10821 RECUR (TREE_OPERAND (t, 1)),
10822 (TREE_NO_WARNING (TREE_OPERAND (t, 1))
10824 : TREE_CODE (TREE_OPERAND (t, 1))),
10825 /*overloaded_p=*/NULL);
10828 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
10830 /* We only want to compute the number of arguments. */
10831 tree expanded = tsubst_pack_expansion (TREE_OPERAND (t, 0), args,
10832 complain, in_decl);
10833 if (expanded == error_mark_node)
10834 return error_mark_node;
10835 return build_int_cst (size_type_node, TREE_VEC_LENGTH (expanded));
10840 op1 = TREE_OPERAND (t, 0);
10843 /* When there are no ARGS, we are trying to evaluate a
10844 non-dependent expression from the parser. Trying to do
10845 the substitutions may not work. */
10847 op1 = TREE_TYPE (op1);
10852 op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
10853 /*function_p=*/false,
10854 /*integral_constant_expression_p=*/false);
10858 return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t), true);
10860 return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t));
10864 tree r = build_x_modify_expr
10865 (RECUR (TREE_OPERAND (t, 0)),
10866 TREE_CODE (TREE_OPERAND (t, 1)),
10867 RECUR (TREE_OPERAND (t, 2)));
10868 /* TREE_NO_WARNING must be set if either the expression was
10869 parenthesized or it uses an operator such as >>= rather
10870 than plain assignment. In the former case, it was already
10871 set and must be copied. In the latter case,
10872 build_x_modify_expr sets it and it must not be reset
10874 if (TREE_NO_WARNING (t))
10875 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
10880 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
10881 args, complain, in_decl);
10882 /* Remember that there was a reference to this entity. */
10885 return build_x_arrow (op1);
10889 tree init = RECUR (TREE_OPERAND (t, 3));
10891 if (TREE_OPERAND (t, 3) && !init)
10892 /* If there was an initializer in the the original tree, but
10893 it instantiated to an empty list, then we should pass on
10894 VOID_ZERO_NODE to tell build_new that it was an empty
10895 initializer () rather than no initializer. This can only
10896 happen when the initializer is a pack expansion whose
10897 parameter packs are of length zero. */
10898 init = void_zero_node;
10901 (RECUR (TREE_OPERAND (t, 0)),
10902 RECUR (TREE_OPERAND (t, 1)),
10903 RECUR (TREE_OPERAND (t, 2)),
10905 NEW_EXPR_USE_GLOBAL (t));
10909 return delete_sanity
10910 (RECUR (TREE_OPERAND (t, 0)),
10911 RECUR (TREE_OPERAND (t, 1)),
10912 DELETE_EXPR_USE_VEC (t),
10913 DELETE_EXPR_USE_GLOBAL (t));
10915 case COMPOUND_EXPR:
10916 return build_x_compound_expr (RECUR (TREE_OPERAND (t, 0)),
10917 RECUR (TREE_OPERAND (t, 1)));
10926 function = CALL_EXPR_FN (t);
10927 /* When we parsed the expression, we determined whether or
10928 not Koenig lookup should be performed. */
10929 koenig_p = KOENIG_LOOKUP_P (t);
10930 if (TREE_CODE (function) == SCOPE_REF)
10932 qualified_p = true;
10933 function = tsubst_qualified_id (function, args, complain, in_decl,
10935 /*address_p=*/false);
10939 if (TREE_CODE (function) == COMPONENT_REF)
10941 tree op = TREE_OPERAND (function, 1);
10943 qualified_p = (TREE_CODE (op) == SCOPE_REF
10944 || (BASELINK_P (op)
10945 && BASELINK_QUALIFIED_P (op)));
10948 qualified_p = false;
10950 function = tsubst_copy_and_build (function, args, complain,
10953 integral_constant_expression_p);
10955 if (BASELINK_P (function))
10956 qualified_p = true;
10959 /* FIXME: Rewrite this so as not to construct an arglist. */
10960 call_args = RECUR (CALL_EXPR_ARGS (t));
10962 /* We do not perform argument-dependent lookup if normal
10963 lookup finds a non-function, in accordance with the
10964 expected resolution of DR 218. */
10966 && ((is_overloaded_fn (function)
10967 /* If lookup found a member function, the Koenig lookup is
10968 not appropriate, even if an unqualified-name was used
10969 to denote the function. */
10970 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function)))
10971 || TREE_CODE (function) == IDENTIFIER_NODE))
10972 function = perform_koenig_lookup (function, call_args);
10974 if (TREE_CODE (function) == IDENTIFIER_NODE)
10976 unqualified_name_lookup_error (function);
10977 return error_mark_node;
10980 /* Remember that there was a reference to this entity. */
10981 if (DECL_P (function))
10982 mark_used (function);
10984 if (TREE_CODE (function) == OFFSET_REF)
10985 return build_offset_ref_call_from_tree (function, call_args);
10986 if (TREE_CODE (function) == COMPONENT_REF)
10988 if (!BASELINK_P (TREE_OPERAND (function, 1)))
10989 return finish_call_expr (function, call_args,
10990 /*disallow_virtual=*/false,
10991 /*koenig_p=*/false);
10993 return (build_new_method_call
10994 (TREE_OPERAND (function, 0),
10995 TREE_OPERAND (function, 1),
10996 call_args, NULL_TREE,
10997 qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL,
11000 return finish_call_expr (function, call_args,
11001 /*disallow_virtual=*/qualified_p,
11006 return build_x_conditional_expr
11007 (RECUR (TREE_OPERAND (t, 0)),
11008 RECUR (TREE_OPERAND (t, 1)),
11009 RECUR (TREE_OPERAND (t, 2)));
11011 case PSEUDO_DTOR_EXPR:
11012 return finish_pseudo_destructor_expr
11013 (RECUR (TREE_OPERAND (t, 0)),
11014 RECUR (TREE_OPERAND (t, 1)),
11015 RECUR (TREE_OPERAND (t, 2)));
11019 tree purpose, value, chain;
11021 if (t == void_list_node)
11024 if ((TREE_PURPOSE (t) && PACK_EXPANSION_P (TREE_PURPOSE (t)))
11025 || (TREE_VALUE (t) && PACK_EXPANSION_P (TREE_VALUE (t))))
11027 /* We have pack expansions, so expand those and
11028 create a new list out of it. */
11029 tree purposevec = NULL_TREE;
11030 tree valuevec = NULL_TREE;
11034 /* Expand the argument expressions. */
11035 if (TREE_PURPOSE (t))
11036 purposevec = tsubst_pack_expansion (TREE_PURPOSE (t), args,
11037 complain, in_decl);
11038 if (TREE_VALUE (t))
11039 valuevec = tsubst_pack_expansion (TREE_VALUE (t), args,
11040 complain, in_decl);
11042 /* Build the rest of the list. */
11043 chain = TREE_CHAIN (t);
11044 if (chain && chain != void_type_node)
11045 chain = RECUR (chain);
11047 /* Determine the number of arguments. */
11048 if (purposevec && TREE_CODE (purposevec) == TREE_VEC)
11050 len = TREE_VEC_LENGTH (purposevec);
11051 gcc_assert (!valuevec || len == TREE_VEC_LENGTH (valuevec));
11053 else if (TREE_CODE (valuevec) == TREE_VEC)
11054 len = TREE_VEC_LENGTH (valuevec);
11057 /* Since we only performed a partial substitution into
11058 the argument pack, we only return a single list
11060 if (purposevec == TREE_PURPOSE (t)
11061 && valuevec == TREE_VALUE (t)
11062 && chain == TREE_CHAIN (t))
11065 return tree_cons (purposevec, valuevec, chain);
11068 /* Convert the argument vectors into a TREE_LIST */
11072 /* Grab the Ith values. */
11074 purpose = purposevec ? TREE_VEC_ELT (purposevec, i)
11077 = valuevec ? convert_from_reference (TREE_VEC_ELT (valuevec, i))
11080 /* Build the list (backwards). */
11081 chain = tree_cons (purpose, value, chain);
11087 purpose = TREE_PURPOSE (t);
11089 purpose = RECUR (purpose);
11090 value = TREE_VALUE (t);
11092 value = RECUR (value);
11093 chain = TREE_CHAIN (t);
11094 if (chain && chain != void_type_node)
11095 chain = RECUR (chain);
11096 if (purpose == TREE_PURPOSE (t)
11097 && value == TREE_VALUE (t)
11098 && chain == TREE_CHAIN (t))
11100 return tree_cons (purpose, value, chain);
11103 case COMPONENT_REF:
11109 object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
11110 args, complain, in_decl);
11111 /* Remember that there was a reference to this entity. */
11112 if (DECL_P (object))
11113 mark_used (object);
11114 object_type = TREE_TYPE (object);
11116 member = TREE_OPERAND (t, 1);
11117 if (BASELINK_P (member))
11118 member = tsubst_baselink (member,
11119 non_reference (TREE_TYPE (object)),
11120 args, complain, in_decl);
11122 member = tsubst_copy (member, args, complain, in_decl);
11123 if (member == error_mark_node)
11124 return error_mark_node;
11126 if (object_type && !CLASS_TYPE_P (object_type))
11128 if (SCALAR_TYPE_P (object_type))
11130 tree s = NULL_TREE;
11131 tree dtor = member;
11133 if (TREE_CODE (dtor) == SCOPE_REF)
11135 s = TREE_OPERAND (dtor, 0);
11136 dtor = TREE_OPERAND (dtor, 1);
11138 if (TREE_CODE (dtor) == BIT_NOT_EXPR)
11140 dtor = TREE_OPERAND (dtor, 0);
11142 return finish_pseudo_destructor_expr (object, s, dtor);
11146 else if (TREE_CODE (member) == SCOPE_REF
11147 && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
11152 /* Lookup the template functions now that we know what the
11154 tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
11155 args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
11156 member = lookup_qualified_name (TREE_OPERAND (member, 0), tmpl,
11157 /*is_type_p=*/false,
11158 /*complain=*/false);
11159 if (BASELINK_P (member))
11161 BASELINK_FUNCTIONS (member)
11162 = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
11164 member = (adjust_result_of_qualified_name_lookup
11165 (member, BINFO_TYPE (BASELINK_BINFO (member)),
11170 qualified_name_lookup_error (object_type, tmpl, member);
11171 return error_mark_node;
11174 else if (TREE_CODE (member) == SCOPE_REF
11175 && !CLASS_TYPE_P (TREE_OPERAND (member, 0))
11176 && TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL)
11178 if (complain & tf_error)
11180 if (TYPE_P (TREE_OPERAND (member, 0)))
11181 error ("%qT is not a class or namespace",
11182 TREE_OPERAND (member, 0));
11184 error ("%qD is not a class or namespace",
11185 TREE_OPERAND (member, 0));
11187 return error_mark_node;
11189 else if (TREE_CODE (member) == FIELD_DECL)
11190 return finish_non_static_data_member (member, object, NULL_TREE);
11192 return finish_class_member_access_expr (object, member,
11193 /*template_p=*/false);
11198 (RECUR (TREE_OPERAND (t, 0)));
11202 VEC(constructor_elt,gc) *n;
11203 constructor_elt *ce;
11204 unsigned HOST_WIDE_INT idx;
11205 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
11206 bool process_index_p;
11208 bool need_copy_p = false;
11210 if (type == error_mark_node)
11211 return error_mark_node;
11213 /* digest_init will do the wrong thing if we let it. */
11214 if (type && TYPE_PTRMEMFUNC_P (type))
11217 /* We do not want to process the index of aggregate
11218 initializers as they are identifier nodes which will be
11219 looked up by digest_init. */
11220 process_index_p = !(type && IS_AGGR_TYPE (type));
11222 n = VEC_copy (constructor_elt, gc, CONSTRUCTOR_ELTS (t));
11223 newlen = VEC_length (constructor_elt, n);
11224 for (idx = 0; VEC_iterate (constructor_elt, n, idx, ce); idx++)
11226 if (ce->index && process_index_p)
11227 ce->index = RECUR (ce->index);
11229 if (PACK_EXPANSION_P (ce->value))
11231 /* Substitute into the pack expansion. */
11232 ce->value = tsubst_pack_expansion (ce->value, args, complain,
11235 if (ce->value == error_mark_node)
11237 else if (TREE_VEC_LENGTH (ce->value) == 1)
11238 /* Just move the argument into place. */
11239 ce->value = TREE_VEC_ELT (ce->value, 0);
11242 /* Update the length of the final CONSTRUCTOR
11243 arguments vector, and note that we will need to
11245 newlen = newlen + TREE_VEC_LENGTH (ce->value) - 1;
11246 need_copy_p = true;
11250 ce->value = RECUR (ce->value);
11255 VEC(constructor_elt,gc) *old_n = n;
11257 n = VEC_alloc (constructor_elt, gc, newlen);
11258 for (idx = 0; VEC_iterate (constructor_elt, old_n, idx, ce);
11261 if (TREE_CODE (ce->value) == TREE_VEC)
11263 int i, len = TREE_VEC_LENGTH (ce->value);
11264 for (i = 0; i < len; ++i)
11265 CONSTRUCTOR_APPEND_ELT (n, 0,
11266 TREE_VEC_ELT (ce->value, i));
11269 CONSTRUCTOR_APPEND_ELT (n, 0, ce->value);
11273 if (TREE_HAS_CONSTRUCTOR (t))
11274 return finish_compound_literal (type, n);
11276 return build_constructor (NULL_TREE, n);
11281 tree operand_0 = RECUR (TREE_OPERAND (t, 0));
11282 if (TYPE_P (operand_0))
11283 return get_typeid (operand_0);
11284 return build_typeid (operand_0);
11294 tree r = tsubst_copy (t, args, complain, in_decl);
11296 if (TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
11297 /* If the original type was a reference, we'll be wrapped in
11298 the appropriate INDIRECT_REF. */
11299 r = convert_from_reference (r);
11304 return build_x_va_arg (RECUR (TREE_OPERAND (t, 0)),
11305 tsubst_copy (TREE_TYPE (t), args, complain,
11308 case OFFSETOF_EXPR:
11309 return finish_offsetof (RECUR (TREE_OPERAND (t, 0)));
11313 tree type1 = tsubst_copy (TRAIT_EXPR_TYPE1 (t), args,
11314 complain, in_decl);
11316 tree type2 = TRAIT_EXPR_TYPE2 (t);
11318 type2 = tsubst_copy (type2, args, complain, in_decl);
11320 return finish_trait_expr (TRAIT_EXPR_KIND (t), type1, type2);
11325 tree old_stmt_expr = cur_stmt_expr;
11326 tree stmt_expr = begin_stmt_expr ();
11328 cur_stmt_expr = stmt_expr;
11329 tsubst_expr (STMT_EXPR_STMT (t), args, complain, in_decl,
11330 integral_constant_expression_p);
11331 stmt_expr = finish_stmt_expr (stmt_expr, false);
11332 cur_stmt_expr = old_stmt_expr;
11338 t = tsubst_copy (t, args, complain, in_decl);
11339 /* As in finish_id_expression, we resolve enumeration constants
11340 to their underlying values. */
11341 if (TREE_CODE (t) == CONST_DECL)
11343 used_types_insert (TREE_TYPE (t));
11344 return DECL_INITIAL (t);
11349 /* Handle Objective-C++ constructs, if appropriate. */
11352 = objcp_tsubst_copy_and_build (t, args, complain,
11353 in_decl, /*function_p=*/false);
11357 return tsubst_copy (t, args, complain, in_decl);
11363 /* Verify that the instantiated ARGS are valid. For type arguments,
11364 make sure that the type's linkage is ok. For non-type arguments,
11365 make sure they are constants if they are integral or enumerations.
11366 Emit an error under control of COMPLAIN, and return TRUE on error. */
11369 check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain)
11371 int ix, len = DECL_NTPARMS (tmpl);
11372 bool result = false;
11374 for (ix = 0; ix != len; ix++)
11376 tree t = TREE_VEC_ELT (args, ix);
11380 /* [basic.link]: A name with no linkage (notably, the name
11381 of a class or enumeration declared in a local scope)
11382 shall not be used to declare an entity with linkage.
11383 This implies that names with no linkage cannot be used as
11384 template arguments. */
11385 tree nt = no_linkage_check (t, /*relaxed_p=*/false);
11389 /* DR 488 makes use of a type with no linkage cause
11390 type deduction to fail. */
11391 if (complain & tf_error)
11393 if (TYPE_ANONYMOUS_P (nt))
11394 error ("%qT is/uses anonymous type", t);
11396 error ("template argument for %qD uses local type %qT",
11401 /* In order to avoid all sorts of complications, we do not
11402 allow variably-modified types as template arguments. */
11403 else if (variably_modified_type_p (t, NULL_TREE))
11405 if (complain & tf_error)
11406 error ("%qT is a variably modified type", t);
11410 /* A non-type argument of integral or enumerated type must be a
11412 else if (TREE_TYPE (t)
11413 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t))
11414 && !TREE_CONSTANT (t))
11416 if (complain & tf_error)
11417 error ("integral expression %qE is not constant", t);
11421 if (result && (complain & tf_error))
11422 error (" trying to instantiate %qD", tmpl);
11426 /* Instantiate the indicated variable or function template TMPL with
11427 the template arguments in TARG_PTR. */
11430 instantiate_template (tree tmpl, tree targ_ptr, tsubst_flags_t complain)
11435 HOST_WIDE_INT saved_processing_template_decl;
11437 if (tmpl == error_mark_node)
11438 return error_mark_node;
11440 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
11442 /* If this function is a clone, handle it specially. */
11443 if (DECL_CLONED_FUNCTION_P (tmpl))
11448 spec = instantiate_template (DECL_CLONED_FUNCTION (tmpl), targ_ptr,
11450 if (spec == error_mark_node)
11451 return error_mark_node;
11453 /* Look for the clone. */
11454 FOR_EACH_CLONE (clone, spec)
11455 if (DECL_NAME (clone) == DECL_NAME (tmpl))
11457 /* We should always have found the clone by now. */
11458 gcc_unreachable ();
11462 /* Check to see if we already have this specialization. */
11463 spec = retrieve_specialization (tmpl, targ_ptr,
11464 /*class_specializations_p=*/false);
11465 if (spec != NULL_TREE)
11468 gen_tmpl = most_general_template (tmpl);
11469 if (tmpl != gen_tmpl)
11471 /* The TMPL is a partial instantiation. To get a full set of
11472 arguments we must add the arguments used to perform the
11473 partial instantiation. */
11474 targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl),
11477 /* Check to see if we already have this specialization. */
11478 spec = retrieve_specialization (gen_tmpl, targ_ptr,
11479 /*class_specializations_p=*/false);
11480 if (spec != NULL_TREE)
11484 if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr),
11486 return error_mark_node;
11488 /* We are building a FUNCTION_DECL, during which the access of its
11489 parameters and return types have to be checked. However this
11490 FUNCTION_DECL which is the desired context for access checking
11491 is not built yet. We solve this chicken-and-egg problem by
11492 deferring all checks until we have the FUNCTION_DECL. */
11493 push_deferring_access_checks (dk_deferred);
11495 /* Although PROCESSING_TEMPLATE_DECL may be true at this point
11496 (because, for example, we have encountered a non-dependent
11497 function call in the body of a template function and must now
11498 determine which of several overloaded functions will be called),
11499 within the instantiation itself we are not processing a
11501 saved_processing_template_decl = processing_template_decl;
11502 processing_template_decl = 0;
11503 /* Substitute template parameters to obtain the specialization. */
11504 fndecl = tsubst (DECL_TEMPLATE_RESULT (gen_tmpl),
11505 targ_ptr, complain, gen_tmpl);
11506 processing_template_decl = saved_processing_template_decl;
11507 if (fndecl == error_mark_node)
11508 return error_mark_node;
11510 /* Now we know the specialization, compute access previously
11512 push_access_scope (fndecl);
11513 perform_deferred_access_checks ();
11514 pop_access_scope (fndecl);
11515 pop_deferring_access_checks ();
11517 /* The DECL_TI_TEMPLATE should always be the immediate parent
11518 template, not the most general template. */
11519 DECL_TI_TEMPLATE (fndecl) = tmpl;
11521 /* If we've just instantiated the main entry point for a function,
11522 instantiate all the alternate entry points as well. We do this
11523 by cloning the instantiation of the main entry point, not by
11524 instantiating the template clones. */
11525 if (TREE_CHAIN (gen_tmpl) && DECL_CLONED_FUNCTION_P (TREE_CHAIN (gen_tmpl)))
11526 clone_function_decl (fndecl, /*update_method_vec_p=*/0);
11531 /* The FN is a TEMPLATE_DECL for a function. The ARGS are the
11532 arguments that are being used when calling it. TARGS is a vector
11533 into which the deduced template arguments are placed.
11535 Return zero for success, 2 for an incomplete match that doesn't resolve
11536 all the types, and 1 for complete failure. An error message will be
11537 printed only for an incomplete match.
11539 If FN is a conversion operator, or we are trying to produce a specific
11540 specialization, RETURN_TYPE is the return type desired.
11542 The EXPLICIT_TARGS are explicit template arguments provided via a
11545 The parameter STRICT is one of:
11548 We are deducing arguments for a function call, as in
11549 [temp.deduct.call].
11552 We are deducing arguments for a conversion function, as in
11553 [temp.deduct.conv].
11556 We are deducing arguments when doing an explicit instantiation
11557 as in [temp.explicit], when determining an explicit specialization
11558 as in [temp.expl.spec], or when taking the address of a function
11559 template, as in [temp.deduct.funcaddr]. */
11562 fn_type_unification (tree fn,
11563 tree explicit_targs,
11567 unification_kind_t strict,
11573 bool incomplete_argument_packs_p = false;
11575 gcc_assert (TREE_CODE (fn) == TEMPLATE_DECL);
11577 fntype = TREE_TYPE (fn);
11578 if (explicit_targs)
11582 The specified template arguments must match the template
11583 parameters in kind (i.e., type, nontype, template), and there
11584 must not be more arguments than there are parameters;
11585 otherwise type deduction fails.
11587 Nontype arguments must match the types of the corresponding
11588 nontype template parameters, or must be convertible to the
11589 types of the corresponding nontype parameters as specified in
11590 _temp.arg.nontype_, otherwise type deduction fails.
11592 All references in the function type of the function template
11593 to the corresponding template parameters are replaced by the
11594 specified template argument values. If a substitution in a
11595 template parameter or in the function type of the function
11596 template results in an invalid type, type deduction fails. */
11597 tree tparms = DECL_INNERMOST_TEMPLATE_PARMS (fn);
11598 int i, len = TREE_VEC_LENGTH (tparms);
11599 tree converted_args;
11600 bool incomplete = false;
11602 if (explicit_targs == error_mark_node)
11606 = (coerce_template_parms (tparms, explicit_targs, NULL_TREE, tf_none,
11607 /*require_all_args=*/false,
11608 /*use_default_args=*/false));
11609 if (converted_args == error_mark_node)
11612 /* Substitute the explicit args into the function type. This is
11613 necessary so that, for instance, explicitly declared function
11614 arguments can match null pointed constants. If we were given
11615 an incomplete set of explicit args, we must not do semantic
11616 processing during substitution as we could create partial
11618 for (i = 0; i < len; i++)
11620 tree parm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
11621 bool parameter_pack = false;
11623 /* Dig out the actual parm. */
11624 if (TREE_CODE (parm) == TYPE_DECL
11625 || TREE_CODE (parm) == TEMPLATE_DECL)
11627 parm = TREE_TYPE (parm);
11628 parameter_pack = TEMPLATE_TYPE_PARAMETER_PACK (parm);
11630 else if (TREE_CODE (parm) == PARM_DECL)
11632 parm = DECL_INITIAL (parm);
11633 parameter_pack = TEMPLATE_PARM_PARAMETER_PACK (parm);
11636 if (parameter_pack)
11640 template_parm_level_and_index (parm, &level, &idx);
11642 /* Mark the argument pack as "incomplete". We could
11643 still deduce more arguments during unification. */
11644 targ = TMPL_ARG (converted_args, level, idx);
11647 ARGUMENT_PACK_INCOMPLETE_P(targ) = 1;
11648 ARGUMENT_PACK_EXPLICIT_ARGS (targ)
11649 = ARGUMENT_PACK_ARGS (targ);
11652 /* We have some incomplete argument packs. */
11653 incomplete_argument_packs_p = true;
11657 if (incomplete_argument_packs_p)
11658 /* Any substitution is guaranteed to be incomplete if there
11659 are incomplete argument packs, because we can still deduce
11663 incomplete = NUM_TMPL_ARGS (explicit_targs) != NUM_TMPL_ARGS (targs);
11665 processing_template_decl += incomplete;
11666 fntype = tsubst (fntype, converted_args, tf_none, NULL_TREE);
11667 processing_template_decl -= incomplete;
11669 if (fntype == error_mark_node)
11672 /* Place the explicitly specified arguments in TARGS. */
11673 for (i = NUM_TMPL_ARGS (converted_args); i--;)
11674 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i);
11677 /* Never do unification on the 'this' parameter. */
11678 parms = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (fntype));
11682 parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms);
11683 args = tree_cons (NULL_TREE, return_type, args);
11686 /* We allow incomplete unification without an error message here
11687 because the standard doesn't seem to explicitly prohibit it. Our
11688 callers must be ready to deal with unification failures in any
11690 result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
11691 targs, parms, args, /*subr=*/0,
11694 if (result == 0 && incomplete_argument_packs_p)
11696 int i, len = NUM_TMPL_ARGS (targs);
11698 /* Clear the "incomplete" flags on all argument packs. */
11699 for (i = 0; i < len; i++)
11701 tree arg = TREE_VEC_ELT (targs, i);
11702 if (ARGUMENT_PACK_P (arg))
11704 ARGUMENT_PACK_INCOMPLETE_P (arg) = 0;
11705 ARGUMENT_PACK_EXPLICIT_ARGS (arg) = NULL_TREE;
11710 /* Now that we have bindings for all of the template arguments,
11711 ensure that the arguments deduced for the template template
11712 parameters have compatible template parameter lists. We cannot
11713 check this property before we have deduced all template
11714 arguments, because the template parameter types of a template
11715 template parameter might depend on prior template parameters
11716 deduced after the template template parameter. The following
11717 ill-formed example illustrates this issue:
11719 template<typename T, template<T> class C> void f(C<5>, T);
11721 template<int N> struct X {};
11724 f(X<5>(), 5l); // error: template argument deduction fails
11727 The template parameter list of 'C' depends on the template type
11728 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
11729 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
11730 time that we deduce 'C'. */
11732 && !template_template_parm_bindings_ok_p
11733 (DECL_INNERMOST_TEMPLATE_PARMS (fn), targs))
11737 /* All is well so far. Now, check:
11741 When all template arguments have been deduced, all uses of
11742 template parameters in nondeduced contexts are replaced with
11743 the corresponding deduced argument values. If the
11744 substitution results in an invalid type, as described above,
11745 type deduction fails. */
11746 if (tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE)
11747 == error_mark_node)
11753 /* Adjust types before performing type deduction, as described in
11754 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
11755 sections are symmetric. PARM is the type of a function parameter
11756 or the return type of the conversion function. ARG is the type of
11757 the argument passed to the call, or the type of the value
11758 initialized with the result of the conversion function.
11759 ARG_EXPR is the original argument expression, which may be null. */
11762 maybe_adjust_types_for_deduction (unification_kind_t strict,
11776 /* Swap PARM and ARG throughout the remainder of this
11777 function; the handling is precisely symmetric since PARM
11778 will initialize ARG rather than vice versa. */
11786 /* There is nothing to do in this case. */
11790 gcc_unreachable ();
11793 if (TREE_CODE (*parm) != REFERENCE_TYPE)
11795 /* [temp.deduct.call]
11797 If P is not a reference type:
11799 --If A is an array type, the pointer type produced by the
11800 array-to-pointer standard conversion (_conv.array_) is
11801 used in place of A for type deduction; otherwise,
11803 --If A is a function type, the pointer type produced by
11804 the function-to-pointer standard conversion
11805 (_conv.func_) is used in place of A for type deduction;
11808 --If A is a cv-qualified type, the top level
11809 cv-qualifiers of A's type are ignored for type
11811 if (TREE_CODE (*arg) == ARRAY_TYPE)
11812 *arg = build_pointer_type (TREE_TYPE (*arg));
11813 else if (TREE_CODE (*arg) == FUNCTION_TYPE)
11814 *arg = build_pointer_type (*arg);
11816 *arg = TYPE_MAIN_VARIANT (*arg);
11819 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
11820 of the form T&&, where T is a template parameter, and the argument
11821 is an lvalue, T is deduced as A& */
11822 if (TREE_CODE (*parm) == REFERENCE_TYPE
11823 && TYPE_REF_IS_RVALUE (*parm)
11824 && TREE_CODE (TREE_TYPE (*parm)) == TEMPLATE_TYPE_PARM
11825 && cp_type_quals (TREE_TYPE (*parm)) == TYPE_UNQUALIFIED
11826 && arg_expr && real_lvalue_p (arg_expr))
11827 *arg = build_reference_type (*arg);
11829 /* [temp.deduct.call]
11831 If P is a cv-qualified type, the top level cv-qualifiers
11832 of P's type are ignored for type deduction. If P is a
11833 reference type, the type referred to by P is used for
11835 *parm = TYPE_MAIN_VARIANT (*parm);
11836 if (TREE_CODE (*parm) == REFERENCE_TYPE)
11838 *parm = TREE_TYPE (*parm);
11839 result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
11842 /* DR 322. For conversion deduction, remove a reference type on parm
11843 too (which has been swapped into ARG). */
11844 if (strict == DEDUCE_CONV && TREE_CODE (*arg) == REFERENCE_TYPE)
11845 *arg = TREE_TYPE (*arg);
11850 /* Most parms like fn_type_unification.
11852 If SUBR is 1, we're being called recursively (to unify the
11853 arguments of a function or method parameter of a function
11857 type_unification_real (tree tparms,
11862 unification_kind_t strict,
11865 tree parm, arg, arg_expr;
11867 int ntparms = TREE_VEC_LENGTH (tparms);
11869 int saw_undeduced = 0;
11872 gcc_assert (TREE_CODE (tparms) == TREE_VEC);
11873 gcc_assert (xparms == NULL_TREE || TREE_CODE (xparms) == TREE_LIST);
11874 gcc_assert (!xargs || TREE_CODE (xargs) == TREE_LIST);
11875 gcc_assert (ntparms > 0);
11880 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL | UNIFY_ALLOW_MORE_CV_QUAL
11881 | UNIFY_ALLOW_DERIVED);
11885 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
11889 sub_strict = UNIFY_ALLOW_NONE;
11893 gcc_unreachable ();
11900 while (parms && parms != void_list_node
11901 && args && args != void_list_node)
11903 if (TREE_CODE (TREE_VALUE (parms)) == TYPE_PACK_EXPANSION)
11906 parm = TREE_VALUE (parms);
11907 parms = TREE_CHAIN (parms);
11908 arg = TREE_VALUE (args);
11909 args = TREE_CHAIN (args);
11912 if (arg == error_mark_node)
11914 if (arg == unknown_type_node)
11915 /* We can't deduce anything from this, but we might get all the
11916 template args from other function args. */
11919 /* Conversions will be performed on a function argument that
11920 corresponds with a function parameter that contains only
11921 non-deducible template parameters and explicitly specified
11922 template parameters. */
11923 if (!uses_template_parms (parm))
11928 type = TREE_TYPE (arg);
11932 if (same_type_p (parm, type))
11934 if (strict != DEDUCE_EXACT
11935 && can_convert_arg (parm, type, TYPE_P (arg) ? NULL_TREE : arg,
11944 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
11945 if (type_unknown_p (arg))
11947 /* [temp.deduct.type]
11949 A template-argument can be deduced from a pointer to
11950 function or pointer to member function argument if
11951 the set of overloaded functions does not contain
11952 function templates and at most one of a set of
11953 overloaded functions provides a unique match. */
11954 if (resolve_overloaded_unification
11955 (tparms, targs, parm, arg, strict, sub_strict))
11961 arg = unlowered_expr_type (arg);
11962 if (arg == error_mark_node)
11967 int arg_strict = sub_strict;
11970 arg_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg,
11973 if (unify (tparms, targs, parm, arg, arg_strict))
11980 && parms != void_list_node
11981 && TREE_CODE (TREE_VALUE (parms)) == TYPE_PACK_EXPANSION)
11983 /* Unify the remaining arguments with the pack expansion type. */
11985 tree parmvec = make_tree_vec (1);
11989 /* Count the number of arguments that remain. */
11990 for (t = args; t && t != void_list_node; t = TREE_CHAIN (t))
11993 /* Allocate a TREE_VEC and copy in all of the arguments */
11994 argvec = make_tree_vec (len);
11995 for (i = 0; args && args != void_list_node; args = TREE_CHAIN (args))
11997 TREE_VEC_ELT (argvec, i) = TREE_VALUE (args);
12001 /* Copy the parameter into parmvec. */
12002 TREE_VEC_ELT (parmvec, 0) = TREE_VALUE (parms);
12003 if (unify_pack_expansion (tparms, targs, parmvec, argvec, strict,
12004 /*call_args_p=*/true, /*subr=*/subr))
12007 /* Advance to the end of the list of parameters. */
12008 parms = TREE_CHAIN (parms);
12011 /* Fail if we've reached the end of the parm list, and more args
12012 are present, and the parm list isn't variadic. */
12013 if (args && args != void_list_node && parms == void_list_node)
12015 /* Fail if parms are left and they don't have default values. */
12016 if (parms && parms != void_list_node
12017 && TREE_PURPOSE (parms) == NULL_TREE)
12021 for (i = 0; i < ntparms; i++)
12022 if (!TREE_VEC_ELT (targs, i))
12026 if (TREE_VEC_ELT (tparms, i) == error_mark_node)
12029 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
12031 /* If this is an undeduced nontype parameter that depends on
12032 a type parameter, try another pass; its type may have been
12033 deduced from a later argument than the one from which
12034 this parameter can be deduced. */
12035 if (TREE_CODE (tparm) == PARM_DECL
12036 && uses_template_parms (TREE_TYPE (tparm))
12037 && !saw_undeduced++)
12040 /* Core issue #226 (C++0x) [temp.deduct]:
12042 If a template argument has not been deduced, its
12043 default template argument, if any, is used.
12045 When we are in C++98 mode, TREE_PURPOSE will either
12046 be NULL_TREE or ERROR_MARK_NODE, so we do not need
12047 to explicitly check cxx_dialect here. */
12048 if (TREE_PURPOSE (TREE_VEC_ELT (tparms, i)))
12050 tree arg = tsubst (TREE_PURPOSE (TREE_VEC_ELT (tparms, i)),
12051 targs, tf_none, NULL_TREE);
12052 if (arg == error_mark_node)
12056 TREE_VEC_ELT (targs, i) = arg;
12061 /* If the type parameter is a parameter pack, then it will
12062 be deduced to an empty parameter pack. */
12063 if (template_parameter_pack_p (tparm))
12067 if (TREE_CODE (tparm) == TEMPLATE_PARM_INDEX)
12069 arg = make_node (NONTYPE_ARGUMENT_PACK);
12070 TREE_TYPE (arg) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm));
12071 TREE_CONSTANT (arg) = 1;
12074 arg = make_node (TYPE_ARGUMENT_PACK);
12076 SET_ARGUMENT_PACK_ARGS (arg, make_tree_vec (0));
12078 TREE_VEC_ELT (targs, i) = arg;
12088 /* Subroutine of type_unification_real. Args are like the variables
12089 at the call site. ARG is an overloaded function (or template-id);
12090 we try deducing template args from each of the overloads, and if
12091 only one succeeds, we go with that. Modifies TARGS and returns
12092 true on success. */
12095 resolve_overloaded_unification (tree tparms,
12099 unification_kind_t strict,
12102 tree tempargs = copy_node (targs);
12106 if (TREE_CODE (arg) == ADDR_EXPR)
12108 arg = TREE_OPERAND (arg, 0);
12114 if (TREE_CODE (arg) == COMPONENT_REF)
12115 /* Handle `&x' where `x' is some static or non-static member
12117 arg = TREE_OPERAND (arg, 1);
12119 if (TREE_CODE (arg) == OFFSET_REF)
12120 arg = TREE_OPERAND (arg, 1);
12122 /* Strip baselink information. */
12123 if (BASELINK_P (arg))
12124 arg = BASELINK_FUNCTIONS (arg);
12126 if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
12128 /* If we got some explicit template args, we need to plug them into
12129 the affected templates before we try to unify, in case the
12130 explicit args will completely resolve the templates in question. */
12132 tree expl_subargs = TREE_OPERAND (arg, 1);
12133 arg = TREE_OPERAND (arg, 0);
12135 for (; arg; arg = OVL_NEXT (arg))
12137 tree fn = OVL_CURRENT (arg);
12138 tree subargs, elem;
12140 if (TREE_CODE (fn) != TEMPLATE_DECL)
12143 ++processing_template_decl;
12144 subargs = get_bindings (fn, DECL_TEMPLATE_RESULT (fn),
12145 expl_subargs, /*check_ret=*/false);
12148 elem = tsubst (TREE_TYPE (fn), subargs, tf_none, NULL_TREE);
12149 good += try_one_overload (tparms, targs, tempargs, parm,
12150 elem, strict, sub_strict, addr_p);
12152 --processing_template_decl;
12155 else if (TREE_CODE (arg) != OVERLOAD
12156 && TREE_CODE (arg) != FUNCTION_DECL)
12157 /* If ARG is, for example, "(0, &f)" then its type will be unknown
12158 -- but the deduction does not succeed because the expression is
12159 not just the function on its own. */
12162 for (; arg; arg = OVL_NEXT (arg))
12163 good += try_one_overload (tparms, targs, tempargs, parm,
12164 TREE_TYPE (OVL_CURRENT (arg)),
12165 strict, sub_strict, addr_p);
12167 /* [temp.deduct.type] A template-argument can be deduced from a pointer
12168 to function or pointer to member function argument if the set of
12169 overloaded functions does not contain function templates and at most
12170 one of a set of overloaded functions provides a unique match.
12172 So if we found multiple possibilities, we return success but don't
12173 deduce anything. */
12177 int i = TREE_VEC_LENGTH (targs);
12179 if (TREE_VEC_ELT (tempargs, i))
12180 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i);
12188 /* Subroutine of resolve_overloaded_unification; does deduction for a single
12189 overload. Fills TARGS with any deduced arguments, or error_mark_node if
12190 different overloads deduce different arguments for a given parm.
12191 ADDR_P is true if the expression for which deduction is being
12192 performed was of the form "& fn" rather than simply "fn".
12194 Returns 1 on success. */
12197 try_one_overload (tree tparms,
12202 unification_kind_t strict,
12210 /* [temp.deduct.type] A template-argument can be deduced from a pointer
12211 to function or pointer to member function argument if the set of
12212 overloaded functions does not contain function templates and at most
12213 one of a set of overloaded functions provides a unique match.
12215 So if this is a template, just return success. */
12217 if (uses_template_parms (arg))
12220 if (TREE_CODE (arg) == METHOD_TYPE)
12221 arg = build_ptrmemfunc_type (build_pointer_type (arg));
12223 arg = build_pointer_type (arg);
12225 sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg, NULL);
12227 /* We don't copy orig_targs for this because if we have already deduced
12228 some template args from previous args, unify would complain when we
12229 try to deduce a template parameter for the same argument, even though
12230 there isn't really a conflict. */
12231 nargs = TREE_VEC_LENGTH (targs);
12232 tempargs = make_tree_vec (nargs);
12234 if (unify (tparms, tempargs, parm, arg, sub_strict) != 0)
12237 /* First make sure we didn't deduce anything that conflicts with
12238 explicitly specified args. */
12239 for (i = nargs; i--; )
12241 tree elt = TREE_VEC_ELT (tempargs, i);
12242 tree oldelt = TREE_VEC_ELT (orig_targs, i);
12246 else if (uses_template_parms (elt))
12247 /* Since we're unifying against ourselves, we will fill in
12248 template args used in the function parm list with our own
12249 template parms. Discard them. */
12250 TREE_VEC_ELT (tempargs, i) = NULL_TREE;
12251 else if (oldelt && !template_args_equal (oldelt, elt))
12255 for (i = nargs; i--; )
12257 tree elt = TREE_VEC_ELT (tempargs, i);
12260 TREE_VEC_ELT (targs, i) = elt;
12266 /* PARM is a template class (perhaps with unbound template
12267 parameters). ARG is a fully instantiated type. If ARG can be
12268 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
12269 TARGS are as for unify. */
12272 try_class_unification (tree tparms, tree targs, tree parm, tree arg)
12274 tree copy_of_targs;
12276 if (!CLASSTYPE_TEMPLATE_INFO (arg)
12277 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg))
12278 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm))))
12281 /* We need to make a new template argument vector for the call to
12282 unify. If we used TARGS, we'd clutter it up with the result of
12283 the attempted unification, even if this class didn't work out.
12284 We also don't want to commit ourselves to all the unifications
12285 we've already done, since unification is supposed to be done on
12286 an argument-by-argument basis. In other words, consider the
12287 following pathological case:
12289 template <int I, int J, int K>
12292 template <int I, int J>
12293 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
12295 template <int I, int J, int K>
12296 void f(S<I, J, K>, S<I, I, I>);
12305 Now, by the time we consider the unification involving `s2', we
12306 already know that we must have `f<0, 0, 0>'. But, even though
12307 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
12308 because there are two ways to unify base classes of S<0, 1, 2>
12309 with S<I, I, I>. If we kept the already deduced knowledge, we
12310 would reject the possibility I=1. */
12311 copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs));
12313 /* If unification failed, we're done. */
12314 if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm),
12315 CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE))
12321 /* Given a template type PARM and a class type ARG, find the unique
12322 base type in ARG that is an instance of PARM. We do not examine
12323 ARG itself; only its base-classes. If there is not exactly one
12324 appropriate base class, return NULL_TREE. PARM may be the type of
12325 a partial specialization, as well as a plain template type. Used
12329 get_template_base (tree tparms, tree targs, tree parm, tree arg)
12331 tree rval = NULL_TREE;
12334 gcc_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg)));
12336 binfo = TYPE_BINFO (complete_type (arg));
12338 /* The type could not be completed. */
12341 /* Walk in inheritance graph order. The search order is not
12342 important, and this avoids multiple walks of virtual bases. */
12343 for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo))
12345 tree r = try_class_unification (tparms, targs, parm, BINFO_TYPE (binfo));
12349 /* If there is more than one satisfactory baseclass, then:
12353 If they yield more than one possible deduced A, the type
12357 if (rval && !same_type_p (r, rval))
12367 /* Returns the level of DECL, which declares a template parameter. */
12370 template_decl_level (tree decl)
12372 switch (TREE_CODE (decl))
12375 case TEMPLATE_DECL:
12376 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl));
12379 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
12382 gcc_unreachable ();
12387 /* Decide whether ARG can be unified with PARM, considering only the
12388 cv-qualifiers of each type, given STRICT as documented for unify.
12389 Returns nonzero iff the unification is OK on that basis. */
12392 check_cv_quals_for_unify (int strict, tree arg, tree parm)
12394 int arg_quals = cp_type_quals (arg);
12395 int parm_quals = cp_type_quals (parm);
12397 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
12398 && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
12400 /* Although a CVR qualifier is ignored when being applied to a
12401 substituted template parameter ([8.3.2]/1 for example), that
12402 does not apply during deduction [14.8.2.4]/1, (even though
12403 that is not explicitly mentioned, [14.8.2.4]/9 indicates
12404 this). Except when we're allowing additional CV qualifiers
12405 at the outer level [14.8.2.1]/3,1st bullet. */
12406 if ((TREE_CODE (arg) == REFERENCE_TYPE
12407 || TREE_CODE (arg) == FUNCTION_TYPE
12408 || TREE_CODE (arg) == METHOD_TYPE)
12409 && (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)))
12412 if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
12413 && (parm_quals & TYPE_QUAL_RESTRICT))
12417 if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
12418 && (arg_quals & parm_quals) != parm_quals)
12421 if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL))
12422 && (parm_quals & arg_quals) != arg_quals)
12428 /* Determines the LEVEL and INDEX for the template parameter PARM. */
12430 template_parm_level_and_index (tree parm, int* level, int* index)
12432 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
12433 || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
12434 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
12436 *index = TEMPLATE_TYPE_IDX (parm);
12437 *level = TEMPLATE_TYPE_LEVEL (parm);
12441 *index = TEMPLATE_PARM_IDX (parm);
12442 *level = TEMPLATE_PARM_LEVEL (parm);
12446 /* Unifies the remaining arguments in PACKED_ARGS with the pack
12447 expansion at the end of PACKED_PARMS. Returns 0 if the type
12448 deduction succeeds, 1 otherwise. STRICT is the same as in
12449 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
12450 call argument list. We'll need to adjust the arguments to make them
12451 types. SUBR tells us if this is from a recursive call to
12452 type_unification_real. */
12454 unify_pack_expansion (tree tparms, tree targs, tree packed_parms,
12455 tree packed_args, int strict, bool call_args_p,
12459 = TREE_VEC_ELT (packed_parms, TREE_VEC_LENGTH (packed_parms) - 1);
12460 tree pattern = PACK_EXPANSION_PATTERN (parm);
12461 tree pack, packs = NULL_TREE;
12462 int i, start = TREE_VEC_LENGTH (packed_parms) - 1;
12463 int len = TREE_VEC_LENGTH (packed_args);
12465 /* Determine the parameter packs we will be deducing from the
12466 pattern, and record their current deductions. */
12467 for (pack = PACK_EXPANSION_PARAMETER_PACKS (parm);
12468 pack; pack = TREE_CHAIN (pack))
12470 tree parm_pack = TREE_VALUE (pack);
12473 /* Determine the index and level of this parameter pack. */
12474 template_parm_level_and_index (parm_pack, &level, &idx);
12476 /* Keep track of the parameter packs and their corresponding
12478 packs = tree_cons (parm_pack, TMPL_ARG (targs, level, idx), packs);
12479 TREE_TYPE (packs) = make_tree_vec (len - start);
12482 /* Loop through all of the arguments that have not yet been
12483 unified and unify each with the pattern. */
12484 for (i = start; i < len; i++)
12486 tree parm = pattern;
12488 /* For each parameter pack, clear out the deduced value so that
12489 we can deduce it again. */
12490 for (pack = packs; pack; pack = TREE_CHAIN (pack))
12493 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12495 TMPL_ARG (targs, level, idx) = NULL_TREE;
12498 /* Unify the pattern with the current argument. */
12500 tree arg = TREE_VEC_ELT (packed_args, i);
12501 tree arg_expr = NULL_TREE;
12502 int arg_strict = strict;
12503 bool skip_arg_p = false;
12509 /* This mirrors what we do in type_unification_real. */
12513 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL
12514 | UNIFY_ALLOW_MORE_CV_QUAL
12515 | UNIFY_ALLOW_DERIVED);
12519 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
12523 sub_strict = UNIFY_ALLOW_NONE;
12527 gcc_unreachable ();
12532 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
12533 if (type_unknown_p (arg))
12535 /* [temp.deduct.type] A template-argument can be
12536 deduced from a pointer to function or pointer
12537 to member function argument if the set of
12538 overloaded functions does not contain function
12539 templates and at most one of a set of
12540 overloaded functions provides a unique
12543 if (resolve_overloaded_unification
12544 (tparms, targs, parm, arg, strict, sub_strict)
12553 arg = unlowered_expr_type (arg);
12554 if (arg == error_mark_node)
12559 arg_strict = sub_strict;
12563 maybe_adjust_types_for_deduction (strict, &parm, &arg,
12569 if (unify (tparms, targs, parm, arg, arg_strict))
12574 /* For each parameter pack, collect the deduced value. */
12575 for (pack = packs; pack; pack = TREE_CHAIN (pack))
12578 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12580 TREE_VEC_ELT (TREE_TYPE (pack), i - start) =
12581 TMPL_ARG (targs, level, idx);
12585 /* Verify that the results of unification with the parameter packs
12586 produce results consistent with what we've seen before, and make
12587 the deduced argument packs available. */
12588 for (pack = packs; pack; pack = TREE_CHAIN (pack))
12590 tree old_pack = TREE_VALUE (pack);
12591 tree new_args = TREE_TYPE (pack);
12592 int i, len = TREE_VEC_LENGTH (new_args);
12593 bool nondeduced_p = false;
12595 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
12596 actually deduce anything. */
12597 for (i = 0; i < len && !nondeduced_p; ++i)
12598 if (TREE_VEC_ELT (new_args, i) == NULL_TREE)
12599 nondeduced_p = true;
12603 if (old_pack && ARGUMENT_PACK_INCOMPLETE_P (old_pack))
12605 /* Prepend the explicit arguments onto NEW_ARGS. */
12606 tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
12607 tree old_args = new_args;
12608 int i, explicit_len = TREE_VEC_LENGTH (explicit_args);
12609 int len = explicit_len + TREE_VEC_LENGTH (old_args);
12611 /* Copy the explicit arguments. */
12612 new_args = make_tree_vec (len);
12613 for (i = 0; i < explicit_len; i++)
12614 TREE_VEC_ELT (new_args, i) = TREE_VEC_ELT (explicit_args, i);
12616 /* Copy the deduced arguments. */
12617 for (; i < len; i++)
12618 TREE_VEC_ELT (new_args, i) =
12619 TREE_VEC_ELT (old_args, i - explicit_len);
12627 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12629 /* Build the deduced *_ARGUMENT_PACK. */
12630 if (TREE_CODE (TREE_PURPOSE (pack)) == TEMPLATE_PARM_INDEX)
12632 result = make_node (NONTYPE_ARGUMENT_PACK);
12633 TREE_TYPE (result) =
12634 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack)));
12635 TREE_CONSTANT (result) = 1;
12638 result = make_node (TYPE_ARGUMENT_PACK);
12640 SET_ARGUMENT_PACK_ARGS (result, new_args);
12642 /* Note the deduced argument packs for this parameter
12644 TMPL_ARG (targs, level, idx) = result;
12646 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack)
12647 && (ARGUMENT_PACK_ARGS (old_pack)
12648 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack)))
12650 /* We only had the explicitly-provided arguments before, but
12651 now we have a complete set of arguments. */
12653 tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
12654 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12656 /* Keep the original deduced argument pack. */
12657 TMPL_ARG (targs, level, idx) = old_pack;
12659 SET_ARGUMENT_PACK_ARGS (old_pack, new_args);
12660 ARGUMENT_PACK_INCOMPLETE_P (old_pack) = 1;
12661 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack) = explicit_args;
12663 else if (!comp_template_args (ARGUMENT_PACK_ARGS (old_pack),
12665 /* Inconsistent unification of this parameter pack. */
12671 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12673 /* Keep the original deduced argument pack. */
12674 TMPL_ARG (targs, level, idx) = old_pack;
12681 /* Deduce the value of template parameters. TPARMS is the (innermost)
12682 set of template parameters to a template. TARGS is the bindings
12683 for those template parameters, as determined thus far; TARGS may
12684 include template arguments for outer levels of template parameters
12685 as well. PARM is a parameter to a template function, or a
12686 subcomponent of that parameter; ARG is the corresponding argument.
12687 This function attempts to match PARM with ARG in a manner
12688 consistent with the existing assignments in TARGS. If more values
12689 are deduced, then TARGS is updated.
12691 Returns 0 if the type deduction succeeds, 1 otherwise. The
12692 parameter STRICT is a bitwise or of the following flags:
12695 Require an exact match between PARM and ARG.
12696 UNIFY_ALLOW_MORE_CV_QUAL:
12697 Allow the deduced ARG to be more cv-qualified (by qualification
12698 conversion) than ARG.
12699 UNIFY_ALLOW_LESS_CV_QUAL:
12700 Allow the deduced ARG to be less cv-qualified than ARG.
12701 UNIFY_ALLOW_DERIVED:
12702 Allow the deduced ARG to be a template base class of ARG,
12703 or a pointer to a template base class of the type pointed to by
12705 UNIFY_ALLOW_INTEGER:
12706 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
12707 case for more information.
12708 UNIFY_ALLOW_OUTER_LEVEL:
12709 This is the outermost level of a deduction. Used to determine validity
12710 of qualification conversions. A valid qualification conversion must
12711 have const qualified pointers leading up to the inner type which
12712 requires additional CV quals, except at the outer level, where const
12713 is not required [conv.qual]. It would be normal to set this flag in
12714 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
12715 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
12716 This is the outermost level of a deduction, and PARM can be more CV
12717 qualified at this point.
12718 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
12719 This is the outermost level of a deduction, and PARM can be less CV
12720 qualified at this point. */
12723 unify (tree tparms, tree targs, tree parm, tree arg, int strict)
12728 int strict_in = strict;
12730 /* I don't think this will do the right thing with respect to types.
12731 But the only case I've seen it in so far has been array bounds, where
12732 signedness is the only information lost, and I think that will be
12734 while (TREE_CODE (parm) == NOP_EXPR)
12735 parm = TREE_OPERAND (parm, 0);
12737 if (arg == error_mark_node)
12739 if (arg == unknown_type_node)
12740 /* We can't deduce anything from this, but we might get all the
12741 template args from other function args. */
12744 /* If PARM uses template parameters, then we can't bail out here,
12745 even if ARG == PARM, since we won't record unifications for the
12746 template parameters. We might need them if we're trying to
12747 figure out which of two things is more specialized. */
12748 if (arg == parm && !uses_template_parms (parm))
12751 /* Immediately reject some pairs that won't unify because of
12752 cv-qualification mismatches. */
12753 if (TREE_CODE (arg) == TREE_CODE (parm)
12755 /* It is the elements of the array which hold the cv quals of an array
12756 type, and the elements might be template type parms. We'll check
12757 when we recurse. */
12758 && TREE_CODE (arg) != ARRAY_TYPE
12759 /* We check the cv-qualifiers when unifying with template type
12760 parameters below. We want to allow ARG `const T' to unify with
12761 PARM `T' for example, when computing which of two templates
12762 is more specialized, for example. */
12763 && TREE_CODE (arg) != TEMPLATE_TYPE_PARM
12764 && !check_cv_quals_for_unify (strict_in, arg, parm))
12767 if (!(strict & UNIFY_ALLOW_OUTER_LEVEL)
12768 && TYPE_P (parm) && !CP_TYPE_CONST_P (parm))
12769 strict &= ~UNIFY_ALLOW_MORE_CV_QUAL;
12770 strict &= ~UNIFY_ALLOW_OUTER_LEVEL;
12771 strict &= ~UNIFY_ALLOW_DERIVED;
12772 strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
12773 strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL;
12775 switch (TREE_CODE (parm))
12777 case TYPENAME_TYPE:
12779 case UNBOUND_CLASS_TEMPLATE:
12780 /* In a type which contains a nested-name-specifier, template
12781 argument values cannot be deduced for template parameters used
12782 within the nested-name-specifier. */
12785 case TEMPLATE_TYPE_PARM:
12786 case TEMPLATE_TEMPLATE_PARM:
12787 case BOUND_TEMPLATE_TEMPLATE_PARM:
12788 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
12789 if (tparm == error_mark_node)
12792 if (TEMPLATE_TYPE_LEVEL (parm)
12793 != template_decl_level (tparm))
12794 /* The PARM is not one we're trying to unify. Just check
12795 to see if it matches ARG. */
12796 return (TREE_CODE (arg) == TREE_CODE (parm)
12797 && same_type_p (parm, arg)) ? 0 : 1;
12798 idx = TEMPLATE_TYPE_IDX (parm);
12799 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
12800 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx));
12802 /* Check for mixed types and values. */
12803 if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
12804 && TREE_CODE (tparm) != TYPE_DECL)
12805 || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
12806 && TREE_CODE (tparm) != TEMPLATE_DECL))
12809 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
12811 /* ARG must be constructed from a template class or a template
12812 template parameter. */
12813 if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM
12814 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg))
12818 tree parmvec = TYPE_TI_ARGS (parm);
12819 tree argvec = INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg));
12821 = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_TI_TEMPLATE (arg));
12823 int parm_variadic_p = 0;
12825 /* The resolution to DR150 makes clear that default
12826 arguments for an N-argument may not be used to bind T
12827 to a template template parameter with fewer than N
12828 parameters. It is not safe to permit the binding of
12829 default arguments as an extension, as that may change
12830 the meaning of a conforming program. Consider:
12832 struct Dense { static const unsigned int dim = 1; };
12834 template <template <typename> class View,
12836 void operator+(float, View<Block> const&);
12838 template <typename Block,
12839 unsigned int Dim = Block::dim>
12840 struct Lvalue_proxy { operator float() const; };
12844 Lvalue_proxy<Dense> p;
12849 Here, if Lvalue_proxy is permitted to bind to View, then
12850 the global operator+ will be used; if they are not, the
12851 Lvalue_proxy will be converted to float. */
12852 if (coerce_template_parms (argtmplvec, parmvec,
12853 TYPE_TI_TEMPLATE (parm),
12855 /*require_all_args=*/true,
12856 /*use_default_args=*/false)
12857 == error_mark_node)
12860 /* Deduce arguments T, i from TT<T> or TT<i>.
12861 We check each element of PARMVEC and ARGVEC individually
12862 rather than the whole TREE_VEC since they can have
12863 different number of elements. */
12865 parmvec = expand_template_argument_pack (parmvec);
12866 argvec = expand_template_argument_pack (argvec);
12868 len = TREE_VEC_LENGTH (parmvec);
12870 /* Check if the parameters end in a pack, making them
12873 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec, len - 1)))
12874 parm_variadic_p = 1;
12876 if (TREE_VEC_LENGTH (argvec) < len - parm_variadic_p)
12879 for (i = 0; i < len - parm_variadic_p; ++i)
12881 if (unify (tparms, targs,
12882 TREE_VEC_ELT (parmvec, i),
12883 TREE_VEC_ELT (argvec, i),
12888 if (parm_variadic_p
12889 && unify_pack_expansion (tparms, targs,
12892 /*call_args_p=*/false,
12896 arg = TYPE_TI_TEMPLATE (arg);
12898 /* Fall through to deduce template name. */
12901 if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
12902 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
12904 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
12906 /* Simple cases: Value already set, does match or doesn't. */
12907 if (targ != NULL_TREE && template_args_equal (targ, arg))
12914 /* If PARM is `const T' and ARG is only `int', we don't have
12915 a match unless we are allowing additional qualification.
12916 If ARG is `const int' and PARM is just `T' that's OK;
12917 that binds `const int' to `T'. */
12918 if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL,
12922 /* Consider the case where ARG is `const volatile int' and
12923 PARM is `const T'. Then, T should be `volatile int'. */
12924 arg = cp_build_qualified_type_real
12925 (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
12926 if (arg == error_mark_node)
12929 /* Simple cases: Value already set, does match or doesn't. */
12930 if (targ != NULL_TREE && same_type_p (targ, arg))
12935 /* Make sure that ARG is not a variable-sized array. (Note
12936 that were talking about variable-sized arrays (like
12937 `int[n]'), rather than arrays of unknown size (like
12938 `int[]').) We'll get very confused by such a type since
12939 the bound of the array will not be computable in an
12940 instantiation. Besides, such types are not allowed in
12941 ISO C++, so we can do as we please here. */
12942 if (variably_modified_type_p (arg, NULL_TREE))
12946 /* If ARG is a parameter pack or an expansion, we cannot unify
12947 against it unless PARM is also a parameter pack. */
12948 if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
12949 && !template_parameter_pack_p (parm))
12952 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
12955 case TEMPLATE_PARM_INDEX:
12956 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
12957 if (tparm == error_mark_node)
12960 if (TEMPLATE_PARM_LEVEL (parm)
12961 != template_decl_level (tparm))
12962 /* The PARM is not one we're trying to unify. Just check
12963 to see if it matches ARG. */
12964 return !(TREE_CODE (arg) == TREE_CODE (parm)
12965 && cp_tree_equal (parm, arg));
12967 idx = TEMPLATE_PARM_IDX (parm);
12968 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
12971 return !cp_tree_equal (targ, arg);
12973 /* [temp.deduct.type] If, in the declaration of a function template
12974 with a non-type template-parameter, the non-type
12975 template-parameter is used in an expression in the function
12976 parameter-list and, if the corresponding template-argument is
12977 deduced, the template-argument type shall match the type of the
12978 template-parameter exactly, except that a template-argument
12979 deduced from an array bound may be of any integral type.
12980 The non-type parameter might use already deduced type parameters. */
12981 tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE);
12982 if (!TREE_TYPE (arg))
12983 /* Template-parameter dependent expression. Just accept it for now.
12984 It will later be processed in convert_template_argument. */
12986 else if (same_type_p (TREE_TYPE (arg), tparm))
12988 else if ((strict & UNIFY_ALLOW_INTEGER)
12989 && (TREE_CODE (tparm) == INTEGER_TYPE
12990 || TREE_CODE (tparm) == BOOLEAN_TYPE))
12991 /* Convert the ARG to the type of PARM; the deduced non-type
12992 template argument must exactly match the types of the
12993 corresponding parameter. */
12994 arg = fold (build_nop (TREE_TYPE (parm), arg));
12995 else if (uses_template_parms (tparm))
12996 /* We haven't deduced the type of this parameter yet. Try again
13002 /* If ARG is a parameter pack or an expansion, we cannot unify
13003 against it unless PARM is also a parameter pack. */
13004 if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
13005 && !TEMPLATE_PARM_PARAMETER_PACK (parm))
13008 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
13013 /* A pointer-to-member constant can be unified only with
13014 another constant. */
13015 if (TREE_CODE (arg) != PTRMEM_CST)
13018 /* Just unify the class member. It would be useless (and possibly
13019 wrong, depending on the strict flags) to unify also
13020 PTRMEM_CST_CLASS, because we want to be sure that both parm and
13021 arg refer to the same variable, even if through different
13022 classes. For instance:
13024 struct A { int x; };
13027 Unification of &A::x and &B::x must succeed. */
13028 return unify (tparms, targs, PTRMEM_CST_MEMBER (parm),
13029 PTRMEM_CST_MEMBER (arg), strict);
13034 if (TREE_CODE (arg) != POINTER_TYPE)
13037 /* [temp.deduct.call]
13039 A can be another pointer or pointer to member type that can
13040 be converted to the deduced A via a qualification
13041 conversion (_conv.qual_).
13043 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
13044 This will allow for additional cv-qualification of the
13045 pointed-to types if appropriate. */
13047 if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
13048 /* The derived-to-base conversion only persists through one
13049 level of pointers. */
13050 strict |= (strict_in & UNIFY_ALLOW_DERIVED);
13052 return unify (tparms, targs, TREE_TYPE (parm),
13053 TREE_TYPE (arg), strict);
13056 case REFERENCE_TYPE:
13057 if (TREE_CODE (arg) != REFERENCE_TYPE)
13059 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
13060 strict & UNIFY_ALLOW_MORE_CV_QUAL);
13063 if (TREE_CODE (arg) != ARRAY_TYPE)
13065 if ((TYPE_DOMAIN (parm) == NULL_TREE)
13066 != (TYPE_DOMAIN (arg) == NULL_TREE))
13068 if (TYPE_DOMAIN (parm) != NULL_TREE)
13075 /* Our representation of array types uses "N - 1" as the
13076 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
13077 not an integer constant. We cannot unify arbitrarily
13078 complex expressions, so we eliminate the MINUS_EXPRs
13080 parm_max = TYPE_MAX_VALUE (TYPE_DOMAIN (parm));
13081 parm_cst = TREE_CODE (parm_max) == INTEGER_CST;
13084 gcc_assert (TREE_CODE (parm_max) == MINUS_EXPR);
13085 parm_max = TREE_OPERAND (parm_max, 0);
13087 arg_max = TYPE_MAX_VALUE (TYPE_DOMAIN (arg));
13088 arg_cst = TREE_CODE (arg_max) == INTEGER_CST;
13091 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
13092 trying to unify the type of a variable with the type
13093 of a template parameter. For example:
13095 template <unsigned int N>
13096 void f (char (&) [N]);
13103 Here, the type of the ARG will be "int [g(i)]", and
13104 may be a SAVE_EXPR, etc. */
13105 if (TREE_CODE (arg_max) != MINUS_EXPR)
13107 arg_max = TREE_OPERAND (arg_max, 0);
13110 /* If only one of the bounds used a MINUS_EXPR, compensate
13111 by adding one to the other bound. */
13112 if (parm_cst && !arg_cst)
13113 parm_max = fold_build2 (PLUS_EXPR,
13117 else if (arg_cst && !parm_cst)
13118 arg_max = fold_build2 (PLUS_EXPR,
13123 if (unify (tparms, targs, parm_max, arg_max, UNIFY_ALLOW_INTEGER))
13126 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
13127 strict & UNIFY_ALLOW_MORE_CV_QUAL);
13134 case ENUMERAL_TYPE:
13136 if (TREE_CODE (arg) != TREE_CODE (parm))
13139 /* We have already checked cv-qualification at the top of the
13141 if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
13144 /* As far as unification is concerned, this wins. Later checks
13145 will invalidate it if necessary. */
13148 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
13149 /* Type INTEGER_CST can come from ordinary constant template args. */
13151 while (TREE_CODE (arg) == NOP_EXPR)
13152 arg = TREE_OPERAND (arg, 0);
13154 if (TREE_CODE (arg) != INTEGER_CST)
13156 return !tree_int_cst_equal (parm, arg);
13161 if (TREE_CODE (arg) != TREE_VEC)
13163 if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
13165 for (i = 0; i < TREE_VEC_LENGTH (parm); ++i)
13166 if (unify (tparms, targs,
13167 TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
13175 if (TREE_CODE (arg) != TREE_CODE (parm))
13178 if (TYPE_PTRMEMFUNC_P (parm))
13180 if (!TYPE_PTRMEMFUNC_P (arg))
13183 return unify (tparms, targs,
13184 TYPE_PTRMEMFUNC_FN_TYPE (parm),
13185 TYPE_PTRMEMFUNC_FN_TYPE (arg),
13189 if (CLASSTYPE_TEMPLATE_INFO (parm))
13191 tree t = NULL_TREE;
13193 if (strict_in & UNIFY_ALLOW_DERIVED)
13195 /* First, we try to unify the PARM and ARG directly. */
13196 t = try_class_unification (tparms, targs,
13201 /* Fallback to the special case allowed in
13202 [temp.deduct.call]:
13204 If P is a class, and P has the form
13205 template-id, then A can be a derived class of
13206 the deduced A. Likewise, if P is a pointer to
13207 a class of the form template-id, A can be a
13208 pointer to a derived class pointed to by the
13210 t = get_template_base (tparms, targs, parm, arg);
13216 else if (CLASSTYPE_TEMPLATE_INFO (arg)
13217 && (CLASSTYPE_TI_TEMPLATE (parm)
13218 == CLASSTYPE_TI_TEMPLATE (arg)))
13219 /* Perhaps PARM is something like S<U> and ARG is S<int>.
13220 Then, we should unify `int' and `U'. */
13223 /* There's no chance of unification succeeding. */
13226 return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
13227 CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE);
13229 else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
13234 case FUNCTION_TYPE:
13235 if (TREE_CODE (arg) != TREE_CODE (parm))
13238 /* CV qualifications for methods can never be deduced, they must
13239 match exactly. We need to check them explicitly here,
13240 because type_unification_real treats them as any other
13241 cvqualified parameter. */
13242 if (TREE_CODE (parm) == METHOD_TYPE
13243 && (!check_cv_quals_for_unify
13245 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (arg))),
13246 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (parm))))))
13249 if (unify (tparms, targs, TREE_TYPE (parm),
13250 TREE_TYPE (arg), UNIFY_ALLOW_NONE))
13252 return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
13253 TYPE_ARG_TYPES (arg), 1, DEDUCE_EXACT,
13257 /* Unify a pointer to member with a pointer to member function, which
13258 deduces the type of the member as a function type. */
13259 if (TYPE_PTRMEMFUNC_P (arg))
13263 cp_cv_quals cv_quals;
13265 /* Check top-level cv qualifiers */
13266 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE, arg, parm))
13269 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
13270 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg), UNIFY_ALLOW_NONE))
13273 /* Determine the type of the function we are unifying against. */
13274 method_type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (arg));
13276 build_function_type (TREE_TYPE (method_type),
13277 TREE_CHAIN (TYPE_ARG_TYPES (method_type)));
13279 /* Extract the cv-qualifiers of the member function from the
13280 implicit object parameter and place them on the function
13281 type to be restored later. */
13283 cp_type_quals(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (method_type))));
13284 fntype = build_qualified_type (fntype, cv_quals);
13285 return unify (tparms, targs, TREE_TYPE (parm), fntype, strict);
13288 if (TREE_CODE (arg) != OFFSET_TYPE)
13290 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
13291 TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE))
13293 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
13297 if (DECL_TEMPLATE_PARM_P (parm))
13298 return unify (tparms, targs, DECL_INITIAL (parm), arg, strict);
13299 if (arg != integral_constant_value (parm))
13304 case TEMPLATE_DECL:
13305 /* Matched cases are handled by the ARG == PARM test above. */
13308 case TYPE_ARGUMENT_PACK:
13309 case NONTYPE_ARGUMENT_PACK:
13311 tree packed_parms = ARGUMENT_PACK_ARGS (parm);
13312 tree packed_args = ARGUMENT_PACK_ARGS (arg);
13313 int i, len = TREE_VEC_LENGTH (packed_parms);
13314 int argslen = TREE_VEC_LENGTH (packed_args);
13315 int parm_variadic_p = 0;
13317 for (i = 0; i < len; ++i)
13319 if (PACK_EXPANSION_P (TREE_VEC_ELT (packed_parms, i)))
13322 /* We can unify against something with a trailing
13324 parm_variadic_p = 1;
13326 /* Since there is something following the pack
13327 expansion, we cannot unify this template argument
13334 /* If we don't have enough arguments to satisfy the parameters
13335 (not counting the pack expression at the end), or we have
13336 too many arguments for a parameter list that doesn't end in
13337 a pack expression, we can't unify. */
13338 if (argslen < (len - parm_variadic_p)
13339 || (argslen > len && !parm_variadic_p))
13342 /* Unify all of the parameters that precede the (optional)
13343 pack expression. */
13344 for (i = 0; i < len - parm_variadic_p; ++i)
13346 if (unify (tparms, targs, TREE_VEC_ELT (packed_parms, i),
13347 TREE_VEC_ELT (packed_args, i), strict))
13351 if (parm_variadic_p)
13352 return unify_pack_expansion (tparms, targs,
13353 packed_parms, packed_args,
13354 strict, /*call_args_p=*/false,
13362 case DECLTYPE_TYPE:
13363 /* Cannot deduce anything from TYPEOF_TYPE or DECLTYPE_TYPE
13368 /* Unification fails if we hit an error node. */
13372 gcc_assert (EXPR_P (parm));
13374 /* We must be looking at an expression. This can happen with
13378 void foo(S<I>, S<I + 2>);
13380 This is a "nondeduced context":
13384 The nondeduced contexts are:
13386 --A type that is a template-id in which one or more of
13387 the template-arguments is an expression that references
13388 a template-parameter.
13390 In these cases, we assume deduction succeeded, but don't
13391 actually infer any unifications. */
13393 if (!uses_template_parms (parm)
13394 && !template_args_equal (parm, arg))
13401 /* Note that DECL can be defined in this translation unit, if
13405 mark_definable (tree decl)
13408 DECL_NOT_REALLY_EXTERN (decl) = 1;
13409 FOR_EACH_CLONE (clone, decl)
13410 DECL_NOT_REALLY_EXTERN (clone) = 1;
13413 /* Called if RESULT is explicitly instantiated, or is a member of an
13414 explicitly instantiated class. */
13417 mark_decl_instantiated (tree result, int extern_p)
13419 SET_DECL_EXPLICIT_INSTANTIATION (result);
13421 /* If this entity has already been written out, it's too late to
13422 make any modifications. */
13423 if (TREE_ASM_WRITTEN (result))
13426 if (TREE_CODE (result) != FUNCTION_DECL)
13427 /* The TREE_PUBLIC flag for function declarations will have been
13428 set correctly by tsubst. */
13429 TREE_PUBLIC (result) = 1;
13431 /* This might have been set by an earlier implicit instantiation. */
13432 DECL_COMDAT (result) = 0;
13435 DECL_NOT_REALLY_EXTERN (result) = 0;
13438 mark_definable (result);
13439 /* Always make artificials weak. */
13440 if (DECL_ARTIFICIAL (result) && flag_weak)
13441 comdat_linkage (result);
13442 /* For WIN32 we also want to put explicit instantiations in
13443 linkonce sections. */
13444 else if (TREE_PUBLIC (result))
13445 maybe_make_one_only (result);
13448 /* If EXTERN_P, then this function will not be emitted -- unless
13449 followed by an explicit instantiation, at which point its linkage
13450 will be adjusted. If !EXTERN_P, then this function will be
13451 emitted here. In neither circumstance do we want
13452 import_export_decl to adjust the linkage. */
13453 DECL_INTERFACE_KNOWN (result) = 1;
13456 /* Given two function templates PAT1 and PAT2, return:
13458 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
13459 -1 if PAT2 is more specialized than PAT1.
13460 0 if neither is more specialized.
13462 LEN indicates the number of parameters we should consider
13463 (defaulted parameters should not be considered).
13465 The 1998 std underspecified function template partial ordering, and
13466 DR214 addresses the issue. We take pairs of arguments, one from
13467 each of the templates, and deduce them against each other. One of
13468 the templates will be more specialized if all the *other*
13469 template's arguments deduce against its arguments and at least one
13470 of its arguments *does* *not* deduce against the other template's
13471 corresponding argument. Deduction is done as for class templates.
13472 The arguments used in deduction have reference and top level cv
13473 qualifiers removed. Iff both arguments were originally reference
13474 types *and* deduction succeeds in both directions, the template
13475 with the more cv-qualified argument wins for that pairing (if
13476 neither is more cv-qualified, they both are equal). Unlike regular
13477 deduction, after all the arguments have been deduced in this way,
13478 we do *not* verify the deduced template argument values can be
13479 substituted into non-deduced contexts, nor do we have to verify
13480 that all template arguments have been deduced. */
13483 more_specialized_fn (tree pat1, tree pat2, int len)
13485 tree decl1 = DECL_TEMPLATE_RESULT (pat1);
13486 tree decl2 = DECL_TEMPLATE_RESULT (pat2);
13487 tree targs1 = make_tree_vec (DECL_NTPARMS (pat1));
13488 tree targs2 = make_tree_vec (DECL_NTPARMS (pat2));
13489 tree tparms1 = DECL_INNERMOST_TEMPLATE_PARMS (pat1);
13490 tree tparms2 = DECL_INNERMOST_TEMPLATE_PARMS (pat2);
13491 tree args1 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
13492 tree args2 = TYPE_ARG_TYPES (TREE_TYPE (decl2));
13496 /* Remove the this parameter from non-static member functions. If
13497 one is a non-static member function and the other is not a static
13498 member function, remove the first parameter from that function
13499 also. This situation occurs for operator functions where we
13500 locate both a member function (with this pointer) and non-member
13501 operator (with explicit first operand). */
13502 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1))
13504 len--; /* LEN is the number of significant arguments for DECL1 */
13505 args1 = TREE_CHAIN (args1);
13506 if (!DECL_STATIC_FUNCTION_P (decl2))
13507 args2 = TREE_CHAIN (args2);
13509 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2))
13511 args2 = TREE_CHAIN (args2);
13512 if (!DECL_STATIC_FUNCTION_P (decl1))
13515 args1 = TREE_CHAIN (args1);
13519 /* If only one is a conversion operator, they are unordered. */
13520 if (DECL_CONV_FN_P (decl1) != DECL_CONV_FN_P (decl2))
13523 /* Consider the return type for a conversion function */
13524 if (DECL_CONV_FN_P (decl1))
13526 args1 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl1)), args1);
13527 args2 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl2)), args2);
13531 processing_template_decl++;
13535 tree arg1 = TREE_VALUE (args1);
13536 tree arg2 = TREE_VALUE (args2);
13537 int deduce1, deduce2;
13541 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
13542 && TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
13544 /* When both arguments are pack expansions, we need only
13545 unify the patterns themselves. */
13546 arg1 = PACK_EXPANSION_PATTERN (arg1);
13547 arg2 = PACK_EXPANSION_PATTERN (arg2);
13549 /* This is the last comparison we need to do. */
13553 if (TREE_CODE (arg1) == REFERENCE_TYPE)
13555 arg1 = TREE_TYPE (arg1);
13556 quals1 = cp_type_quals (arg1);
13559 if (TREE_CODE (arg2) == REFERENCE_TYPE)
13561 arg2 = TREE_TYPE (arg2);
13562 quals2 = cp_type_quals (arg2);
13565 if ((quals1 < 0) != (quals2 < 0))
13567 /* Only of the args is a reference, see if we should apply
13568 array/function pointer decay to it. This is not part of
13569 DR214, but is, IMHO, consistent with the deduction rules
13570 for the function call itself, and with our earlier
13571 implementation of the underspecified partial ordering
13572 rules. (nathan). */
13575 switch (TREE_CODE (arg1))
13578 arg1 = TREE_TYPE (arg1);
13580 case FUNCTION_TYPE:
13581 arg1 = build_pointer_type (arg1);
13590 switch (TREE_CODE (arg2))
13593 arg2 = TREE_TYPE (arg2);
13595 case FUNCTION_TYPE:
13596 arg2 = build_pointer_type (arg2);
13605 arg1 = TYPE_MAIN_VARIANT (arg1);
13606 arg2 = TYPE_MAIN_VARIANT (arg2);
13608 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION)
13610 int i, len2 = list_length (args2);
13611 tree parmvec = make_tree_vec (1);
13612 tree argvec = make_tree_vec (len2);
13615 /* Setup the parameter vector, which contains only ARG1. */
13616 TREE_VEC_ELT (parmvec, 0) = arg1;
13618 /* Setup the argument vector, which contains the remaining
13620 for (i = 0; i < len2; i++, ta = TREE_CHAIN (ta))
13621 TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
13623 deduce1 = !unify_pack_expansion (tparms1, targs1, parmvec,
13624 argvec, UNIFY_ALLOW_NONE,
13625 /*call_args_p=*/false,
13628 /* We cannot deduce in the other direction, because ARG1 is
13629 a pack expansion but ARG2 is not. */
13632 else if (TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
13634 int i, len1 = list_length (args1);
13635 tree parmvec = make_tree_vec (1);
13636 tree argvec = make_tree_vec (len1);
13639 /* Setup the parameter vector, which contains only ARG1. */
13640 TREE_VEC_ELT (parmvec, 0) = arg2;
13642 /* Setup the argument vector, which contains the remaining
13644 for (i = 0; i < len1; i++, ta = TREE_CHAIN (ta))
13645 TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
13647 deduce2 = !unify_pack_expansion (tparms2, targs2, parmvec,
13648 argvec, UNIFY_ALLOW_NONE,
13649 /*call_args_p=*/false,
13652 /* We cannot deduce in the other direction, because ARG2 is
13653 a pack expansion but ARG1 is not.*/
13659 /* The normal case, where neither argument is a pack
13661 deduce1 = !unify (tparms1, targs1, arg1, arg2, UNIFY_ALLOW_NONE);
13662 deduce2 = !unify (tparms2, targs2, arg2, arg1, UNIFY_ALLOW_NONE);
13669 if (better1 < 0 && better2 < 0)
13670 /* We've failed to deduce something in either direction.
13671 These must be unordered. */
13674 if (deduce1 && deduce2 && quals1 >= 0 && quals2 >= 0)
13676 /* Deduces in both directions, see if quals can
13677 disambiguate. Pretend the worse one failed to deduce. */
13678 if ((quals1 & quals2) == quals2)
13680 if ((quals1 & quals2) == quals1)
13683 if (deduce1 && !deduce2 && !better2)
13685 if (deduce2 && !deduce1 && !better1)
13688 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
13689 || TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
13690 /* We have already processed all of the arguments in our
13691 handing of the pack expansion type. */
13694 args1 = TREE_CHAIN (args1);
13695 args2 = TREE_CHAIN (args2);
13697 /* Stop when an ellipsis is seen. */
13698 if (args1 == NULL_TREE || args2 == NULL_TREE)
13702 processing_template_decl--;
13704 /* All things being equal, if the next argument is a pack expansion
13705 for one function but not for the other, prefer the
13706 non-variadic function. */
13707 if ((better1 > 0) - (better2 > 0) == 0
13708 && args1 && TREE_VALUE (args1)
13709 && args2 && TREE_VALUE (args2))
13711 if (TREE_CODE (TREE_VALUE (args1)) == TYPE_PACK_EXPANSION)
13712 return TREE_CODE (TREE_VALUE (args2)) == TYPE_PACK_EXPANSION ? 0 : -1;
13713 else if (TREE_CODE (TREE_VALUE (args2)) == TYPE_PACK_EXPANSION)
13717 return (better1 > 0) - (better2 > 0);
13720 /* Determine which of two partial specializations is more specialized.
13722 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
13723 to the first partial specialization. The TREE_VALUE is the
13724 innermost set of template parameters for the partial
13725 specialization. PAT2 is similar, but for the second template.
13727 Return 1 if the first partial specialization is more specialized;
13728 -1 if the second is more specialized; 0 if neither is more
13731 See [temp.class.order] for information about determining which of
13732 two templates is more specialized. */
13735 more_specialized_class (tree pat1, tree pat2)
13740 bool any_deductions = false;
13742 tmpl1 = TREE_TYPE (pat1);
13743 tmpl2 = TREE_TYPE (pat2);
13745 /* Just like what happens for functions, if we are ordering between
13746 different class template specializations, we may encounter dependent
13747 types in the arguments, and we need our dependency check functions
13748 to behave correctly. */
13749 ++processing_template_decl;
13750 targs = get_class_bindings (TREE_VALUE (pat1),
13751 CLASSTYPE_TI_ARGS (tmpl1),
13752 CLASSTYPE_TI_ARGS (tmpl2));
13756 any_deductions = true;
13759 targs = get_class_bindings (TREE_VALUE (pat2),
13760 CLASSTYPE_TI_ARGS (tmpl2),
13761 CLASSTYPE_TI_ARGS (tmpl1));
13765 any_deductions = true;
13767 --processing_template_decl;
13769 /* In the case of a tie where at least one of the class templates
13770 has a parameter pack at the end, the template with the most
13771 non-packed parameters wins. */
13774 && (template_args_variadic_p (TREE_PURPOSE (pat1))
13775 || template_args_variadic_p (TREE_PURPOSE (pat2))))
13777 tree args1 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1));
13778 tree args2 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2));
13779 int len1 = TREE_VEC_LENGTH (args1);
13780 int len2 = TREE_VEC_LENGTH (args2);
13782 /* We don't count the pack expansion at the end. */
13783 if (template_args_variadic_p (TREE_PURPOSE (pat1)))
13785 if (template_args_variadic_p (TREE_PURPOSE (pat2)))
13790 else if (len1 < len2)
13797 /* Return the template arguments that will produce the function signature
13798 DECL from the function template FN, with the explicit template
13799 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
13800 also match. Return NULL_TREE if no satisfactory arguments could be
13804 get_bindings (tree fn, tree decl, tree explicit_args, bool check_rettype)
13806 int ntparms = DECL_NTPARMS (fn);
13807 tree targs = make_tree_vec (ntparms);
13809 tree decl_arg_types;
13811 /* Substitute the explicit template arguments into the type of DECL.
13812 The call to fn_type_unification will handle substitution into the
13814 decl_type = TREE_TYPE (decl);
13815 if (explicit_args && uses_template_parms (decl_type))
13818 tree converted_args;
13820 if (DECL_TEMPLATE_INFO (decl))
13821 tmpl = DECL_TI_TEMPLATE (decl);
13823 /* We can get here for some invalid specializations. */
13827 = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
13828 explicit_args, NULL_TREE,
13830 /*require_all_args=*/false,
13831 /*use_default_args=*/false);
13832 if (converted_args == error_mark_node)
13835 decl_type = tsubst (decl_type, converted_args, tf_none, NULL_TREE);
13836 if (decl_type == error_mark_node)
13840 /* Never do unification on the 'this' parameter. */
13841 decl_arg_types = skip_artificial_parms_for (decl,
13842 TYPE_ARG_TYPES (decl_type));
13844 if (fn_type_unification (fn, explicit_args, targs,
13846 (check_rettype || DECL_CONV_FN_P (fn)
13847 ? TREE_TYPE (decl_type) : NULL_TREE),
13848 DEDUCE_EXACT, LOOKUP_NORMAL))
13854 /* Return the innermost template arguments that, when applied to a
13855 template specialization whose innermost template parameters are
13856 TPARMS, and whose specialization arguments are PARMS, yield the
13859 For example, suppose we have:
13861 template <class T, class U> struct S {};
13862 template <class T> struct S<T*, int> {};
13864 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
13865 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
13866 int}. The resulting vector will be {double}, indicating that `T'
13867 is bound to `double'. */
13870 get_class_bindings (tree tparms, tree spec_args, tree args)
13872 int i, ntparms = TREE_VEC_LENGTH (tparms);
13874 tree innermost_deduced_args;
13876 innermost_deduced_args = make_tree_vec (ntparms);
13877 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
13879 deduced_args = copy_node (args);
13880 SET_TMPL_ARGS_LEVEL (deduced_args,
13881 TMPL_ARGS_DEPTH (deduced_args),
13882 innermost_deduced_args);
13885 deduced_args = innermost_deduced_args;
13887 if (unify (tparms, deduced_args,
13888 INNERMOST_TEMPLATE_ARGS (spec_args),
13889 INNERMOST_TEMPLATE_ARGS (args),
13893 for (i = 0; i < ntparms; ++i)
13894 if (! TREE_VEC_ELT (innermost_deduced_args, i))
13897 /* Verify that nondeduced template arguments agree with the type
13898 obtained from argument deduction.
13902 struct A { typedef int X; };
13903 template <class T, class U> struct C {};
13904 template <class T> struct C<T, typename T::X> {};
13906 Then with the instantiation `C<A, int>', we can deduce that
13907 `T' is `A' but unify () does not check whether `typename T::X'
13909 spec_args = tsubst (spec_args, deduced_args, tf_none, NULL_TREE);
13910 if (spec_args == error_mark_node
13911 /* We only need to check the innermost arguments; the other
13912 arguments will always agree. */
13913 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args),
13914 INNERMOST_TEMPLATE_ARGS (args)))
13917 /* Now that we have bindings for all of the template arguments,
13918 ensure that the arguments deduced for the template template
13919 parameters have compatible template parameter lists. See the use
13920 of template_template_parm_bindings_ok_p in fn_type_unification
13921 for more information. */
13922 if (!template_template_parm_bindings_ok_p (tparms, deduced_args))
13925 return deduced_args;
13928 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
13929 Return the TREE_LIST node with the most specialized template, if
13930 any. If there is no most specialized template, the error_mark_node
13933 Note that this function does not look at, or modify, the
13934 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
13935 returned is one of the elements of INSTANTIATIONS, callers may
13936 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
13937 and retrieve it from the value returned. */
13940 most_specialized_instantiation (tree templates)
13944 ++processing_template_decl;
13947 for (fn = TREE_CHAIN (templates); fn; fn = TREE_CHAIN (fn))
13951 if (get_bindings (TREE_VALUE (champ),
13952 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
13953 NULL_TREE, /*check_ret=*/false))
13956 if (get_bindings (TREE_VALUE (fn),
13957 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
13958 NULL_TREE, /*check_ret=*/false))
13965 /* Equally specialized, move to next function. If there
13966 is no next function, nothing's most specialized. */
13967 fn = TREE_CHAIN (fn);
13975 /* Now verify that champ is better than everything earlier in the
13976 instantiation list. */
13977 for (fn = templates; fn != champ; fn = TREE_CHAIN (fn))
13978 if (get_bindings (TREE_VALUE (champ),
13979 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
13980 NULL_TREE, /*check_ret=*/false)
13981 || !get_bindings (TREE_VALUE (fn),
13982 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
13983 NULL_TREE, /*check_ret=*/false))
13989 processing_template_decl--;
13992 return error_mark_node;
13997 /* If DECL is a specialization of some template, return the most
13998 general such template. Otherwise, returns NULL_TREE.
14000 For example, given:
14002 template <class T> struct S { template <class U> void f(U); };
14004 if TMPL is `template <class U> void S<int>::f(U)' this will return
14005 the full template. This function will not trace past partial
14006 specializations, however. For example, given in addition:
14008 template <class T> struct S<T*> { template <class U> void f(U); };
14010 if TMPL is `template <class U> void S<int*>::f(U)' this will return
14011 `template <class T> template <class U> S<T*>::f(U)'. */
14014 most_general_template (tree decl)
14016 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
14017 an immediate specialization. */
14018 if (TREE_CODE (decl) == FUNCTION_DECL)
14020 if (DECL_TEMPLATE_INFO (decl)) {
14021 decl = DECL_TI_TEMPLATE (decl);
14023 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
14024 template friend. */
14025 if (TREE_CODE (decl) != TEMPLATE_DECL)
14031 /* Look for more and more general templates. */
14032 while (DECL_TEMPLATE_INFO (decl))
14034 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
14035 (See cp-tree.h for details.) */
14036 if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
14039 if (CLASS_TYPE_P (TREE_TYPE (decl))
14040 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
14043 /* Stop if we run into an explicitly specialized class template. */
14044 if (!DECL_NAMESPACE_SCOPE_P (decl)
14045 && DECL_CONTEXT (decl)
14046 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl)))
14049 decl = DECL_TI_TEMPLATE (decl);
14055 /* Return the most specialized of the class template partial
14056 specializations of TMPL which can produce TYPE, a specialization of
14057 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
14058 a _TYPE node corresponding to the partial specialization, while the
14059 TREE_PURPOSE is the set of template arguments that must be
14060 substituted into the TREE_TYPE in order to generate TYPE.
14062 If the choice of partial specialization is ambiguous, a diagnostic
14063 is issued, and the error_mark_node is returned. If there are no
14064 partial specializations of TMPL matching TYPE, then NULL_TREE is
14068 most_specialized_class (tree type, tree tmpl)
14070 tree list = NULL_TREE;
14076 tree outer_args = NULL_TREE;
14078 tmpl = most_general_template (tmpl);
14079 args = CLASSTYPE_TI_ARGS (type);
14081 /* For determining which partial specialization to use, only the
14082 innermost args are interesting. */
14083 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
14085 outer_args = strip_innermost_template_args (args, 1);
14086 args = INNERMOST_TEMPLATE_ARGS (args);
14089 for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t))
14091 tree partial_spec_args;
14093 tree parms = TREE_VALUE (t);
14095 partial_spec_args = CLASSTYPE_TI_ARGS (TREE_TYPE (t));
14100 ++processing_template_decl;
14102 /* Discard the outer levels of args, and then substitute in the
14103 template args from the enclosing class. */
14104 partial_spec_args = INNERMOST_TEMPLATE_ARGS (partial_spec_args);
14105 partial_spec_args = tsubst_template_args
14106 (partial_spec_args, outer_args, tf_none, NULL_TREE);
14108 /* PARMS already refers to just the innermost parms, but the
14109 template parms in partial_spec_args had their levels lowered
14110 by tsubst, so we need to do the same for the parm list. We
14111 can't just tsubst the TREE_VEC itself, as tsubst wants to
14112 treat a TREE_VEC as an argument vector. */
14113 parms = copy_node (parms);
14114 for (i = TREE_VEC_LENGTH (parms) - 1; i >= 0; --i)
14115 TREE_VEC_ELT (parms, i) =
14116 tsubst (TREE_VEC_ELT (parms, i), outer_args, tf_none, NULL_TREE);
14118 --processing_template_decl;
14120 spec_args = get_class_bindings (parms,
14126 spec_args = add_to_template_args (outer_args, spec_args);
14127 list = tree_cons (spec_args, TREE_VALUE (t), list);
14128 TREE_TYPE (list) = TREE_TYPE (t);
14135 ambiguous_p = false;
14138 t = TREE_CHAIN (t);
14139 for (; t; t = TREE_CHAIN (t))
14141 fate = more_specialized_class (champ, t);
14148 t = TREE_CHAIN (t);
14151 ambiguous_p = true;
14160 for (t = list; t && t != champ; t = TREE_CHAIN (t))
14162 fate = more_specialized_class (champ, t);
14165 ambiguous_p = true;
14172 const char *str = "candidates are:";
14173 error ("ambiguous class template instantiation for %q#T", type);
14174 for (t = list; t; t = TREE_CHAIN (t))
14176 error ("%s %+#T", str, TREE_TYPE (t));
14179 return error_mark_node;
14185 /* Explicitly instantiate DECL. */
14188 do_decl_instantiation (tree decl, tree storage)
14190 tree result = NULL_TREE;
14193 if (!decl || decl == error_mark_node)
14194 /* An error occurred, for which grokdeclarator has already issued
14195 an appropriate message. */
14197 else if (! DECL_LANG_SPECIFIC (decl))
14199 error ("explicit instantiation of non-template %q#D", decl);
14202 else if (TREE_CODE (decl) == VAR_DECL)
14204 /* There is an asymmetry here in the way VAR_DECLs and
14205 FUNCTION_DECLs are handled by grokdeclarator. In the case of
14206 the latter, the DECL we get back will be marked as a
14207 template instantiation, and the appropriate
14208 DECL_TEMPLATE_INFO will be set up. This does not happen for
14209 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
14210 should handle VAR_DECLs as it currently handles
14212 if (!DECL_CLASS_SCOPE_P (decl))
14214 error ("%qD is not a static data member of a class template", decl);
14217 result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false);
14218 if (!result || TREE_CODE (result) != VAR_DECL)
14220 error ("no matching template for %qD found", decl);
14223 if (!same_type_p (TREE_TYPE (result), TREE_TYPE (decl)))
14225 error ("type %qT for explicit instantiation %qD does not match "
14226 "declared type %qT", TREE_TYPE (result), decl,
14231 else if (TREE_CODE (decl) != FUNCTION_DECL)
14233 error ("explicit instantiation of %q#D", decl);
14239 /* Check for various error cases. Note that if the explicit
14240 instantiation is valid the RESULT will currently be marked as an
14241 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
14242 until we get here. */
14244 if (DECL_TEMPLATE_SPECIALIZATION (result))
14246 /* DR 259 [temp.spec].
14248 Both an explicit instantiation and a declaration of an explicit
14249 specialization shall not appear in a program unless the explicit
14250 instantiation follows a declaration of the explicit specialization.
14252 For a given set of template parameters, if an explicit
14253 instantiation of a template appears after a declaration of an
14254 explicit specialization for that template, the explicit
14255 instantiation has no effect. */
14258 else if (DECL_EXPLICIT_INSTANTIATION (result))
14262 No program shall explicitly instantiate any template more
14265 We check DECL_NOT_REALLY_EXTERN so as not to complain when
14266 the first instantiation was `extern' and the second is not,
14267 and EXTERN_P for the opposite case. */
14268 if (DECL_NOT_REALLY_EXTERN (result) && !extern_p)
14269 pedwarn ("duplicate explicit instantiation of %q#D", result);
14270 /* If an "extern" explicit instantiation follows an ordinary
14271 explicit instantiation, the template is instantiated. */
14275 else if (!DECL_IMPLICIT_INSTANTIATION (result))
14277 error ("no matching template for %qD found", result);
14280 else if (!DECL_TEMPLATE_INFO (result))
14282 pedwarn ("explicit instantiation of non-template %q#D", result);
14286 if (storage == NULL_TREE)
14288 else if (storage == ridpointers[(int) RID_EXTERN])
14290 if (pedantic && !in_system_header)
14291 pedwarn ("ISO C++ forbids the use of %<extern%> on explicit "
14296 error ("storage class %qD applied to template instantiation", storage);
14298 check_explicit_instantiation_namespace (result);
14299 mark_decl_instantiated (result, extern_p);
14301 instantiate_decl (result, /*defer_ok=*/1,
14302 /*expl_inst_class_mem_p=*/false);
14306 mark_class_instantiated (tree t, int extern_p)
14308 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
14309 SET_CLASSTYPE_INTERFACE_KNOWN (t);
14310 CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
14311 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
14314 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
14315 rest_of_type_compilation (t, 1);
14319 /* Called from do_type_instantiation through binding_table_foreach to
14320 do recursive instantiation for the type bound in ENTRY. */
14322 bt_instantiate_type_proc (binding_entry entry, void *data)
14324 tree storage = *(tree *) data;
14326 if (IS_AGGR_TYPE (entry->type)
14327 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type)))
14328 do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0);
14331 /* Called from do_type_instantiation to instantiate a member
14332 (a member function or a static member variable) of an
14333 explicitly instantiated class template. */
14335 instantiate_class_member (tree decl, int extern_p)
14337 mark_decl_instantiated (decl, extern_p);
14339 instantiate_decl (decl, /*defer_ok=*/1,
14340 /*expl_inst_class_mem_p=*/true);
14343 /* Perform an explicit instantiation of template class T. STORAGE, if
14344 non-null, is the RID for extern, inline or static. COMPLAIN is
14345 nonzero if this is called from the parser, zero if called recursively,
14346 since the standard is unclear (as detailed below). */
14349 do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
14354 int previous_instantiation_extern_p = 0;
14356 if (TREE_CODE (t) == TYPE_DECL)
14359 if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t))
14361 error ("explicit instantiation of non-template type %qT", t);
14367 if (!COMPLETE_TYPE_P (t))
14369 if (complain & tf_error)
14370 error ("explicit instantiation of %q#T before definition of template",
14375 if (storage != NULL_TREE)
14377 if (pedantic && !in_system_header)
14378 pedwarn("ISO C++ forbids the use of %qE on explicit instantiations",
14381 if (storage == ridpointers[(int) RID_INLINE])
14383 else if (storage == ridpointers[(int) RID_EXTERN])
14385 else if (storage == ridpointers[(int) RID_STATIC])
14389 error ("storage class %qD applied to template instantiation",
14395 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
14397 /* DR 259 [temp.spec].
14399 Both an explicit instantiation and a declaration of an explicit
14400 specialization shall not appear in a program unless the explicit
14401 instantiation follows a declaration of the explicit specialization.
14403 For a given set of template parameters, if an explicit
14404 instantiation of a template appears after a declaration of an
14405 explicit specialization for that template, the explicit
14406 instantiation has no effect. */
14409 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t))
14413 No program shall explicitly instantiate any template more
14416 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
14417 instantiation was `extern'. If EXTERN_P then the second is.
14418 These cases are OK. */
14419 previous_instantiation_extern_p = CLASSTYPE_INTERFACE_ONLY (t);
14421 if (!previous_instantiation_extern_p && !extern_p
14422 && (complain & tf_error))
14423 pedwarn ("duplicate explicit instantiation of %q#T", t);
14425 /* If we've already instantiated the template, just return now. */
14426 if (!CLASSTYPE_INTERFACE_ONLY (t))
14430 check_explicit_instantiation_namespace (TYPE_NAME (t));
14431 mark_class_instantiated (t, extern_p);
14439 /* In contrast to implicit instantiation, where only the
14440 declarations, and not the definitions, of members are
14441 instantiated, we have here:
14445 The explicit instantiation of a class template specialization
14446 implies the instantiation of all of its members not
14447 previously explicitly specialized in the translation unit
14448 containing the explicit instantiation.
14450 Of course, we can't instantiate member template classes, since
14451 we don't have any arguments for them. Note that the standard
14452 is unclear on whether the instantiation of the members are
14453 *explicit* instantiations or not. However, the most natural
14454 interpretation is that it should be an explicit instantiation. */
14457 for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp))
14458 if (TREE_CODE (tmp) == FUNCTION_DECL
14459 && DECL_TEMPLATE_INSTANTIATION (tmp))
14460 instantiate_class_member (tmp, extern_p);
14462 for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp))
14463 if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp))
14464 instantiate_class_member (tmp, extern_p);
14466 if (CLASSTYPE_NESTED_UTDS (t))
14467 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t),
14468 bt_instantiate_type_proc, &storage);
14472 /* Given a function DECL, which is a specialization of TMPL, modify
14473 DECL to be a re-instantiation of TMPL with the same template
14474 arguments. TMPL should be the template into which tsubst'ing
14475 should occur for DECL, not the most general template.
14477 One reason for doing this is a scenario like this:
14480 void f(const T&, int i);
14482 void g() { f(3, 7); }
14485 void f(const T& t, const int i) { }
14487 Note that when the template is first instantiated, with
14488 instantiate_template, the resulting DECL will have no name for the
14489 first parameter, and the wrong type for the second. So, when we go
14490 to instantiate the DECL, we regenerate it. */
14493 regenerate_decl_from_template (tree decl, tree tmpl)
14495 /* The arguments used to instantiate DECL, from the most general
14500 args = DECL_TI_ARGS (decl);
14501 code_pattern = DECL_TEMPLATE_RESULT (tmpl);
14503 /* Make sure that we can see identifiers, and compute access
14505 push_access_scope (decl);
14507 if (TREE_CODE (decl) == FUNCTION_DECL)
14515 args_depth = TMPL_ARGS_DEPTH (args);
14516 parms_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
14517 if (args_depth > parms_depth)
14518 args = get_innermost_template_args (args, parms_depth);
14520 specs = tsubst_exception_specification (TREE_TYPE (code_pattern),
14521 args, tf_error, NULL_TREE);
14523 TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl),
14526 /* Merge parameter declarations. */
14527 decl_parm = skip_artificial_parms_for (decl,
14528 DECL_ARGUMENTS (decl));
14530 = skip_artificial_parms_for (code_pattern,
14531 DECL_ARGUMENTS (code_pattern));
14532 while (decl_parm && !FUNCTION_PARAMETER_PACK_P (pattern_parm))
14537 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
14538 DECL_NAME (decl_parm) = DECL_NAME (pattern_parm);
14539 parm_type = tsubst (TREE_TYPE (pattern_parm), args, tf_error,
14541 parm_type = type_decays_to (parm_type);
14542 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
14543 TREE_TYPE (decl_parm) = parm_type;
14544 attributes = DECL_ATTRIBUTES (pattern_parm);
14545 if (DECL_ATTRIBUTES (decl_parm) != attributes)
14547 DECL_ATTRIBUTES (decl_parm) = attributes;
14548 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
14550 decl_parm = TREE_CHAIN (decl_parm);
14551 pattern_parm = TREE_CHAIN (pattern_parm);
14553 /* Merge any parameters that match with the function parameter
14555 if (pattern_parm && FUNCTION_PARAMETER_PACK_P (pattern_parm))
14558 tree expanded_types;
14559 /* Expand the TYPE_PACK_EXPANSION that provides the types for
14560 the parameters in this function parameter pack. */
14561 expanded_types = tsubst_pack_expansion (TREE_TYPE (pattern_parm),
14562 args, tf_error, NULL_TREE);
14563 len = TREE_VEC_LENGTH (expanded_types);
14564 for (i = 0; i < len; i++)
14569 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
14570 /* Rename the parameter to include the index. */
14571 DECL_NAME (decl_parm) =
14572 make_ith_pack_parameter_name (DECL_NAME (pattern_parm), i);
14573 parm_type = TREE_VEC_ELT (expanded_types, i);
14574 parm_type = type_decays_to (parm_type);
14575 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
14576 TREE_TYPE (decl_parm) = parm_type;
14577 attributes = DECL_ATTRIBUTES (pattern_parm);
14578 if (DECL_ATTRIBUTES (decl_parm) != attributes)
14580 DECL_ATTRIBUTES (decl_parm) = attributes;
14581 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
14583 decl_parm = TREE_CHAIN (decl_parm);
14586 /* Merge additional specifiers from the CODE_PATTERN. */
14587 if (DECL_DECLARED_INLINE_P (code_pattern)
14588 && !DECL_DECLARED_INLINE_P (decl))
14589 DECL_DECLARED_INLINE_P (decl) = 1;
14590 if (DECL_INLINE (code_pattern) && !DECL_INLINE (decl))
14591 DECL_INLINE (decl) = 1;
14593 else if (TREE_CODE (decl) == VAR_DECL)
14594 DECL_INITIAL (decl) =
14595 tsubst_expr (DECL_INITIAL (code_pattern), args,
14596 tf_error, DECL_TI_TEMPLATE (decl),
14597 /*integral_constant_expression_p=*/false);
14599 gcc_unreachable ();
14601 pop_access_scope (decl);
14604 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
14605 substituted to get DECL. */
14608 template_for_substitution (tree decl)
14610 tree tmpl = DECL_TI_TEMPLATE (decl);
14612 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
14613 for the instantiation. This is not always the most general
14614 template. Consider, for example:
14617 struct S { template <class U> void f();
14618 template <> void f<int>(); };
14620 and an instantiation of S<double>::f<int>. We want TD to be the
14621 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
14622 while (/* An instantiation cannot have a definition, so we need a
14623 more general template. */
14624 DECL_TEMPLATE_INSTANTIATION (tmpl)
14625 /* We must also deal with friend templates. Given:
14627 template <class T> struct S {
14628 template <class U> friend void f() {};
14631 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
14632 so far as the language is concerned, but that's still
14633 where we get the pattern for the instantiation from. On
14634 other hand, if the definition comes outside the class, say:
14636 template <class T> struct S {
14637 template <class U> friend void f();
14639 template <class U> friend void f() {}
14641 we don't need to look any further. That's what the check for
14642 DECL_INITIAL is for. */
14643 || (TREE_CODE (decl) == FUNCTION_DECL
14644 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl)
14645 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl))))
14647 /* The present template, TD, should not be a definition. If it
14648 were a definition, we should be using it! Note that we
14649 cannot restructure the loop to just keep going until we find
14650 a template with a definition, since that might go too far if
14651 a specialization was declared, but not defined. */
14652 gcc_assert (TREE_CODE (decl) != VAR_DECL
14653 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl)));
14655 /* Fetch the more general template. */
14656 tmpl = DECL_TI_TEMPLATE (tmpl);
14662 /* Produce the definition of D, a _DECL generated from a template. If
14663 DEFER_OK is nonzero, then we don't have to actually do the
14664 instantiation now; we just have to do it sometime. Normally it is
14665 an error if this is an explicit instantiation but D is undefined.
14666 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
14667 explicitly instantiated class template. */
14670 instantiate_decl (tree d, int defer_ok,
14671 bool expl_inst_class_mem_p)
14673 tree tmpl = DECL_TI_TEMPLATE (d);
14680 bool pattern_defined;
14682 location_t saved_loc = input_location;
14683 int saved_in_system_header = in_system_header;
14686 /* This function should only be used to instantiate templates for
14687 functions and static member variables. */
14688 gcc_assert (TREE_CODE (d) == FUNCTION_DECL
14689 || TREE_CODE (d) == VAR_DECL);
14691 /* Variables are never deferred; if instantiation is required, they
14692 are instantiated right away. That allows for better code in the
14693 case that an expression refers to the value of the variable --
14694 if the variable has a constant value the referring expression can
14695 take advantage of that fact. */
14696 if (TREE_CODE (d) == VAR_DECL)
14699 /* Don't instantiate cloned functions. Instead, instantiate the
14700 functions they cloned. */
14701 if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d))
14702 d = DECL_CLONED_FUNCTION (d);
14704 if (DECL_TEMPLATE_INSTANTIATED (d))
14705 /* D has already been instantiated. It might seem reasonable to
14706 check whether or not D is an explicit instantiation, and, if so,
14707 stop here. But when an explicit instantiation is deferred
14708 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
14709 is set, even though we still need to do the instantiation. */
14712 /* If we already have a specialization of this declaration, then
14713 there's no reason to instantiate it. Note that
14714 retrieve_specialization gives us both instantiations and
14715 specializations, so we must explicitly check
14716 DECL_TEMPLATE_SPECIALIZATION. */
14717 gen_tmpl = most_general_template (tmpl);
14718 gen_args = DECL_TI_ARGS (d);
14719 spec = retrieve_specialization (gen_tmpl, gen_args,
14720 /*class_specializations_p=*/false);
14721 if (spec != NULL_TREE && DECL_TEMPLATE_SPECIALIZATION (spec))
14724 /* This needs to happen before any tsubsting. */
14725 if (! push_tinst_level (d))
14728 timevar_push (TV_PARSE);
14730 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
14731 for the instantiation. */
14732 td = template_for_substitution (d);
14733 code_pattern = DECL_TEMPLATE_RESULT (td);
14735 /* We should never be trying to instantiate a member of a class
14736 template or partial specialization. */
14737 gcc_assert (d != code_pattern);
14739 if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d))
14740 || DECL_TEMPLATE_SPECIALIZATION (td))
14741 /* In the case of a friend template whose definition is provided
14742 outside the class, we may have too many arguments. Drop the
14743 ones we don't need. The same is true for specializations. */
14744 args = get_innermost_template_args
14745 (gen_args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td)));
14749 if (TREE_CODE (d) == FUNCTION_DECL)
14750 pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE);
14752 pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
14754 /* We may be in the middle of deferred access check. Disable it now. */
14755 push_deferring_access_checks (dk_no_deferred);
14757 /* Unless an explicit instantiation directive has already determined
14758 the linkage of D, remember that a definition is available for
14760 if (pattern_defined
14761 && !DECL_INTERFACE_KNOWN (d)
14762 && !DECL_NOT_REALLY_EXTERN (d))
14763 mark_definable (d);
14765 input_location = DECL_SOURCE_LOCATION (d);
14766 in_system_header = DECL_IN_SYSTEM_HEADER (d);
14768 /* If D is a member of an explicitly instantiated class template,
14769 and no definition is available, treat it like an implicit
14771 if (!pattern_defined && expl_inst_class_mem_p
14772 && DECL_EXPLICIT_INSTANTIATION (d))
14774 DECL_NOT_REALLY_EXTERN (d) = 0;
14775 DECL_INTERFACE_KNOWN (d) = 0;
14776 SET_DECL_IMPLICIT_INSTANTIATION (d);
14781 /* Recheck the substitutions to obtain any warning messages
14782 about ignoring cv qualifiers. */
14783 tree gen = DECL_TEMPLATE_RESULT (gen_tmpl);
14784 tree type = TREE_TYPE (gen);
14786 /* Make sure that we can see identifiers, and compute access
14787 correctly. D is already the target FUNCTION_DECL with the
14789 push_access_scope (d);
14791 if (TREE_CODE (gen) == FUNCTION_DECL)
14793 tsubst (DECL_ARGUMENTS (gen), gen_args, tf_warning_or_error, d);
14794 tsubst_exception_specification (type, gen_args, tf_warning_or_error,
14796 /* Don't simply tsubst the function type, as that will give
14797 duplicate warnings about poor parameter qualifications.
14798 The function arguments are the same as the decl_arguments
14799 without the top level cv qualifiers. */
14800 type = TREE_TYPE (type);
14802 tsubst (type, gen_args, tf_warning_or_error, d);
14804 pop_access_scope (d);
14807 /* Check to see whether we know that this template will be
14808 instantiated in some other file, as with "extern template"
14810 external_p = (DECL_INTERFACE_KNOWN (d) && DECL_REALLY_EXTERN (d));
14811 /* In general, we do not instantiate such templates... */
14813 /* ... but we instantiate inline functions so that we can inline
14815 && ! (TREE_CODE (d) == FUNCTION_DECL && DECL_INLINE (d))
14816 /* ... we instantiate static data members whose values are
14817 needed in integral constant expressions. */
14818 && ! (TREE_CODE (d) == VAR_DECL
14819 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (d)))
14821 /* Defer all other templates, unless we have been explicitly
14822 forbidden from doing so. */
14823 if (/* If there is no definition, we cannot instantiate the
14826 /* If it's OK to postpone instantiation, do so. */
14828 /* If this is a static data member that will be defined
14829 elsewhere, we don't want to instantiate the entire data
14830 member, but we do want to instantiate the initializer so that
14831 we can substitute that elsewhere. */
14832 || (external_p && TREE_CODE (d) == VAR_DECL))
14834 /* The definition of the static data member is now required so
14835 we must substitute the initializer. */
14836 if (TREE_CODE (d) == VAR_DECL
14837 && !DECL_INITIAL (d)
14838 && DECL_INITIAL (code_pattern))
14843 ns = decl_namespace_context (d);
14844 push_nested_namespace (ns);
14845 push_nested_class (DECL_CONTEXT (d));
14846 init = tsubst_expr (DECL_INITIAL (code_pattern),
14848 tf_warning_or_error, NULL_TREE,
14849 /*integral_constant_expression_p=*/false);
14850 cp_finish_decl (d, init, /*init_const_expr_p=*/false,
14851 /*asmspec_tree=*/NULL_TREE,
14852 LOOKUP_ONLYCONVERTING);
14853 pop_nested_class ();
14854 pop_nested_namespace (ns);
14857 /* We restore the source position here because it's used by
14858 add_pending_template. */
14859 input_location = saved_loc;
14861 if (at_eof && !pattern_defined
14862 && DECL_EXPLICIT_INSTANTIATION (d))
14865 The definition of a non-exported function template, a
14866 non-exported member function template, or a non-exported
14867 member function or static data member of a class template
14868 shall be present in every translation unit in which it is
14869 explicitly instantiated. */
14871 ("explicit instantiation of %qD but no definition available", d);
14873 /* ??? Historically, we have instantiated inline functions, even
14874 when marked as "extern template". */
14875 if (!(external_p && TREE_CODE (d) == VAR_DECL))
14876 add_pending_template (d);
14879 /* Tell the repository that D is available in this translation unit
14880 -- and see if it is supposed to be instantiated here. */
14881 if (TREE_PUBLIC (d) && !DECL_REALLY_EXTERN (d) && !repo_emit_p (d))
14883 /* In a PCH file, despite the fact that the repository hasn't
14884 requested instantiation in the PCH it is still possible that
14885 an instantiation will be required in a file that includes the
14888 add_pending_template (d);
14889 /* Instantiate inline functions so that the inliner can do its
14890 job, even though we'll not be emitting a copy of this
14892 if (!(TREE_CODE (d) == FUNCTION_DECL
14893 && flag_inline_trees
14894 && DECL_DECLARED_INLINE_P (d)))
14898 need_push = !cfun || !global_bindings_p ();
14900 push_to_top_level ();
14902 /* Mark D as instantiated so that recursive calls to
14903 instantiate_decl do not try to instantiate it again. */
14904 DECL_TEMPLATE_INSTANTIATED (d) = 1;
14906 /* Regenerate the declaration in case the template has been modified
14907 by a subsequent redeclaration. */
14908 regenerate_decl_from_template (d, td);
14910 /* We already set the file and line above. Reset them now in case
14911 they changed as a result of calling regenerate_decl_from_template. */
14912 input_location = DECL_SOURCE_LOCATION (d);
14914 if (TREE_CODE (d) == VAR_DECL)
14918 /* Clear out DECL_RTL; whatever was there before may not be right
14919 since we've reset the type of the declaration. */
14920 SET_DECL_RTL (d, NULL_RTX);
14921 DECL_IN_AGGR_P (d) = 0;
14923 /* The initializer is placed in DECL_INITIAL by
14924 regenerate_decl_from_template. Pull it out so that
14925 finish_decl can process it. */
14926 init = DECL_INITIAL (d);
14927 DECL_INITIAL (d) = NULL_TREE;
14928 DECL_INITIALIZED_P (d) = 0;
14930 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
14931 initializer. That function will defer actual emission until
14932 we have a chance to determine linkage. */
14933 DECL_EXTERNAL (d) = 0;
14935 /* Enter the scope of D so that access-checking works correctly. */
14936 push_nested_class (DECL_CONTEXT (d));
14937 finish_decl (d, init, NULL_TREE);
14938 pop_nested_class ();
14940 else if (TREE_CODE (d) == FUNCTION_DECL)
14942 htab_t saved_local_specializations;
14947 /* Save away the current list, in case we are instantiating one
14948 template from within the body of another. */
14949 saved_local_specializations = local_specializations;
14951 /* Set up the list of local specializations. */
14952 local_specializations = htab_create (37,
14953 hash_local_specialization,
14954 eq_local_specializations,
14957 /* Set up context. */
14958 start_preparsed_function (d, NULL_TREE, SF_PRE_PARSED);
14960 /* Create substitution entries for the parameters. */
14961 subst_decl = DECL_TEMPLATE_RESULT (template_for_substitution (d));
14962 tmpl_parm = DECL_ARGUMENTS (subst_decl);
14963 spec_parm = DECL_ARGUMENTS (d);
14964 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d))
14966 register_local_specialization (spec_parm, tmpl_parm);
14967 spec_parm = skip_artificial_parms_for (d, spec_parm);
14968 tmpl_parm = skip_artificial_parms_for (subst_decl, tmpl_parm);
14970 while (tmpl_parm && !FUNCTION_PARAMETER_PACK_P (tmpl_parm))
14972 register_local_specialization (spec_parm, tmpl_parm);
14973 tmpl_parm = TREE_CHAIN (tmpl_parm);
14974 spec_parm = TREE_CHAIN (spec_parm);
14976 if (tmpl_parm && FUNCTION_PARAMETER_PACK_P (tmpl_parm))
14978 /* Collect all of the extra "packed" parameters into an
14982 tree argpack = make_node (NONTYPE_ARGUMENT_PACK);
14983 tree argtypepack = make_node (TYPE_ARGUMENT_PACK);
14987 /* Count how many parameters remain. */
14988 for (t = spec_parm; t; t = TREE_CHAIN (t))
14991 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
14992 parmvec = make_tree_vec (len);
14993 parmtypevec = make_tree_vec (len);
14994 for(i = 0; i < len; i++, spec_parm = TREE_CHAIN (spec_parm))
14996 TREE_VEC_ELT (parmvec, i) = spec_parm;
14997 TREE_VEC_ELT (parmtypevec, i) = TREE_TYPE (spec_parm);
15000 /* Build the argument packs. */
15001 SET_ARGUMENT_PACK_ARGS (argpack, parmvec);
15002 SET_ARGUMENT_PACK_ARGS (argtypepack, parmtypevec);
15003 TREE_TYPE (argpack) = argtypepack;
15005 /* Register the (value) argument pack as a specialization of
15006 TMPL_PARM, then move on. */
15007 register_local_specialization (argpack, tmpl_parm);
15008 tmpl_parm = TREE_CHAIN (tmpl_parm);
15010 gcc_assert (!spec_parm);
15012 /* Substitute into the body of the function. */
15013 tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
15014 tf_warning_or_error, tmpl,
15015 /*integral_constant_expression_p=*/false);
15017 /* Set the current input_location to the end of the function
15018 so that finish_function knows where we are. */
15019 input_location = DECL_STRUCT_FUNCTION (code_pattern)->function_end_locus;
15021 /* We don't need the local specializations any more. */
15022 htab_delete (local_specializations);
15023 local_specializations = saved_local_specializations;
15025 /* Finish the function. */
15026 d = finish_function (0);
15027 expand_or_defer_fn (d);
15030 /* We're not deferring instantiation any more. */
15031 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
15034 pop_from_top_level ();
15037 input_location = saved_loc;
15038 in_system_header = saved_in_system_header;
15039 pop_deferring_access_checks ();
15040 pop_tinst_level ();
15042 timevar_pop (TV_PARSE);
15047 /* Run through the list of templates that we wish we could
15048 instantiate, and instantiate any we can. RETRIES is the
15049 number of times we retry pending template instantiation. */
15052 instantiate_pending_templates (int retries)
15055 location_t saved_loc = input_location;
15056 int saved_in_system_header = in_system_header;
15058 /* Instantiating templates may trigger vtable generation. This in turn
15059 may require further template instantiations. We place a limit here
15060 to avoid infinite loop. */
15061 if (pending_templates && retries >= max_tinst_depth)
15063 tree decl = pending_templates->tinst->decl;
15065 error ("template instantiation depth exceeds maximum of %d"
15066 " instantiating %q+D, possibly from virtual table generation"
15067 " (use -ftemplate-depth-NN to increase the maximum)",
15068 max_tinst_depth, decl);
15069 if (TREE_CODE (decl) == FUNCTION_DECL)
15070 /* Pretend that we defined it. */
15071 DECL_INITIAL (decl) = error_mark_node;
15077 struct pending_template **t = &pending_templates;
15078 struct pending_template *last = NULL;
15082 tree instantiation = reopen_tinst_level ((*t)->tinst);
15083 bool complete = false;
15085 if (TYPE_P (instantiation))
15089 if (!COMPLETE_TYPE_P (instantiation))
15091 instantiate_class_template (instantiation);
15092 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
15093 for (fn = TYPE_METHODS (instantiation);
15095 fn = TREE_CHAIN (fn))
15096 if (! DECL_ARTIFICIAL (fn))
15097 instantiate_decl (fn,
15099 /*expl_inst_class_mem_p=*/false);
15100 if (COMPLETE_TYPE_P (instantiation))
15104 complete = COMPLETE_TYPE_P (instantiation);
15108 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation)
15109 && !DECL_TEMPLATE_INSTANTIATED (instantiation))
15112 = instantiate_decl (instantiation,
15114 /*expl_inst_class_mem_p=*/false);
15115 if (DECL_TEMPLATE_INSTANTIATED (instantiation))
15119 complete = (DECL_TEMPLATE_SPECIALIZATION (instantiation)
15120 || DECL_TEMPLATE_INSTANTIATED (instantiation));
15124 /* If INSTANTIATION has been instantiated, then we don't
15125 need to consider it again in the future. */
15133 current_tinst_level = NULL;
15135 last_pending_template = last;
15137 while (reconsider);
15139 input_location = saved_loc;
15140 in_system_header = saved_in_system_header;
15143 /* Substitute ARGVEC into T, which is a list of initializers for
15144 either base class or a non-static data member. The TREE_PURPOSEs
15145 are DECLs, and the TREE_VALUEs are the initializer values. Used by
15146 instantiate_decl. */
15149 tsubst_initializer_list (tree t, tree argvec)
15151 tree inits = NULL_TREE;
15153 for (; t; t = TREE_CHAIN (t))
15157 tree expanded_bases = NULL_TREE;
15158 tree expanded_arguments = NULL_TREE;
15161 if (TREE_CODE (TREE_PURPOSE (t)) == TYPE_PACK_EXPANSION)
15166 /* Expand the base class expansion type into separate base
15168 expanded_bases = tsubst_pack_expansion (TREE_PURPOSE (t), argvec,
15169 tf_warning_or_error,
15171 if (expanded_bases == error_mark_node)
15174 /* We'll be building separate TREE_LISTs of arguments for
15176 len = TREE_VEC_LENGTH (expanded_bases);
15177 expanded_arguments = make_tree_vec (len);
15178 for (i = 0; i < len; i++)
15179 TREE_VEC_ELT (expanded_arguments, i) = NULL_TREE;
15181 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
15182 expand each argument in the TREE_VALUE of t. */
15183 expr = make_node (EXPR_PACK_EXPANSION);
15184 PACK_EXPANSION_PARAMETER_PACKS (expr) =
15185 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t));
15187 if (TREE_VALUE (t) == void_type_node)
15188 /* VOID_TYPE_NODE is used to indicate
15189 value-initialization. */
15191 for (i = 0; i < len; i++)
15192 TREE_VEC_ELT (expanded_arguments, i) = void_type_node;
15196 /* Substitute parameter packs into each argument in the
15198 in_base_initializer = 1;
15199 for (arg = TREE_VALUE (t); arg; arg = TREE_CHAIN (arg))
15201 tree expanded_exprs;
15203 /* Expand the argument. */
15204 SET_PACK_EXPANSION_PATTERN (expr, TREE_VALUE (arg));
15206 = tsubst_pack_expansion (expr, argvec,
15207 tf_warning_or_error,
15210 /* Prepend each of the expanded expressions to the
15211 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
15212 for (i = 0; i < len; i++)
15214 TREE_VEC_ELT (expanded_arguments, i) =
15215 tree_cons (NULL_TREE,
15216 TREE_VEC_ELT (expanded_exprs, i),
15217 TREE_VEC_ELT (expanded_arguments, i));
15220 in_base_initializer = 0;
15222 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
15223 since we built them backwards. */
15224 for (i = 0; i < len; i++)
15226 TREE_VEC_ELT (expanded_arguments, i) =
15227 nreverse (TREE_VEC_ELT (expanded_arguments, i));
15232 for (i = 0; i < len; ++i)
15234 if (expanded_bases)
15236 decl = TREE_VEC_ELT (expanded_bases, i);
15237 decl = expand_member_init (decl);
15238 init = TREE_VEC_ELT (expanded_arguments, i);
15242 decl = tsubst_copy (TREE_PURPOSE (t), argvec,
15243 tf_warning_or_error, NULL_TREE);
15245 decl = expand_member_init (decl);
15246 if (decl && !DECL_P (decl))
15247 in_base_initializer = 1;
15249 init = tsubst_expr (TREE_VALUE (t), argvec,
15250 tf_warning_or_error, NULL_TREE,
15251 /*integral_constant_expression_p=*/false);
15252 in_base_initializer = 0;
15257 init = build_tree_list (decl, init);
15258 TREE_CHAIN (init) = inits;
15266 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
15269 set_current_access_from_decl (tree decl)
15271 if (TREE_PRIVATE (decl))
15272 current_access_specifier = access_private_node;
15273 else if (TREE_PROTECTED (decl))
15274 current_access_specifier = access_protected_node;
15276 current_access_specifier = access_public_node;
15279 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
15280 is the instantiation (which should have been created with
15281 start_enum) and ARGS are the template arguments to use. */
15284 tsubst_enum (tree tag, tree newtag, tree args)
15288 for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
15293 decl = TREE_VALUE (e);
15294 /* Note that in a template enum, the TREE_VALUE is the
15295 CONST_DECL, not the corresponding INTEGER_CST. */
15296 value = tsubst_expr (DECL_INITIAL (decl),
15297 args, tf_warning_or_error, NULL_TREE,
15298 /*integral_constant_expression_p=*/true);
15300 /* Give this enumeration constant the correct access. */
15301 set_current_access_from_decl (decl);
15303 /* Actually build the enumerator itself. */
15304 build_enumerator (DECL_NAME (decl), value, newtag);
15307 finish_enum (newtag);
15308 DECL_SOURCE_LOCATION (TYPE_NAME (newtag))
15309 = DECL_SOURCE_LOCATION (TYPE_NAME (tag));
15312 /* DECL is a FUNCTION_DECL that is a template specialization. Return
15313 its type -- but without substituting the innermost set of template
15314 arguments. So, innermost set of template parameters will appear in
15318 get_mostly_instantiated_function_type (tree decl)
15326 tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
15327 targs = DECL_TI_ARGS (decl);
15328 tparms = DECL_TEMPLATE_PARMS (tmpl);
15329 parm_depth = TMPL_PARMS_DEPTH (tparms);
15331 /* There should be as many levels of arguments as there are levels
15333 gcc_assert (parm_depth == TMPL_ARGS_DEPTH (targs));
15335 fn_type = TREE_TYPE (tmpl);
15337 if (parm_depth == 1)
15338 /* No substitution is necessary. */
15342 int i, save_access_control;
15345 /* Replace the innermost level of the TARGS with NULL_TREEs to
15346 let tsubst know not to substitute for those parameters. */
15347 partial_args = make_tree_vec (TREE_VEC_LENGTH (targs));
15348 for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i)
15349 SET_TMPL_ARGS_LEVEL (partial_args, i,
15350 TMPL_ARGS_LEVEL (targs, i));
15351 SET_TMPL_ARGS_LEVEL (partial_args,
15352 TMPL_ARGS_DEPTH (targs),
15353 make_tree_vec (DECL_NTPARMS (tmpl)));
15355 /* Disable access control as this function is used only during
15357 save_access_control = flag_access_control;
15358 flag_access_control = 0;
15360 ++processing_template_decl;
15361 /* Now, do the (partial) substitution to figure out the
15362 appropriate function type. */
15363 fn_type = tsubst (fn_type, partial_args, tf_error, NULL_TREE);
15364 --processing_template_decl;
15366 /* Substitute into the template parameters to obtain the real
15367 innermost set of parameters. This step is important if the
15368 innermost set of template parameters contains value
15369 parameters whose types depend on outer template parameters. */
15370 TREE_VEC_LENGTH (partial_args)--;
15371 tparms = tsubst_template_parms (tparms, partial_args, tf_error);
15373 flag_access_control = save_access_control;
15379 /* Return truthvalue if we're processing a template different from
15380 the last one involved in diagnostics. */
15382 problematic_instantiation_changed (void)
15384 return last_template_error_tick != tinst_level_tick;
15387 /* Remember current template involved in diagnostics. */
15389 record_last_problematic_instantiation (void)
15391 last_template_error_tick = tinst_level_tick;
15394 struct tinst_level *
15395 current_instantiation (void)
15397 return current_tinst_level;
15400 /* [temp.param] Check that template non-type parm TYPE is of an allowable
15401 type. Return zero for ok, nonzero for disallowed. Issue error and
15402 warning messages under control of COMPLAIN. */
15405 invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain)
15407 if (INTEGRAL_TYPE_P (type))
15409 else if (POINTER_TYPE_P (type))
15411 else if (TYPE_PTR_TO_MEMBER_P (type))
15413 else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
15415 else if (TREE_CODE (type) == TYPENAME_TYPE)
15418 if (complain & tf_error)
15419 error ("%q#T is not a valid type for a template constant parameter", type);
15423 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
15424 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
15427 dependent_type_p_r (tree type)
15433 A type is dependent if it is:
15435 -- a template parameter. Template template parameters are types
15436 for us (since TYPE_P holds true for them) so we handle
15438 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
15439 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
15441 /* -- a qualified-id with a nested-name-specifier which contains a
15442 class-name that names a dependent type or whose unqualified-id
15443 names a dependent type. */
15444 if (TREE_CODE (type) == TYPENAME_TYPE)
15446 /* -- a cv-qualified type where the cv-unqualified type is
15448 type = TYPE_MAIN_VARIANT (type);
15449 /* -- a compound type constructed from any dependent type. */
15450 if (TYPE_PTR_TO_MEMBER_P (type))
15451 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type))
15452 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
15454 else if (TREE_CODE (type) == POINTER_TYPE
15455 || TREE_CODE (type) == REFERENCE_TYPE)
15456 return dependent_type_p (TREE_TYPE (type));
15457 else if (TREE_CODE (type) == FUNCTION_TYPE
15458 || TREE_CODE (type) == METHOD_TYPE)
15462 if (dependent_type_p (TREE_TYPE (type)))
15464 for (arg_type = TYPE_ARG_TYPES (type);
15466 arg_type = TREE_CHAIN (arg_type))
15467 if (dependent_type_p (TREE_VALUE (arg_type)))
15471 /* -- an array type constructed from any dependent type or whose
15472 size is specified by a constant expression that is
15473 value-dependent. */
15474 if (TREE_CODE (type) == ARRAY_TYPE)
15476 if (TYPE_DOMAIN (type)
15477 && dependent_type_p (TYPE_DOMAIN (type)))
15479 return dependent_type_p (TREE_TYPE (type));
15481 else if (TREE_CODE (type) == INTEGER_TYPE
15482 && !TREE_CONSTANT (TYPE_MAX_VALUE (type)))
15484 /* If this is the TYPE_DOMAIN of an array type, consider it
15486 return (value_dependent_expression_p (TYPE_MAX_VALUE (type))
15487 || type_dependent_expression_p (TYPE_MAX_VALUE (type)));
15490 /* -- a template-id in which either the template name is a template
15492 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
15494 /* ... or any of the template arguments is a dependent type or
15495 an expression that is type-dependent or value-dependent. */
15496 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
15497 && (any_dependent_template_arguments_p
15498 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
15501 /* All TYPEOF_TYPEs and DECLTYPE_TYPEs are dependent; if the
15502 argument of the `typeof' expression is not type-dependent, then
15503 it should already been have resolved. */
15504 if (TREE_CODE (type) == TYPEOF_TYPE
15505 || TREE_CODE (type) == DECLTYPE_TYPE)
15508 /* A template argument pack is dependent if any of its packed
15510 if (TREE_CODE (type) == TYPE_ARGUMENT_PACK)
15512 tree args = ARGUMENT_PACK_ARGS (type);
15513 int i, len = TREE_VEC_LENGTH (args);
15514 for (i = 0; i < len; ++i)
15515 if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
15519 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
15520 be template parameters. */
15521 if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
15524 /* The standard does not specifically mention types that are local
15525 to template functions or local classes, but they should be
15526 considered dependent too. For example:
15528 template <int I> void f() {
15533 The size of `E' cannot be known until the value of `I' has been
15534 determined. Therefore, `E' must be considered dependent. */
15535 scope = TYPE_CONTEXT (type);
15536 if (scope && TYPE_P (scope))
15537 return dependent_type_p (scope);
15538 else if (scope && TREE_CODE (scope) == FUNCTION_DECL)
15539 return type_dependent_expression_p (scope);
15541 /* Other types are non-dependent. */
15545 /* Returns TRUE if TYPE is dependent, in the sense of
15546 [temp.dep.type]. */
15549 dependent_type_p (tree type)
15551 /* If there are no template parameters in scope, then there can't be
15552 any dependent types. */
15553 if (!processing_template_decl)
15555 /* If we are not processing a template, then nobody should be
15556 providing us with a dependent type. */
15558 gcc_assert (TREE_CODE (type) != TEMPLATE_TYPE_PARM);
15562 /* If the type is NULL, we have not computed a type for the entity
15563 in question; in that case, the type is dependent. */
15567 /* Erroneous types can be considered non-dependent. */
15568 if (type == error_mark_node)
15571 /* If we have not already computed the appropriate value for TYPE,
15573 if (!TYPE_DEPENDENT_P_VALID (type))
15575 TYPE_DEPENDENT_P (type) = dependent_type_p_r (type);
15576 TYPE_DEPENDENT_P_VALID (type) = 1;
15579 return TYPE_DEPENDENT_P (type);
15582 /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
15585 dependent_scope_ref_p (tree expression, bool criterion (tree))
15590 gcc_assert (TREE_CODE (expression) == SCOPE_REF);
15592 if (!TYPE_P (TREE_OPERAND (expression, 0)))
15595 scope = TREE_OPERAND (expression, 0);
15596 name = TREE_OPERAND (expression, 1);
15600 An id-expression is type-dependent if it contains a
15601 nested-name-specifier that contains a class-name that names a
15603 /* The suggested resolution to Core Issue 2 implies that if the
15604 qualifying type is the current class, then we must peek
15607 && currently_open_class (scope)
15608 && !criterion (name))
15610 if (dependent_type_p (scope))
15616 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
15617 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
15621 value_dependent_expression_p (tree expression)
15623 if (!processing_template_decl)
15626 /* A name declared with a dependent type. */
15627 if (DECL_P (expression) && type_dependent_expression_p (expression))
15630 switch (TREE_CODE (expression))
15632 case IDENTIFIER_NODE:
15633 /* A name that has not been looked up -- must be dependent. */
15636 case TEMPLATE_PARM_INDEX:
15637 /* A non-type template parm. */
15641 /* A non-type template parm. */
15642 if (DECL_TEMPLATE_PARM_P (expression))
15644 return value_dependent_expression_p (DECL_INITIAL (expression));
15647 /* A constant with integral or enumeration type and is initialized
15648 with an expression that is value-dependent. */
15649 if (DECL_INITIAL (expression)
15650 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression))
15651 && value_dependent_expression_p (DECL_INITIAL (expression)))
15655 case DYNAMIC_CAST_EXPR:
15656 case STATIC_CAST_EXPR:
15657 case CONST_CAST_EXPR:
15658 case REINTERPRET_CAST_EXPR:
15660 /* These expressions are value-dependent if the type to which
15661 the cast occurs is dependent or the expression being casted
15662 is value-dependent. */
15664 tree type = TREE_TYPE (expression);
15666 if (dependent_type_p (type))
15669 /* A functional cast has a list of operands. */
15670 expression = TREE_OPERAND (expression, 0);
15673 /* If there are no operands, it must be an expression such
15674 as "int()". This should not happen for aggregate types
15675 because it would form non-constant expressions. */
15676 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
15681 if (TREE_CODE (expression) == TREE_LIST)
15682 return any_value_dependent_elements_p (expression);
15684 return value_dependent_expression_p (expression);
15689 /* A `sizeof' expression is value-dependent if the operand is
15690 type-dependent or is a pack expansion. */
15691 expression = TREE_OPERAND (expression, 0);
15692 if (PACK_EXPANSION_P (expression))
15694 else if (TYPE_P (expression))
15695 return dependent_type_p (expression);
15696 return type_dependent_expression_p (expression);
15699 return dependent_scope_ref_p (expression, value_dependent_expression_p);
15701 case COMPONENT_REF:
15702 return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
15703 || value_dependent_expression_p (TREE_OPERAND (expression, 1)));
15706 /* A CALL_EXPR may appear in a constant expression if it is a
15707 call to a builtin function, e.g., __builtin_constant_p. All
15708 such calls are value-dependent. */
15711 case NONTYPE_ARGUMENT_PACK:
15712 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
15713 is value-dependent. */
15715 tree values = ARGUMENT_PACK_ARGS (expression);
15716 int i, len = TREE_VEC_LENGTH (values);
15718 for (i = 0; i < len; ++i)
15719 if (value_dependent_expression_p (TREE_VEC_ELT (values, i)))
15727 tree type2 = TRAIT_EXPR_TYPE2 (expression);
15728 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression))
15729 || (type2 ? dependent_type_p (type2) : false));
15733 return ((value_dependent_expression_p (TREE_OPERAND (expression, 0)))
15734 || (value_dependent_expression_p (TREE_OPERAND (expression, 2))));
15737 /* A constant expression is value-dependent if any subexpression is
15738 value-dependent. */
15739 switch (TREE_CODE_CLASS (TREE_CODE (expression)))
15741 case tcc_reference:
15743 return (value_dependent_expression_p
15744 (TREE_OPERAND (expression, 0)));
15746 case tcc_comparison:
15748 return ((value_dependent_expression_p
15749 (TREE_OPERAND (expression, 0)))
15750 || (value_dependent_expression_p
15751 (TREE_OPERAND (expression, 1))));
15753 case tcc_expression:
15757 for (i = 0; i < TREE_OPERAND_LENGTH (expression); ++i)
15758 /* In some cases, some of the operands may be missing.
15759 (For example, in the case of PREDECREMENT_EXPR, the
15760 amount to increment by may be missing.) That doesn't
15761 make the expression dependent. */
15762 if (TREE_OPERAND (expression, i)
15763 && (value_dependent_expression_p
15764 (TREE_OPERAND (expression, i))))
15774 /* The expression is not value-dependent. */
15778 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
15779 [temp.dep.expr]. */
15782 type_dependent_expression_p (tree expression)
15784 if (!processing_template_decl)
15787 if (expression == error_mark_node)
15790 /* An unresolved name is always dependent. */
15791 if (TREE_CODE (expression) == IDENTIFIER_NODE
15792 || TREE_CODE (expression) == USING_DECL)
15795 /* Some expression forms are never type-dependent. */
15796 if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR
15797 || TREE_CODE (expression) == SIZEOF_EXPR
15798 || TREE_CODE (expression) == ALIGNOF_EXPR
15799 || TREE_CODE (expression) == TRAIT_EXPR
15800 || TREE_CODE (expression) == TYPEID_EXPR
15801 || TREE_CODE (expression) == DELETE_EXPR
15802 || TREE_CODE (expression) == VEC_DELETE_EXPR
15803 || TREE_CODE (expression) == THROW_EXPR)
15806 /* The types of these expressions depends only on the type to which
15807 the cast occurs. */
15808 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
15809 || TREE_CODE (expression) == STATIC_CAST_EXPR
15810 || TREE_CODE (expression) == CONST_CAST_EXPR
15811 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
15812 || TREE_CODE (expression) == CAST_EXPR)
15813 return dependent_type_p (TREE_TYPE (expression));
15815 /* The types of these expressions depends only on the type created
15816 by the expression. */
15817 if (TREE_CODE (expression) == NEW_EXPR
15818 || TREE_CODE (expression) == VEC_NEW_EXPR)
15820 /* For NEW_EXPR tree nodes created inside a template, either
15821 the object type itself or a TREE_LIST may appear as the
15823 tree type = TREE_OPERAND (expression, 1);
15824 if (TREE_CODE (type) == TREE_LIST)
15825 /* This is an array type. We need to check array dimensions
15827 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type)))
15828 || value_dependent_expression_p
15829 (TREE_OPERAND (TREE_VALUE (type), 1));
15831 return dependent_type_p (type);
15834 if (TREE_CODE (expression) == SCOPE_REF
15835 && dependent_scope_ref_p (expression,
15836 type_dependent_expression_p))
15839 if (TREE_CODE (expression) == FUNCTION_DECL
15840 && DECL_LANG_SPECIFIC (expression)
15841 && DECL_TEMPLATE_INFO (expression)
15842 && (any_dependent_template_arguments_p
15843 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
15846 if (TREE_CODE (expression) == TEMPLATE_DECL
15847 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression))
15850 if (TREE_CODE (expression) == STMT_EXPR)
15851 expression = stmt_expr_value_expr (expression);
15853 if (TREE_TYPE (expression) == unknown_type_node)
15855 if (TREE_CODE (expression) == ADDR_EXPR)
15856 return type_dependent_expression_p (TREE_OPERAND (expression, 0));
15857 if (TREE_CODE (expression) == COMPONENT_REF
15858 || TREE_CODE (expression) == OFFSET_REF)
15860 if (type_dependent_expression_p (TREE_OPERAND (expression, 0)))
15862 expression = TREE_OPERAND (expression, 1);
15863 if (TREE_CODE (expression) == IDENTIFIER_NODE)
15866 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
15867 if (TREE_CODE (expression) == SCOPE_REF)
15870 if (TREE_CODE (expression) == BASELINK)
15871 expression = BASELINK_FUNCTIONS (expression);
15873 if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
15875 if (any_dependent_template_arguments_p
15876 (TREE_OPERAND (expression, 1)))
15878 expression = TREE_OPERAND (expression, 0);
15880 gcc_assert (TREE_CODE (expression) == OVERLOAD
15881 || TREE_CODE (expression) == FUNCTION_DECL);
15885 if (type_dependent_expression_p (OVL_CURRENT (expression)))
15887 expression = OVL_NEXT (expression);
15892 gcc_assert (TREE_CODE (expression) != TYPE_DECL);
15894 return (dependent_type_p (TREE_TYPE (expression)));
15897 /* Returns TRUE if ARGS (a TREE_LIST of arguments to a function call)
15898 contains a type-dependent expression. */
15901 any_type_dependent_arguments_p (const_tree args)
15905 tree arg = TREE_VALUE (args);
15907 if (type_dependent_expression_p (arg))
15909 args = TREE_CHAIN (args);
15914 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
15915 expressions) contains any value-dependent expressions. */
15918 any_value_dependent_elements_p (const_tree list)
15920 for (; list; list = TREE_CHAIN (list))
15921 if (value_dependent_expression_p (TREE_VALUE (list)))
15927 /* Returns TRUE if the ARG (a template argument) is dependent. */
15930 dependent_template_arg_p (tree arg)
15932 if (!processing_template_decl)
15935 if (TREE_CODE (arg) == TEMPLATE_DECL
15936 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
15937 return dependent_template_p (arg);
15938 else if (ARGUMENT_PACK_P (arg))
15940 tree args = ARGUMENT_PACK_ARGS (arg);
15941 int i, len = TREE_VEC_LENGTH (args);
15942 for (i = 0; i < len; ++i)
15944 if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
15950 else if (TYPE_P (arg))
15951 return dependent_type_p (arg);
15953 return (type_dependent_expression_p (arg)
15954 || value_dependent_expression_p (arg));
15957 /* Returns true if ARGS (a collection of template arguments) contains
15958 any types that require structural equality testing. */
15961 any_template_arguments_need_structural_equality_p (tree args)
15968 if (args == error_mark_node)
15971 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
15973 tree level = TMPL_ARGS_LEVEL (args, i + 1);
15974 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
15976 tree arg = TREE_VEC_ELT (level, j);
15977 tree packed_args = NULL_TREE;
15980 if (ARGUMENT_PACK_P (arg))
15982 /* Look inside the argument pack. */
15983 packed_args = ARGUMENT_PACK_ARGS (arg);
15984 len = TREE_VEC_LENGTH (packed_args);
15987 for (k = 0; k < len; ++k)
15990 arg = TREE_VEC_ELT (packed_args, k);
15992 if (error_operand_p (arg))
15994 else if (TREE_CODE (arg) == TEMPLATE_DECL
15995 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
15997 else if (TYPE_P (arg) && TYPE_STRUCTURAL_EQUALITY_P (arg))
15999 else if (!TYPE_P (arg) && TREE_TYPE (arg)
16000 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg)))
16009 /* Returns true if ARGS (a collection of template arguments) contains
16010 any dependent arguments. */
16013 any_dependent_template_arguments_p (const_tree args)
16020 if (args == error_mark_node)
16023 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
16025 const_tree level = TMPL_ARGS_LEVEL (args, i + 1);
16026 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
16027 if (dependent_template_arg_p (TREE_VEC_ELT (level, j)))
16034 /* Returns TRUE if the template TMPL is dependent. */
16037 dependent_template_p (tree tmpl)
16039 if (TREE_CODE (tmpl) == OVERLOAD)
16043 if (dependent_template_p (OVL_FUNCTION (tmpl)))
16045 tmpl = OVL_CHAIN (tmpl);
16050 /* Template template parameters are dependent. */
16051 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
16052 || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
16054 /* So are names that have not been looked up. */
16055 if (TREE_CODE (tmpl) == SCOPE_REF
16056 || TREE_CODE (tmpl) == IDENTIFIER_NODE)
16058 /* So are member templates of dependent classes. */
16059 if (TYPE_P (CP_DECL_CONTEXT (tmpl)))
16060 return dependent_type_p (DECL_CONTEXT (tmpl));
16064 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
16067 dependent_template_id_p (tree tmpl, tree args)
16069 return (dependent_template_p (tmpl)
16070 || any_dependent_template_arguments_p (args));
16073 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
16074 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
16075 no such TYPE can be found. Note that this function peers inside
16076 uninstantiated templates and therefore should be used only in
16077 extremely limited situations. ONLY_CURRENT_P restricts this
16078 peering to the currently open classes hierarchy (which is required
16079 when comparing types). */
16082 resolve_typename_type (tree type, bool only_current_p)
16091 gcc_assert (TREE_CODE (type) == TYPENAME_TYPE);
16093 scope = TYPE_CONTEXT (type);
16094 name = TYPE_IDENTIFIER (type);
16096 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
16097 it first before we can figure out what NAME refers to. */
16098 if (TREE_CODE (scope) == TYPENAME_TYPE)
16099 scope = resolve_typename_type (scope, only_current_p);
16100 /* If we don't know what SCOPE refers to, then we cannot resolve the
16102 if (TREE_CODE (scope) == TYPENAME_TYPE)
16104 /* If the SCOPE is a template type parameter, we have no way of
16105 resolving the name. */
16106 if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
16108 /* If the SCOPE is not the current instantiation, there's no reason
16109 to look inside it. */
16110 if (only_current_p && !currently_open_class (scope))
16112 /* If SCOPE isn't the template itself, it will not have a valid
16113 TYPE_FIELDS list. */
16114 if (same_type_p (scope, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope)))
16115 /* scope is either the template itself or a compatible instantiation
16116 like X<T>, so look up the name in the original template. */
16117 scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope);
16119 /* scope is a partial instantiation, so we can't do the lookup or we
16120 will lose the template arguments. */
16122 /* Enter the SCOPE so that name lookup will be resolved as if we
16123 were in the class definition. In particular, SCOPE will no
16124 longer be considered a dependent type. */
16125 pushed_scope = push_scope (scope);
16126 /* Look up the declaration. */
16127 decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true);
16129 result = NULL_TREE;
16131 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
16132 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
16135 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE
16136 && TREE_CODE (decl) == TYPE_DECL)
16138 result = TREE_TYPE (decl);
16139 if (result == error_mark_node)
16140 result = NULL_TREE;
16142 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR
16143 && DECL_CLASS_TEMPLATE_P (decl))
16147 /* Obtain the template and the arguments. */
16148 tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0);
16149 args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1);
16150 /* Instantiate the template. */
16151 result = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE,
16152 /*entering_scope=*/0,
16153 tf_error | tf_user);
16154 if (result == error_mark_node)
16155 result = NULL_TREE;
16158 /* Leave the SCOPE. */
16160 pop_scope (pushed_scope);
16162 /* If we failed to resolve it, return the original typename. */
16166 /* If lookup found a typename type, resolve that too. */
16167 if (TREE_CODE (result) == TYPENAME_TYPE && !TYPENAME_IS_RESOLVING_P (result))
16169 /* Ill-formed programs can cause infinite recursion here, so we
16170 must catch that. */
16171 TYPENAME_IS_RESOLVING_P (type) = 1;
16172 result = resolve_typename_type (result, only_current_p);
16173 TYPENAME_IS_RESOLVING_P (type) = 0;
16176 /* Qualify the resulting type. */
16177 quals = cp_type_quals (type);
16179 result = cp_build_qualified_type (result, cp_type_quals (result) | quals);
16184 /* EXPR is an expression which is not type-dependent. Return a proxy
16185 for EXPR that can be used to compute the types of larger
16186 expressions containing EXPR. */
16189 build_non_dependent_expr (tree expr)
16193 /* Preserve null pointer constants so that the type of things like
16194 "p == 0" where "p" is a pointer can be determined. */
16195 if (null_ptr_cst_p (expr))
16197 /* Preserve OVERLOADs; the functions must be available to resolve
16200 if (TREE_CODE (inner_expr) == STMT_EXPR)
16201 inner_expr = stmt_expr_value_expr (inner_expr);
16202 if (TREE_CODE (inner_expr) == ADDR_EXPR)
16203 inner_expr = TREE_OPERAND (inner_expr, 0);
16204 if (TREE_CODE (inner_expr) == COMPONENT_REF)
16205 inner_expr = TREE_OPERAND (inner_expr, 1);
16206 if (is_overloaded_fn (inner_expr)
16207 || TREE_CODE (inner_expr) == OFFSET_REF)
16209 /* There is no need to return a proxy for a variable. */
16210 if (TREE_CODE (expr) == VAR_DECL)
16212 /* Preserve string constants; conversions from string constants to
16213 "char *" are allowed, even though normally a "const char *"
16214 cannot be used to initialize a "char *". */
16215 if (TREE_CODE (expr) == STRING_CST)
16217 /* Preserve arithmetic constants, as an optimization -- there is no
16218 reason to create a new node. */
16219 if (TREE_CODE (expr) == INTEGER_CST || TREE_CODE (expr) == REAL_CST)
16221 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
16222 There is at least one place where we want to know that a
16223 particular expression is a throw-expression: when checking a ?:
16224 expression, there are special rules if the second or third
16225 argument is a throw-expression. */
16226 if (TREE_CODE (expr) == THROW_EXPR)
16229 if (TREE_CODE (expr) == COND_EXPR)
16230 return build3 (COND_EXPR,
16232 TREE_OPERAND (expr, 0),
16233 (TREE_OPERAND (expr, 1)
16234 ? build_non_dependent_expr (TREE_OPERAND (expr, 1))
16235 : build_non_dependent_expr (TREE_OPERAND (expr, 0))),
16236 build_non_dependent_expr (TREE_OPERAND (expr, 2)));
16237 if (TREE_CODE (expr) == COMPOUND_EXPR
16238 && !COMPOUND_EXPR_OVERLOADED (expr))
16239 return build2 (COMPOUND_EXPR,
16241 TREE_OPERAND (expr, 0),
16242 build_non_dependent_expr (TREE_OPERAND (expr, 1)));
16244 /* If the type is unknown, it can't really be non-dependent */
16245 gcc_assert (TREE_TYPE (expr) != unknown_type_node);
16247 /* Otherwise, build a NON_DEPENDENT_EXPR.
16249 REFERENCE_TYPEs are not stripped for expressions in templates
16250 because doing so would play havoc with mangling. Consider, for
16253 template <typename T> void f<T& g>() { g(); }
16255 In the body of "f", the expression for "g" will have
16256 REFERENCE_TYPE, even though the standard says that it should
16257 not. The reason is that we must preserve the syntactic form of
16258 the expression so that mangling (say) "f<g>" inside the body of
16259 "f" works out correctly. Therefore, the REFERENCE_TYPE is
16261 return build1 (NON_DEPENDENT_EXPR, non_reference (TREE_TYPE (expr)), expr);
16264 /* ARGS is a TREE_LIST of expressions as arguments to a function call.
16265 Return a new TREE_LIST with the various arguments replaced with
16266 equivalent non-dependent expressions. */
16269 build_non_dependent_args (tree args)
16274 new_args = NULL_TREE;
16275 for (a = args; a; a = TREE_CHAIN (a))
16276 new_args = tree_cons (NULL_TREE,
16277 build_non_dependent_expr (TREE_VALUE (a)),
16279 return nreverse (new_args);
16282 #include "gt-cp-pt.h"