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 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 2, 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 COPYING. If not, write to
21 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
24 /* Known bugs or deficiencies include:
26 all methods must be provided in header files; can't use a source
27 file that contains only the method templates and "just win". */
31 #include "coretypes.h"
35 #include "pointer-set.h"
39 #include "cp-objcp-common.h"
40 #include "tree-inline.h"
47 #include "tree-iterator.h"
50 /* The type of functions taking a tree, and some additional data, and
52 typedef int (*tree_fn_t) (tree, void*);
54 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
55 instantiations have been deferred, either because their definitions
56 were not yet available, or because we were putting off doing the work.
57 The TREE_PURPOSE of each entry is either a DECL (for a function or
58 static data member), or a TYPE (for a class) indicating what we are
59 hoping to instantiate. The TREE_VALUE is not used. */
60 static GTY(()) tree pending_templates;
61 static GTY(()) tree last_pending_template;
63 int processing_template_parmlist;
64 static int template_header_count;
66 static GTY(()) tree saved_trees;
67 static VEC(int,heap) *inline_parm_levels;
69 static GTY(()) tree current_tinst_level;
71 static GTY(()) tree saved_access_scope;
73 /* Live only within one (recursive) call to tsubst_expr. We use
74 this to pass the statement expression node from the STMT_EXPR
75 to the EXPR_STMT that is its result. */
76 static tree cur_stmt_expr;
78 /* A map from local variable declarations in the body of the template
79 presently being instantiated to the corresponding instantiated
81 static htab_t local_specializations;
83 /* Contains canonical template parameter types. The vector is indexed by
84 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
85 TREE_LIST, whose TREE_VALUEs contain the canonical template
86 parameters of various types and levels. */
87 static GTY(()) VEC(tree,gc) *canonical_template_parms;
89 #define UNIFY_ALLOW_NONE 0
90 #define UNIFY_ALLOW_MORE_CV_QUAL 1
91 #define UNIFY_ALLOW_LESS_CV_QUAL 2
92 #define UNIFY_ALLOW_DERIVED 4
93 #define UNIFY_ALLOW_INTEGER 8
94 #define UNIFY_ALLOW_OUTER_LEVEL 16
95 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
96 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
98 static void push_access_scope (tree);
99 static void pop_access_scope (tree);
100 static bool resolve_overloaded_unification (tree, tree, tree, tree,
101 unification_kind_t, int);
102 static int try_one_overload (tree, tree, tree, tree, tree,
103 unification_kind_t, int, bool);
104 static int unify (tree, tree, tree, tree, int);
105 static void add_pending_template (tree);
106 static int push_tinst_level (tree);
107 static void pop_tinst_level (void);
108 static void reopen_tinst_level (tree);
109 static tree tsubst_initializer_list (tree, tree);
110 static tree get_class_bindings (tree, tree, tree);
111 static tree coerce_template_parms (tree, tree, tree, tsubst_flags_t,
113 static void tsubst_enum (tree, tree, tree);
114 static tree add_to_template_args (tree, tree);
115 static tree add_outermost_template_args (tree, tree);
116 static bool check_instantiated_args (tree, tree, tsubst_flags_t);
117 static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*,
119 static int type_unification_real (tree, tree, tree, tree,
120 int, unification_kind_t, int);
121 static void note_template_header (int);
122 static tree convert_nontype_argument_function (tree, tree);
123 static tree convert_nontype_argument (tree, tree);
124 static tree convert_template_argument (tree, tree, tree,
125 tsubst_flags_t, int, tree);
126 static int for_each_template_parm (tree, tree_fn_t, void*,
127 struct pointer_set_t*);
128 static tree expand_template_argument_pack (tree);
129 static tree build_template_parm_index (int, int, int, tree, tree);
130 static int inline_needs_template_parms (tree);
131 static void push_inline_template_parms_recursive (tree, int);
132 static tree retrieve_local_specialization (tree);
133 static void register_local_specialization (tree, tree);
134 static tree reduce_template_parm_level (tree, tree, int);
135 static int mark_template_parm (tree, void *);
136 static int template_parm_this_level_p (tree, void *);
137 static tree tsubst_friend_function (tree, tree);
138 static tree tsubst_friend_class (tree, tree);
139 static int can_complete_type_without_circularity (tree);
140 static tree get_bindings (tree, tree, tree, bool);
141 static int template_decl_level (tree);
142 static int check_cv_quals_for_unify (int, tree, tree);
143 static void template_parm_level_and_index (tree, int*, int*);
144 static int unify_pack_expansion (tree, tree, tree, tree, int, bool, bool);
145 static tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree);
146 static tree tsubst_template_args (tree, tree, tsubst_flags_t, tree);
147 static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
148 static void regenerate_decl_from_template (tree, tree);
149 static tree most_specialized_class (tree, tree);
150 static tree tsubst_aggr_type (tree, tree, tsubst_flags_t, tree, int);
151 static tree tsubst_arg_types (tree, tree, tsubst_flags_t, tree);
152 static tree tsubst_function_type (tree, tree, tsubst_flags_t, tree);
153 static bool check_specialization_scope (void);
154 static tree process_partial_specialization (tree);
155 static void set_current_access_from_decl (tree);
156 static tree get_template_base (tree, tree, tree, tree);
157 static tree try_class_unification (tree, tree, tree, tree);
158 static int coerce_template_template_parms (tree, tree, tsubst_flags_t,
160 static int template_args_equal (tree, tree);
161 static void tsubst_default_arguments (tree);
162 static tree for_each_template_parm_r (tree *, int *, void *);
163 static tree copy_default_args_to_explicit_spec_1 (tree, tree);
164 static void copy_default_args_to_explicit_spec (tree);
165 static int invalid_nontype_parm_type_p (tree, tsubst_flags_t);
166 static int eq_local_specializations (const void *, const void *);
167 static bool dependent_template_arg_p (tree);
168 static bool any_template_arguments_need_structural_equality_p (tree);
169 static bool dependent_type_p_r (tree);
170 static tree tsubst (tree, tree, tsubst_flags_t, tree);
171 static tree tsubst_expr (tree, tree, tsubst_flags_t, tree, bool);
172 static tree tsubst_copy (tree, tree, tsubst_flags_t, tree);
173 static tree tsubst_pack_expansion (tree, tree, tsubst_flags_t, tree);
175 /* Make the current scope suitable for access checking when we are
176 processing T. T can be FUNCTION_DECL for instantiated function
177 template, or VAR_DECL for static member variable (need by
178 instantiate_decl). */
181 push_access_scope (tree t)
183 gcc_assert (TREE_CODE (t) == FUNCTION_DECL
184 || TREE_CODE (t) == VAR_DECL);
186 if (DECL_FRIEND_CONTEXT (t))
187 push_nested_class (DECL_FRIEND_CONTEXT (t));
188 else if (DECL_CLASS_SCOPE_P (t))
189 push_nested_class (DECL_CONTEXT (t));
191 push_to_top_level ();
193 if (TREE_CODE (t) == FUNCTION_DECL)
195 saved_access_scope = tree_cons
196 (NULL_TREE, current_function_decl, saved_access_scope);
197 current_function_decl = t;
201 /* Restore the scope set up by push_access_scope. T is the node we
205 pop_access_scope (tree t)
207 if (TREE_CODE (t) == FUNCTION_DECL)
209 current_function_decl = TREE_VALUE (saved_access_scope);
210 saved_access_scope = TREE_CHAIN (saved_access_scope);
213 if (DECL_FRIEND_CONTEXT (t) || DECL_CLASS_SCOPE_P (t))
216 pop_from_top_level ();
219 /* Do any processing required when DECL (a member template
220 declaration) is finished. Returns the TEMPLATE_DECL corresponding
221 to DECL, unless it is a specialization, in which case the DECL
222 itself is returned. */
225 finish_member_template_decl (tree decl)
227 if (decl == error_mark_node)
228 return error_mark_node;
230 gcc_assert (DECL_P (decl));
232 if (TREE_CODE (decl) == TYPE_DECL)
236 type = TREE_TYPE (decl);
237 if (IS_AGGR_TYPE (type)
238 && CLASSTYPE_TEMPLATE_INFO (type)
239 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
241 tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
242 check_member_template (tmpl);
247 else if (TREE_CODE (decl) == FIELD_DECL)
248 error ("data member %qD cannot be a member template", decl);
249 else if (DECL_TEMPLATE_INFO (decl))
251 if (!DECL_TEMPLATE_SPECIALIZATION (decl))
253 check_member_template (DECL_TI_TEMPLATE (decl));
254 return DECL_TI_TEMPLATE (decl);
260 error ("invalid member template declaration %qD", decl);
262 return error_mark_node;
265 /* Returns the template nesting level of the indicated class TYPE.
275 A<T>::B<U> has depth two, while A<T> has depth one.
276 Both A<T>::B<int> and A<int>::B<U> have depth one, if
277 they are instantiations, not specializations.
279 This function is guaranteed to return 0 if passed NULL_TREE so
280 that, for example, `template_class_depth (current_class_type)' is
284 template_class_depth (tree type)
289 type && TREE_CODE (type) != NAMESPACE_DECL;
290 type = (TREE_CODE (type) == FUNCTION_DECL)
291 ? CP_DECL_CONTEXT (type) : TYPE_CONTEXT (type))
293 if (TREE_CODE (type) != FUNCTION_DECL)
295 if (CLASSTYPE_TEMPLATE_INFO (type)
296 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type))
297 && uses_template_parms (CLASSTYPE_TI_ARGS (type)))
302 if (DECL_TEMPLATE_INFO (type)
303 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (type))
304 && uses_template_parms (DECL_TI_ARGS (type)))
312 /* Returns 1 if processing DECL as part of do_pending_inlines
313 needs us to push template parms. */
316 inline_needs_template_parms (tree decl)
318 if (! DECL_TEMPLATE_INFO (decl))
321 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl)))
322 > (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl)));
325 /* Subroutine of maybe_begin_member_template_processing.
326 Push the template parms in PARMS, starting from LEVELS steps into the
327 chain, and ending at the beginning, since template parms are listed
331 push_inline_template_parms_recursive (tree parmlist, int levels)
333 tree parms = TREE_VALUE (parmlist);
337 push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1);
339 ++processing_template_decl;
340 current_template_parms
341 = tree_cons (size_int (processing_template_decl),
342 parms, current_template_parms);
343 TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1;
345 begin_scope (TREE_VEC_LENGTH (parms) ? sk_template_parms : sk_template_spec,
347 for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
349 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
351 if (parm == error_mark_node)
354 gcc_assert (DECL_P (parm));
356 switch (TREE_CODE (parm))
365 /* Make a CONST_DECL as is done in process_template_parm.
366 It is ugly that we recreate this here; the original
367 version built in process_template_parm is no longer
369 tree decl = build_decl (CONST_DECL, DECL_NAME (parm),
371 DECL_ARTIFICIAL (decl) = 1;
372 TREE_CONSTANT (decl) = 1;
373 TREE_INVARIANT (decl) = 1;
374 TREE_READONLY (decl) = 1;
375 DECL_INITIAL (decl) = DECL_INITIAL (parm);
376 SET_DECL_TEMPLATE_PARM_P (decl);
387 /* Restore the template parameter context for a member template or
388 a friend template defined in a class definition. */
391 maybe_begin_member_template_processing (tree decl)
396 if (inline_needs_template_parms (decl))
398 parms = DECL_TEMPLATE_PARMS (most_general_template (decl));
399 levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl;
401 if (DECL_TEMPLATE_SPECIALIZATION (decl))
404 parms = TREE_CHAIN (parms);
407 push_inline_template_parms_recursive (parms, levels);
410 /* Remember how many levels of template parameters we pushed so that
411 we can pop them later. */
412 VEC_safe_push (int, heap, inline_parm_levels, levels);
415 /* Undo the effects of maybe_begin_member_template_processing. */
418 maybe_end_member_template_processing (void)
423 if (VEC_length (int, inline_parm_levels) == 0)
426 last = VEC_pop (int, inline_parm_levels);
427 for (i = 0; i < last; ++i)
429 --processing_template_decl;
430 current_template_parms = TREE_CHAIN (current_template_parms);
435 /* Return a new template argument vector which contains all of ARGS,
436 but has as its innermost set of arguments the EXTRA_ARGS. */
439 add_to_template_args (tree args, tree extra_args)
446 extra_depth = TMPL_ARGS_DEPTH (extra_args);
447 new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth);
449 for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i)
450 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));
452 for (j = 1; j <= extra_depth; ++j, ++i)
453 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));
458 /* Like add_to_template_args, but only the outermost ARGS are added to
459 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
460 (EXTRA_ARGS) levels are added. This function is used to combine
461 the template arguments from a partial instantiation with the
462 template arguments used to attain the full instantiation from the
463 partial instantiation. */
466 add_outermost_template_args (tree args, tree extra_args)
470 /* If there are more levels of EXTRA_ARGS than there are ARGS,
471 something very fishy is going on. */
472 gcc_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args));
474 /* If *all* the new arguments will be the EXTRA_ARGS, just return
476 if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
479 /* For the moment, we make ARGS look like it contains fewer levels. */
480 TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);
482 new_args = add_to_template_args (args, extra_args);
484 /* Now, we restore ARGS to its full dimensions. */
485 TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);
490 /* Return the N levels of innermost template arguments from the ARGS. */
493 get_innermost_template_args (tree args, int n)
501 /* If N is 1, just return the innermost set of template arguments. */
503 return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args));
505 /* If we're not removing anything, just return the arguments we were
507 extra_levels = TMPL_ARGS_DEPTH (args) - n;
508 gcc_assert (extra_levels >= 0);
509 if (extra_levels == 0)
512 /* Make a new set of arguments, not containing the outer arguments. */
513 new_args = make_tree_vec (n);
514 for (i = 1; i <= n; ++i)
515 SET_TMPL_ARGS_LEVEL (new_args, i,
516 TMPL_ARGS_LEVEL (args, i + extra_levels));
521 /* We've got a template header coming up; push to a new level for storing
525 begin_template_parm_list (void)
527 /* We use a non-tag-transparent scope here, which causes pushtag to
528 put tags in this scope, rather than in the enclosing class or
529 namespace scope. This is the right thing, since we want
530 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
531 global template class, push_template_decl handles putting the
532 TEMPLATE_DECL into top-level scope. For a nested template class,
535 template <class T> struct S1 {
536 template <class T> struct S2 {};
539 pushtag contains special code to call pushdecl_with_scope on the
540 TEMPLATE_DECL for S2. */
541 begin_scope (sk_template_parms, NULL);
542 ++processing_template_decl;
543 ++processing_template_parmlist;
544 note_template_header (0);
547 /* This routine is called when a specialization is declared. If it is
548 invalid to declare a specialization here, an error is reported and
549 false is returned, otherwise this routine will return true. */
552 check_specialization_scope (void)
554 tree scope = current_scope ();
558 An explicit specialization shall be declared in the namespace of
559 which the template is a member, or, for member templates, in the
560 namespace of which the enclosing class or enclosing class
561 template is a member. An explicit specialization of a member
562 function, member class or static data member of a class template
563 shall be declared in the namespace of which the class template
565 if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
567 error ("explicit specialization in non-namespace scope %qD", scope);
573 In an explicit specialization declaration for a member of a class
574 template or a member template that appears in namespace scope,
575 the member template and some of its enclosing class templates may
576 remain unspecialized, except that the declaration shall not
577 explicitly specialize a class member template if its enclosing
578 class templates are not explicitly specialized as well. */
579 if (current_template_parms)
581 error ("enclosing class templates are not explicitly specialized");
588 /* We've just seen template <>. */
591 begin_specialization (void)
593 begin_scope (sk_template_spec, NULL);
594 note_template_header (1);
595 return check_specialization_scope ();
598 /* Called at then end of processing a declaration preceded by
602 end_specialization (void)
605 reset_specialization ();
608 /* Any template <>'s that we have seen thus far are not referring to a
609 function specialization. */
612 reset_specialization (void)
614 processing_specialization = 0;
615 template_header_count = 0;
618 /* We've just seen a template header. If SPECIALIZATION is nonzero,
619 it was of the form template <>. */
622 note_template_header (int specialization)
624 processing_specialization = specialization;
625 template_header_count++;
628 /* We're beginning an explicit instantiation. */
631 begin_explicit_instantiation (void)
633 gcc_assert (!processing_explicit_instantiation);
634 processing_explicit_instantiation = true;
639 end_explicit_instantiation (void)
641 gcc_assert (processing_explicit_instantiation);
642 processing_explicit_instantiation = false;
645 /* An explicit specialization or partial specialization TMPL is being
646 declared. Check that the namespace in which the specialization is
647 occurring is permissible. Returns false iff it is invalid to
648 specialize TMPL in the current namespace. */
651 check_specialization_namespace (tree tmpl)
653 tree tpl_ns = decl_namespace_context (tmpl);
657 An explicit specialization shall be declared in the namespace of
658 which the template is a member, or, for member templates, in the
659 namespace of which the enclosing class or enclosing class
660 template is a member. An explicit specialization of a member
661 function, member class or static data member of a class template
662 shall be declared in the namespace of which the class template is
664 if (is_associated_namespace (current_namespace, tpl_ns))
665 /* Same or super-using namespace. */
669 pedwarn ("specialization of %qD in different namespace", tmpl);
670 pedwarn (" from definition of %q+#D", tmpl);
675 /* SPEC is an explicit instantiation. Check that it is valid to
676 perform this explicit instantiation in the current namespace. */
679 check_explicit_instantiation_namespace (tree spec)
683 /* DR 275: An explicit instantiation shall appear in an enclosing
684 namespace of its template. */
685 ns = decl_namespace_context (spec);
686 if (!is_ancestor (current_namespace, ns))
687 pedwarn ("explicit instantiation of %qD in namespace %qD "
688 "(which does not enclose namespace %qD)",
689 spec, current_namespace, ns);
692 /* The TYPE is being declared. If it is a template type, that means it
693 is a partial specialization. Do appropriate error-checking. */
696 maybe_process_partial_specialization (tree type)
700 if (type == error_mark_node)
701 return error_mark_node;
703 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
705 error ("name of class shadows template template parameter %qD",
707 return error_mark_node;
710 context = TYPE_CONTEXT (type);
712 if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type))
714 /* This is for ordinary explicit specialization and partial
715 specialization of a template class such as:
717 template <> class C<int>;
721 template <class T> class C<T*>;
723 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
725 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
726 && !COMPLETE_TYPE_P (type))
728 check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type));
729 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
730 if (processing_template_decl)
731 push_template_decl (TYPE_MAIN_DECL (type));
733 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
734 error ("specialization of %qT after instantiation", type);
736 else if (CLASS_TYPE_P (type)
737 && !CLASSTYPE_USE_TEMPLATE (type)
738 && CLASSTYPE_TEMPLATE_INFO (type)
739 && context && CLASS_TYPE_P (context)
740 && CLASSTYPE_TEMPLATE_INFO (context))
742 /* This is for an explicit specialization of member class
743 template according to [temp.expl.spec/18]:
745 template <> template <class U> class C<int>::D;
747 The context `C<int>' must be an implicit instantiation.
748 Otherwise this is just a member class template declared
751 template <> class C<int> { template <class U> class D; };
752 template <> template <class U> class C<int>::D;
754 In the first case, `C<int>::D' is a specialization of `C<T>::D'
755 while in the second case, `C<int>::D' is a primary template
756 and `C<T>::D' may not exist. */
758 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context)
759 && !COMPLETE_TYPE_P (type))
763 if (current_namespace
764 != decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type)))
766 pedwarn ("specializing %q#T in different namespace", type);
767 pedwarn (" from definition of %q+#D",
768 CLASSTYPE_TI_TEMPLATE (type));
771 /* Check for invalid specialization after instantiation:
773 template <> template <> class C<int>::D<int>;
774 template <> template <class U> class C<int>::D; */
776 for (t = DECL_TEMPLATE_INSTANTIATIONS
777 (most_general_template (CLASSTYPE_TI_TEMPLATE (type)));
778 t; t = TREE_CHAIN (t))
779 if (TREE_VALUE (t) != type
780 && TYPE_CONTEXT (TREE_VALUE (t)) == context)
781 error ("specialization %qT after instantiation %qT",
782 type, TREE_VALUE (t));
784 /* Mark TYPE as a specialization. And as a result, we only
785 have one level of template argument for the innermost
787 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
788 CLASSTYPE_TI_ARGS (type)
789 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
792 else if (processing_specialization)
794 error ("explicit specialization of non-template %qT", type);
795 return error_mark_node;
801 /* Returns nonzero if we can optimize the retrieval of specializations
802 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
803 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
806 optimize_specialization_lookup_p (tree tmpl)
808 return (DECL_FUNCTION_TEMPLATE_P (tmpl)
809 && DECL_CLASS_SCOPE_P (tmpl)
810 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
812 && CLASS_TYPE_P (DECL_CONTEXT (tmpl))
813 /* The optimized lookup depends on the fact that the
814 template arguments for the member function template apply
815 purely to the containing class, which is not true if the
816 containing class is an explicit or partial
818 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl))
819 && !DECL_MEMBER_TEMPLATE_P (tmpl)
820 && !DECL_CONV_FN_P (tmpl)
821 /* It is possible to have a template that is not a member
822 template and is not a member of a template class:
824 template <typename T>
825 struct S { friend A::f(); };
827 Here, the friend function is a template, but the context does
828 not have template information. The optimized lookup relies
829 on having ARGS be the template arguments for both the class
830 and the function template. */
831 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl)));
834 /* Retrieve the specialization (in the sense of [temp.spec] - a
835 specialization is either an instantiation or an explicit
836 specialization) of TMPL for the given template ARGS. If there is
837 no such specialization, return NULL_TREE. The ARGS are a vector of
838 arguments, or a vector of vectors of arguments, in the case of
839 templates with more than one level of parameters.
841 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
842 then we search for a partial specialization matching ARGS. This
843 parameter is ignored if TMPL is not a class template. */
846 retrieve_specialization (tree tmpl, tree args,
847 bool class_specializations_p)
849 if (args == error_mark_node)
852 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
854 /* There should be as many levels of arguments as there are
855 levels of parameters. */
856 gcc_assert (TMPL_ARGS_DEPTH (args)
857 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)));
859 if (optimize_specialization_lookup_p (tmpl))
862 tree class_specialization;
863 VEC(tree,gc) *methods;
867 /* The template arguments actually apply to the containing
868 class. Find the class specialization with those
870 class_template = CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl));
872 = retrieve_specialization (class_template, args,
873 /*class_specializations_p=*/false);
874 if (!class_specialization)
876 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
877 for the specialization. */
878 idx = class_method_index_for_fn (class_specialization, tmpl);
881 /* Iterate through the methods with the indicated name, looking
882 for the one that has an instance of TMPL. */
883 methods = CLASSTYPE_METHOD_VEC (class_specialization);
884 for (fns = VEC_index (tree, methods, idx); fns; fns = OVL_NEXT (fns))
886 tree fn = OVL_CURRENT (fns);
887 if (DECL_TEMPLATE_INFO (fn) && DECL_TI_TEMPLATE (fn) == tmpl)
897 /* Class templates store their instantiations on the
898 DECL_TEMPLATE_INSTANTIATIONS list; other templates use the
899 DECL_TEMPLATE_SPECIALIZATIONS list. */
900 if (!class_specializations_p
901 && TREE_CODE (DECL_TEMPLATE_RESULT (tmpl)) == TYPE_DECL)
902 sp = &DECL_TEMPLATE_INSTANTIATIONS (tmpl);
904 sp = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
906 /* Iterate through the list until we find a matching template. */
907 while (*sp != NULL_TREE)
911 if (comp_template_args (TREE_PURPOSE (spec), args))
913 /* Use the move-to-front heuristic to speed up future
917 *sp = TREE_CHAIN (*sp);
918 TREE_CHAIN (spec) = *head;
921 return TREE_VALUE (spec);
923 sp = &TREE_CHAIN (spec);
930 /* Like retrieve_specialization, but for local declarations. */
933 retrieve_local_specialization (tree tmpl)
935 tree spec = (tree) htab_find_with_hash (local_specializations, tmpl,
936 htab_hash_pointer (tmpl));
937 return spec ? TREE_PURPOSE (spec) : NULL_TREE;
940 /* Returns nonzero iff DECL is a specialization of TMPL. */
943 is_specialization_of (tree decl, tree tmpl)
947 if (TREE_CODE (decl) == FUNCTION_DECL)
951 t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
957 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
959 for (t = TREE_TYPE (decl);
961 t = CLASSTYPE_USE_TEMPLATE (t)
962 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
963 if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl)))
970 /* Returns nonzero iff DECL is a specialization of friend declaration
971 FRIEND according to [temp.friend]. */
974 is_specialization_of_friend (tree decl, tree friend)
976 bool need_template = true;
979 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
980 || TREE_CODE (decl) == TYPE_DECL);
982 /* For [temp.friend/6] when FRIEND is an ordinary member function
983 of a template class, we want to check if DECL is a specialization
985 if (TREE_CODE (friend) == FUNCTION_DECL
986 && DECL_TEMPLATE_INFO (friend)
987 && !DECL_USE_TEMPLATE (friend))
989 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
990 friend = DECL_TI_TEMPLATE (friend);
991 need_template = false;
993 else if (TREE_CODE (friend) == TEMPLATE_DECL
994 && !PRIMARY_TEMPLATE_P (friend))
995 need_template = false;
997 /* There is nothing to do if this is not a template friend. */
998 if (TREE_CODE (friend) != TEMPLATE_DECL)
1001 if (is_specialization_of (decl, friend))
1005 A member of a class template may be declared to be a friend of a
1006 non-template class. In this case, the corresponding member of
1007 every specialization of the class template is a friend of the
1008 class granting friendship.
1010 For example, given a template friend declaration
1012 template <class T> friend void A<T>::f();
1014 the member function below is considered a friend
1016 template <> struct A<int> {
1020 For this type of template friend, TEMPLATE_DEPTH below will be
1021 nonzero. To determine if DECL is a friend of FRIEND, we first
1022 check if the enclosing class is a specialization of another. */
1024 template_depth = template_class_depth (DECL_CONTEXT (friend));
1026 && DECL_CLASS_SCOPE_P (decl)
1027 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)),
1028 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend))))
1030 /* Next, we check the members themselves. In order to handle
1031 a few tricky cases, such as when FRIEND's are
1033 template <class T> friend void A<T>::g(T t);
1034 template <class T> template <T t> friend void A<T>::h();
1038 void A<int>::g(int);
1039 template <int> void A<int>::h();
1041 we need to figure out ARGS, the template arguments from
1042 the context of DECL. This is required for template substitution
1043 of `T' in the function parameter of `g' and template parameter
1044 of `h' in the above examples. Here ARGS corresponds to `int'. */
1046 tree context = DECL_CONTEXT (decl);
1047 tree args = NULL_TREE;
1048 int current_depth = 0;
1050 while (current_depth < template_depth)
1052 if (CLASSTYPE_TEMPLATE_INFO (context))
1054 if (current_depth == 0)
1055 args = TYPE_TI_ARGS (context);
1057 args = add_to_template_args (TYPE_TI_ARGS (context), args);
1060 context = TYPE_CONTEXT (context);
1063 if (TREE_CODE (decl) == FUNCTION_DECL)
1068 tree friend_args_type;
1069 tree decl_args_type;
1071 /* Make sure that both DECL and FRIEND are templates or
1073 is_template = DECL_TEMPLATE_INFO (decl)
1074 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl));
1075 if (need_template ^ is_template)
1077 else if (is_template)
1079 /* If both are templates, check template parameter list. */
1081 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
1083 if (!comp_template_parms
1084 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)),
1088 decl_type = TREE_TYPE (DECL_TI_TEMPLATE (decl));
1091 decl_type = TREE_TYPE (decl);
1093 friend_type = tsubst_function_type (TREE_TYPE (friend), args,
1094 tf_none, NULL_TREE);
1095 if (friend_type == error_mark_node)
1098 /* Check if return types match. */
1099 if (!same_type_p (TREE_TYPE (decl_type), TREE_TYPE (friend_type)))
1102 /* Check if function parameter types match, ignoring the
1103 `this' parameter. */
1104 friend_args_type = TYPE_ARG_TYPES (friend_type);
1105 decl_args_type = TYPE_ARG_TYPES (decl_type);
1106 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend))
1107 friend_args_type = TREE_CHAIN (friend_args_type);
1108 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1109 decl_args_type = TREE_CHAIN (decl_args_type);
1111 return compparms (decl_args_type, friend_args_type);
1115 /* DECL is a TYPE_DECL */
1117 tree decl_type = TREE_TYPE (decl);
1119 /* Make sure that both DECL and FRIEND are templates or
1122 = CLASSTYPE_TEMPLATE_INFO (decl_type)
1123 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type));
1125 if (need_template ^ is_template)
1127 else if (is_template)
1130 /* If both are templates, check the name of the two
1131 TEMPLATE_DECL's first because is_friend didn't. */
1132 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type))
1133 != DECL_NAME (friend))
1136 /* Now check template parameter list. */
1138 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
1140 return comp_template_parms
1141 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type)),
1145 return (DECL_NAME (decl)
1146 == DECL_NAME (friend));
1152 /* Register the specialization SPEC as a specialization of TMPL with
1153 the indicated ARGS. IS_FRIEND indicates whether the specialization
1154 is actually just a friend declaration. Returns SPEC, or an
1155 equivalent prior declaration, if available. */
1158 register_specialization (tree spec, tree tmpl, tree args, bool is_friend)
1162 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
1164 if (TREE_CODE (spec) == FUNCTION_DECL
1165 && uses_template_parms (DECL_TI_ARGS (spec)))
1166 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1167 register it; we want the corresponding TEMPLATE_DECL instead.
1168 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1169 the more obvious `uses_template_parms (spec)' to avoid problems
1170 with default function arguments. In particular, given
1171 something like this:
1173 template <class T> void f(T t1, T t = T())
1175 the default argument expression is not substituted for in an
1176 instantiation unless and until it is actually needed. */
1179 fn = retrieve_specialization (tmpl, args,
1180 /*class_specializations_p=*/false);
1181 /* We can sometimes try to re-register a specialization that we've
1182 already got. In particular, regenerate_decl_from_template calls
1183 duplicate_decls which will update the specialization list. But,
1184 we'll still get called again here anyhow. It's more convenient
1185 to simply allow this than to try to prevent it. */
1188 else if (fn && DECL_TEMPLATE_SPECIALIZATION (spec))
1190 if (DECL_TEMPLATE_INSTANTIATION (fn))
1193 || DECL_EXPLICIT_INSTANTIATION (fn))
1195 error ("specialization of %qD after instantiation",
1197 return error_mark_node;
1202 /* This situation should occur only if the first
1203 specialization is an implicit instantiation, the
1204 second is an explicit specialization, and the
1205 implicit instantiation has not yet been used. That
1206 situation can occur if we have implicitly
1207 instantiated a member function and then specialized
1210 We can also wind up here if a friend declaration that
1211 looked like an instantiation turns out to be a
1214 template <class T> void foo(T);
1215 class S { friend void foo<>(int) };
1216 template <> void foo(int);
1218 We transform the existing DECL in place so that any
1219 pointers to it become pointers to the updated
1222 If there was a definition for the template, but not
1223 for the specialization, we want this to look as if
1224 there were no definition, and vice versa. */
1225 DECL_INITIAL (fn) = NULL_TREE;
1226 duplicate_decls (spec, fn, is_friend);
1227 /* The call to duplicate_decls will have applied
1230 An explicit specialization of a function template
1231 is inline only if it is explicitly declared to be,
1232 and independently of whether its function template
1235 to the primary function; now copy the inline bits to
1236 the various clones. */
1237 FOR_EACH_CLONE (clone, fn)
1239 DECL_DECLARED_INLINE_P (clone)
1240 = DECL_DECLARED_INLINE_P (fn);
1244 check_specialization_namespace (fn);
1249 else if (DECL_TEMPLATE_SPECIALIZATION (fn))
1251 if (!duplicate_decls (spec, fn, is_friend) && DECL_INITIAL (spec))
1252 /* Dup decl failed, but this is a new definition. Set the
1253 line number so any errors match this new
1255 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec);
1261 /* A specialization must be declared in the same namespace as the
1262 template it is specializing. */
1263 if (DECL_TEMPLATE_SPECIALIZATION (spec)
1264 && !check_specialization_namespace (tmpl))
1265 DECL_CONTEXT (spec) = FROB_CONTEXT (decl_namespace_context (tmpl));
1267 if (!optimize_specialization_lookup_p (tmpl))
1268 DECL_TEMPLATE_SPECIALIZATIONS (tmpl)
1269 = tree_cons (args, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl));
1274 /* Unregister the specialization SPEC as a specialization of TMPL.
1275 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1276 if the SPEC was listed as a specialization of TMPL. */
1279 reregister_specialization (tree spec, tree tmpl, tree new_spec)
1283 for (s = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
1285 s = &TREE_CHAIN (*s))
1286 if (TREE_VALUE (*s) == spec)
1289 *s = TREE_CHAIN (*s);
1291 TREE_VALUE (*s) = new_spec;
1298 /* Compare an entry in the local specializations hash table P1 (which
1299 is really a pointer to a TREE_LIST) with P2 (which is really a
1303 eq_local_specializations (const void *p1, const void *p2)
1305 return TREE_VALUE ((tree) p1) == (tree) p2;
1308 /* Hash P1, an entry in the local specializations table. */
1311 hash_local_specialization (const void* p1)
1313 return htab_hash_pointer (TREE_VALUE ((tree) p1));
1316 /* Like register_specialization, but for local declarations. We are
1317 registering SPEC, an instantiation of TMPL. */
1320 register_local_specialization (tree spec, tree tmpl)
1324 slot = htab_find_slot_with_hash (local_specializations, tmpl,
1325 htab_hash_pointer (tmpl), INSERT);
1326 *slot = build_tree_list (spec, tmpl);
1329 /* TYPE is a class type. Returns true if TYPE is an explicitly
1330 specialized class. */
1333 explicit_class_specialization_p (tree type)
1335 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
1337 return !uses_template_parms (CLASSTYPE_TI_ARGS (type));
1340 /* Print the list of candidate FNS in an error message. */
1343 print_candidates (tree fns)
1347 const char *str = "candidates are:";
1349 for (fn = fns; fn != NULL_TREE; fn = TREE_CHAIN (fn))
1353 for (f = TREE_VALUE (fn); f; f = OVL_NEXT (f))
1354 error ("%s %+#D", str, OVL_CURRENT (f));
1359 /* Returns the template (one of the functions given by TEMPLATE_ID)
1360 which can be specialized to match the indicated DECL with the
1361 explicit template args given in TEMPLATE_ID. The DECL may be
1362 NULL_TREE if none is available. In that case, the functions in
1363 TEMPLATE_ID are non-members.
1365 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1366 specialization of a member template.
1368 The TEMPLATE_COUNT is the number of references to qualifying
1369 template classes that appeared in the name of the function. See
1370 check_explicit_specialization for a more accurate description.
1372 TSK indicates what kind of template declaration (if any) is being
1373 declared. TSK_TEMPLATE indicates that the declaration given by
1374 DECL, though a FUNCTION_DECL, has template parameters, and is
1375 therefore a template function.
1377 The template args (those explicitly specified and those deduced)
1378 are output in a newly created vector *TARGS_OUT.
1380 If it is impossible to determine the result, an error message is
1381 issued. The error_mark_node is returned to indicate failure. */
1384 determine_specialization (tree template_id,
1387 int need_member_template,
1393 tree explicit_targs;
1394 tree candidates = NULL_TREE;
1395 /* A TREE_LIST of templates of which DECL may be a specialization.
1396 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1397 corresponding TREE_PURPOSE is the set of template arguments that,
1398 when used to instantiate the template, would produce a function
1399 with the signature of DECL. */
1400 tree templates = NULL_TREE;
1402 struct cp_binding_level *b;
1404 *targs_out = NULL_TREE;
1406 if (template_id == error_mark_node || decl == error_mark_node)
1407 return error_mark_node;
1409 fns = TREE_OPERAND (template_id, 0);
1410 explicit_targs = TREE_OPERAND (template_id, 1);
1412 if (fns == error_mark_node)
1413 return error_mark_node;
1415 /* Check for baselinks. */
1416 if (BASELINK_P (fns))
1417 fns = BASELINK_FUNCTIONS (fns);
1419 if (!is_overloaded_fn (fns))
1421 error ("%qD is not a function template", fns);
1422 return error_mark_node;
1425 /* Count the number of template headers specified for this
1428 for (b = current_binding_level;
1429 b->kind == sk_template_parms;
1433 for (; fns; fns = OVL_NEXT (fns))
1435 tree fn = OVL_CURRENT (fns);
1437 if (TREE_CODE (fn) == TEMPLATE_DECL)
1439 tree decl_arg_types;
1442 /* In case of explicit specialization, we need to check if
1443 the number of template headers appearing in the specialization
1444 is correct. This is usually done in check_explicit_specialization,
1445 but the check done there cannot be exhaustive when specializing
1446 member functions. Consider the following code:
1448 template <> void A<int>::f(int);
1449 template <> template <> void A<int>::f(int);
1451 Assuming that A<int> is not itself an explicit specialization
1452 already, the first line specializes "f" which is a non-template
1453 member function, whilst the second line specializes "f" which
1454 is a template member function. So both lines are syntactically
1455 correct, and check_explicit_specialization does not reject
1458 Here, we can do better, as we are matching the specialization
1459 against the declarations. We count the number of template
1460 headers, and we check if they match TEMPLATE_COUNT + 1
1461 (TEMPLATE_COUNT is the number of qualifying template classes,
1462 plus there must be another header for the member template
1465 Notice that if header_count is zero, this is not a
1466 specialization but rather a template instantiation, so there
1467 is no check we can perform here. */
1468 if (header_count && header_count != template_count + 1)
1471 /* Check that the number of template arguments at the
1472 innermost level for DECL is the same as for FN. */
1473 if (current_binding_level->kind == sk_template_parms
1474 && !current_binding_level->explicit_spec_p
1475 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn))
1476 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
1477 (current_template_parms))))
1480 /* DECL might be a specialization of FN. */
1481 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1482 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
1484 /* For a non-static member function, we need to make sure
1485 that the const qualification is the same. Since
1486 get_bindings does not try to merge the "this" parameter,
1487 we must do the comparison explicitly. */
1488 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1489 && !same_type_p (TREE_VALUE (fn_arg_types),
1490 TREE_VALUE (decl_arg_types)))
1493 /* Skip the "this" parameter and, for constructors of
1494 classes with virtual bases, the VTT parameter. A
1495 full specialization of a constructor will have a VTT
1496 parameter, but a template never will. */
1498 = skip_artificial_parms_for (decl, decl_arg_types);
1500 = skip_artificial_parms_for (fn, fn_arg_types);
1502 /* Check that the number of function parameters matches.
1504 template <class T> void f(int i = 0);
1505 template <> void f<int>();
1506 The specialization f<int> is invalid but is not caught
1507 by get_bindings below. */
1508 if (list_length (fn_arg_types) != list_length (decl_arg_types))
1511 /* Function templates cannot be specializations; there are
1512 no partial specializations of functions. Therefore, if
1513 the type of DECL does not match FN, there is no
1515 if (tsk == tsk_template)
1517 if (compparms (fn_arg_types, decl_arg_types))
1518 candidates = tree_cons (NULL_TREE, fn, candidates);
1522 /* See whether this function might be a specialization of this
1524 targs = get_bindings (fn, decl, explicit_targs, /*check_ret=*/true);
1527 /* We cannot deduce template arguments that when used to
1528 specialize TMPL will produce DECL. */
1531 /* Save this template, and the arguments deduced. */
1532 templates = tree_cons (targs, fn, templates);
1534 else if (need_member_template)
1535 /* FN is an ordinary member function, and we need a
1536 specialization of a member template. */
1538 else if (TREE_CODE (fn) != FUNCTION_DECL)
1539 /* We can get IDENTIFIER_NODEs here in certain erroneous
1542 else if (!DECL_FUNCTION_MEMBER_P (fn))
1543 /* This is just an ordinary non-member function. Nothing can
1544 be a specialization of that. */
1546 else if (DECL_ARTIFICIAL (fn))
1547 /* Cannot specialize functions that are created implicitly. */
1551 tree decl_arg_types;
1553 /* This is an ordinary member function. However, since
1554 we're here, we can assume it's enclosing class is a
1555 template class. For example,
1557 template <typename T> struct S { void f(); };
1558 template <> void S<int>::f() {}
1560 Here, S<int>::f is a non-template, but S<int> is a
1561 template class. If FN has the same type as DECL, we
1562 might be in business. */
1564 if (!DECL_TEMPLATE_INFO (fn))
1565 /* Its enclosing class is an explicit specialization
1566 of a template class. This is not a candidate. */
1569 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
1570 TREE_TYPE (TREE_TYPE (fn))))
1571 /* The return types differ. */
1574 /* Adjust the type of DECL in case FN is a static member. */
1575 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1576 if (DECL_STATIC_FUNCTION_P (fn)
1577 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1578 decl_arg_types = TREE_CHAIN (decl_arg_types);
1580 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1583 candidates = tree_cons (NULL_TREE, fn, candidates);
1587 if (templates && TREE_CHAIN (templates))
1593 It is possible for a specialization with a given function
1594 signature to be instantiated from more than one function
1595 template. In such cases, explicit specification of the
1596 template arguments must be used to uniquely identify the
1597 function template specialization being specialized.
1599 Note that here, there's no suggestion that we're supposed to
1600 determine which of the candidate templates is most
1601 specialized. However, we, also have:
1605 Partial ordering of overloaded function template
1606 declarations is used in the following contexts to select
1607 the function template to which a function template
1608 specialization refers:
1610 -- when an explicit specialization refers to a function
1613 So, we do use the partial ordering rules, at least for now.
1614 This extension can only serve to make invalid programs valid,
1615 so it's safe. And, there is strong anecdotal evidence that
1616 the committee intended the partial ordering rules to apply;
1617 the EDG front end has that behavior, and John Spicer claims
1618 that the committee simply forgot to delete the wording in
1619 [temp.expl.spec]. */
1620 tree tmpl = most_specialized_instantiation (templates);
1621 if (tmpl != error_mark_node)
1624 TREE_CHAIN (templates) = NULL_TREE;
1628 if (templates == NULL_TREE && candidates == NULL_TREE)
1630 error ("template-id %qD for %q+D does not match any template "
1631 "declaration", template_id, decl);
1632 return error_mark_node;
1634 else if ((templates && TREE_CHAIN (templates))
1635 || (candidates && TREE_CHAIN (candidates))
1636 || (templates && candidates))
1638 error ("ambiguous template specialization %qD for %q+D",
1640 chainon (candidates, templates);
1641 print_candidates (candidates);
1642 return error_mark_node;
1645 /* We have one, and exactly one, match. */
1648 tree fn = TREE_VALUE (candidates);
1649 /* DECL is a re-declaration of a template function. */
1650 if (TREE_CODE (fn) == TEMPLATE_DECL)
1652 /* It was a specialization of an ordinary member function in a
1654 *targs_out = copy_node (DECL_TI_ARGS (fn));
1655 return DECL_TI_TEMPLATE (fn);
1658 /* It was a specialization of a template. */
1659 targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates)));
1660 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs))
1662 *targs_out = copy_node (targs);
1663 SET_TMPL_ARGS_LEVEL (*targs_out,
1664 TMPL_ARGS_DEPTH (*targs_out),
1665 TREE_PURPOSE (templates));
1668 *targs_out = TREE_PURPOSE (templates);
1669 return TREE_VALUE (templates);
1672 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
1673 but with the default argument values filled in from those in the
1677 copy_default_args_to_explicit_spec_1 (tree spec_types,
1680 tree new_spec_types;
1685 if (spec_types == void_list_node)
1686 return void_list_node;
1688 /* Substitute into the rest of the list. */
1690 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
1691 TREE_CHAIN (tmpl_types));
1693 /* Add the default argument for this parameter. */
1694 return hash_tree_cons (TREE_PURPOSE (tmpl_types),
1695 TREE_VALUE (spec_types),
1699 /* DECL is an explicit specialization. Replicate default arguments
1700 from the template it specializes. (That way, code like:
1702 template <class T> void f(T = 3);
1703 template <> void f(double);
1706 works, as required.) An alternative approach would be to look up
1707 the correct default arguments at the call-site, but this approach
1708 is consistent with how implicit instantiations are handled. */
1711 copy_default_args_to_explicit_spec (tree decl)
1716 tree new_spec_types;
1720 tree object_type = NULL_TREE;
1721 tree in_charge = NULL_TREE;
1722 tree vtt = NULL_TREE;
1724 /* See if there's anything we need to do. */
1725 tmpl = DECL_TI_TEMPLATE (decl);
1726 tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
1727 for (t = tmpl_types; t; t = TREE_CHAIN (t))
1728 if (TREE_PURPOSE (t))
1733 old_type = TREE_TYPE (decl);
1734 spec_types = TYPE_ARG_TYPES (old_type);
1736 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1738 /* Remove the this pointer, but remember the object's type for
1740 object_type = TREE_TYPE (TREE_VALUE (spec_types));
1741 spec_types = TREE_CHAIN (spec_types);
1742 tmpl_types = TREE_CHAIN (tmpl_types);
1744 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
1746 /* DECL may contain more parameters than TMPL due to the extra
1747 in-charge parameter in constructors and destructors. */
1748 in_charge = spec_types;
1749 spec_types = TREE_CHAIN (spec_types);
1751 if (DECL_HAS_VTT_PARM_P (decl))
1754 spec_types = TREE_CHAIN (spec_types);
1758 /* Compute the merged default arguments. */
1760 copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);
1762 /* Compute the new FUNCTION_TYPE. */
1766 new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt),
1771 /* Put the in-charge parameter back. */
1772 new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
1773 TREE_VALUE (in_charge),
1776 new_type = build_method_type_directly (object_type,
1777 TREE_TYPE (old_type),
1781 new_type = build_function_type (TREE_TYPE (old_type),
1783 new_type = cp_build_type_attribute_variant (new_type,
1784 TYPE_ATTRIBUTES (old_type));
1785 new_type = build_exception_variant (new_type,
1786 TYPE_RAISES_EXCEPTIONS (old_type));
1787 TREE_TYPE (decl) = new_type;
1790 /* Check to see if the function just declared, as indicated in
1791 DECLARATOR, and in DECL, is a specialization of a function
1792 template. We may also discover that the declaration is an explicit
1793 instantiation at this point.
1795 Returns DECL, or an equivalent declaration that should be used
1796 instead if all goes well. Issues an error message if something is
1797 amiss. Returns error_mark_node if the error is not easily
1800 FLAGS is a bitmask consisting of the following flags:
1802 2: The function has a definition.
1803 4: The function is a friend.
1805 The TEMPLATE_COUNT is the number of references to qualifying
1806 template classes that appeared in the name of the function. For
1809 template <class T> struct S { void f(); };
1812 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1813 classes are not counted in the TEMPLATE_COUNT, so that in
1815 template <class T> struct S {};
1816 template <> struct S<int> { void f(); }
1817 template <> void S<int>::f();
1819 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1820 invalid; there should be no template <>.)
1822 If the function is a specialization, it is marked as such via
1823 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1824 is set up correctly, and it is added to the list of specializations
1825 for that template. */
1828 check_explicit_specialization (tree declarator,
1833 int have_def = flags & 2;
1834 int is_friend = flags & 4;
1835 int specialization = 0;
1836 int explicit_instantiation = 0;
1837 int member_specialization = 0;
1838 tree ctype = DECL_CLASS_CONTEXT (decl);
1839 tree dname = DECL_NAME (decl);
1844 if (!processing_specialization)
1847 tsk = tsk_excessive_parms;
1850 tsk = current_tmpl_spec_kind (template_count);
1855 if (processing_specialization)
1858 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1860 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1863 /* This could be something like:
1865 template <class T> void f(T);
1866 class S { friend void f<>(int); } */
1870 /* This case handles bogus declarations like template <>
1871 template <class T> void f<int>(); */
1873 error ("template-id %qD in declaration of primary template",
1880 case tsk_invalid_member_spec:
1881 /* The error has already been reported in
1882 check_specialization_scope. */
1883 return error_mark_node;
1885 case tsk_invalid_expl_inst:
1886 error ("template parameter list used in explicit instantiation");
1892 error ("definition provided for explicit instantiation");
1894 explicit_instantiation = 1;
1897 case tsk_excessive_parms:
1898 case tsk_insufficient_parms:
1899 if (tsk == tsk_excessive_parms)
1900 error ("too many template parameter lists in declaration of %qD",
1902 else if (template_header_count)
1903 error("too few template parameter lists in declaration of %qD", decl);
1905 error("explicit specialization of %qD must be introduced by "
1906 "%<template <>%>", decl);
1910 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1912 member_specialization = 1;
1918 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1920 /* This case handles bogus declarations like template <>
1921 template <class T> void f<int>(); */
1923 if (uses_template_parms (declarator))
1924 error ("function template partial specialization %qD "
1925 "is not allowed", declarator);
1927 error ("template-id %qD in declaration of primary template",
1932 if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
1933 /* This is a specialization of a member template, without
1934 specialization the containing class. Something like:
1936 template <class T> struct S {
1937 template <class U> void f (U);
1939 template <> template <class U> void S<int>::f(U) {}
1941 That's a specialization -- but of the entire template. */
1949 if (specialization || member_specialization)
1951 tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
1952 for (; t; t = TREE_CHAIN (t))
1953 if (TREE_PURPOSE (t))
1956 ("default argument specified in explicit specialization");
1961 if (specialization || member_specialization || explicit_instantiation)
1963 tree tmpl = NULL_TREE;
1964 tree targs = NULL_TREE;
1966 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
1967 if (TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
1971 gcc_assert (TREE_CODE (declarator) == IDENTIFIER_NODE);
1976 /* If there is no class context, the explicit instantiation
1977 must be at namespace scope. */
1978 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl));
1980 /* Find the namespace binding, using the declaration
1982 fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
1984 if (!fns || !is_overloaded_fn (fns))
1986 error ("%qD is not a template function", dname);
1987 fns = error_mark_node;
1991 tree fn = OVL_CURRENT (fns);
1992 if (!is_associated_namespace (CP_DECL_CONTEXT (decl),
1993 CP_DECL_CONTEXT (fn)))
1994 error ("%qD is not declared in %qD",
1995 decl, current_namespace);
1999 declarator = lookup_template_function (fns, NULL_TREE);
2002 if (declarator == error_mark_node)
2003 return error_mark_node;
2005 if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
2007 if (!explicit_instantiation)
2008 /* A specialization in class scope. This is invalid,
2009 but the error will already have been flagged by
2010 check_specialization_scope. */
2011 return error_mark_node;
2014 /* It's not valid to write an explicit instantiation in
2017 class C { template void f(); }
2019 This case is caught by the parser. However, on
2022 template class C { void f(); };
2024 (which is invalid) we can get here. The error will be
2031 else if (ctype != NULL_TREE
2032 && (TREE_CODE (TREE_OPERAND (declarator, 0)) ==
2035 /* Find the list of functions in ctype that have the same
2036 name as the declared function. */
2037 tree name = TREE_OPERAND (declarator, 0);
2038 tree fns = NULL_TREE;
2041 if (constructor_name_p (name, ctype))
2043 int is_constructor = DECL_CONSTRUCTOR_P (decl);
2045 if (is_constructor ? !TYPE_HAS_CONSTRUCTOR (ctype)
2046 : !CLASSTYPE_DESTRUCTORS (ctype))
2048 /* From [temp.expl.spec]:
2050 If such an explicit specialization for the member
2051 of a class template names an implicitly-declared
2052 special member function (clause _special_), the
2053 program is ill-formed.
2055 Similar language is found in [temp.explicit]. */
2056 error ("specialization of implicitly-declared special member function");
2057 return error_mark_node;
2060 name = is_constructor ? ctor_identifier : dtor_identifier;
2063 if (!DECL_CONV_FN_P (decl))
2065 idx = lookup_fnfields_1 (ctype, name);
2067 fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (ctype), idx);
2071 VEC(tree,gc) *methods;
2074 /* For a type-conversion operator, we cannot do a
2075 name-based lookup. We might be looking for `operator
2076 int' which will be a specialization of `operator T'.
2077 So, we find *all* the conversion operators, and then
2078 select from them. */
2081 methods = CLASSTYPE_METHOD_VEC (ctype);
2083 for (idx = CLASSTYPE_FIRST_CONVERSION_SLOT;
2084 VEC_iterate (tree, methods, idx, ovl);
2087 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl)))
2088 /* There are no more conversion functions. */
2091 /* Glue all these conversion functions together
2092 with those we already have. */
2093 for (; ovl; ovl = OVL_NEXT (ovl))
2094 fns = ovl_cons (OVL_CURRENT (ovl), fns);
2098 if (fns == NULL_TREE)
2100 error ("no member function %qD declared in %qT", name, ctype);
2101 return error_mark_node;
2104 TREE_OPERAND (declarator, 0) = fns;
2107 /* Figure out what exactly is being specialized at this point.
2108 Note that for an explicit instantiation, even one for a
2109 member function, we cannot tell apriori whether the
2110 instantiation is for a member template, or just a member
2111 function of a template class. Even if a member template is
2112 being instantiated, the member template arguments may be
2113 elided if they can be deduced from the rest of the
2115 tmpl = determine_specialization (declarator, decl,
2117 member_specialization,
2121 if (!tmpl || tmpl == error_mark_node)
2122 /* We couldn't figure out what this declaration was
2124 return error_mark_node;
2127 tree gen_tmpl = most_general_template (tmpl);
2129 if (explicit_instantiation)
2131 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2132 is done by do_decl_instantiation later. */
2134 int arg_depth = TMPL_ARGS_DEPTH (targs);
2135 int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
2137 if (arg_depth > parm_depth)
2139 /* If TMPL is not the most general template (for
2140 example, if TMPL is a friend template that is
2141 injected into namespace scope), then there will
2142 be too many levels of TARGS. Remove some of them
2147 new_targs = make_tree_vec (parm_depth);
2148 for (i = arg_depth - parm_depth; i < arg_depth; ++i)
2149 TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
2150 = TREE_VEC_ELT (targs, i);
2154 return instantiate_template (tmpl, targs, tf_error);
2157 /* If we thought that the DECL was a member function, but it
2158 turns out to be specializing a static member function,
2159 make DECL a static member function as well. */
2160 if (DECL_STATIC_FUNCTION_P (tmpl)
2161 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2162 revert_static_member_fn (decl);
2164 /* If this is a specialization of a member template of a
2165 template class, we want to return the TEMPLATE_DECL, not
2166 the specialization of it. */
2167 if (tsk == tsk_template)
2169 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
2170 DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl)) = NULL_TREE;
2173 DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
2174 DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (tmpl))
2175 = DECL_SOURCE_LOCATION (decl);
2176 /* We want to use the argument list specified in the
2177 definition, not in the original declaration. */
2178 DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (tmpl))
2179 = DECL_ARGUMENTS (decl);
2184 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2185 DECL_TEMPLATE_INFO (decl) = tree_cons (tmpl, targs, NULL_TREE);
2187 /* Inherit default function arguments from the template
2188 DECL is specializing. */
2189 copy_default_args_to_explicit_spec (decl);
2191 /* This specialization has the same protection as the
2192 template it specializes. */
2193 TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
2194 TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
2196 /* 7.1.1-1 [dcl.stc]
2198 A storage-class-specifier shall not be specified in an
2199 explicit specialization...
2201 The parser rejects these, so unless action is taken here,
2202 explicit function specializations will always appear with
2205 The action recommended by the C++ CWG in response to C++
2206 defect report 605 is to make the storage class and linkage
2207 of the explicit specialization match the templated function:
2209 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2211 if (tsk == tsk_expl_spec && DECL_FUNCTION_TEMPLATE_P (gen_tmpl))
2213 tree tmpl_func = DECL_TEMPLATE_RESULT (gen_tmpl);
2214 gcc_assert (TREE_CODE (tmpl_func) == FUNCTION_DECL);
2216 /* This specialization has the same linkage and visiblity as
2217 the function template it specializes. */
2218 TREE_PUBLIC (decl) = TREE_PUBLIC (tmpl_func);
2219 DECL_THIS_STATIC (decl) = DECL_THIS_STATIC (tmpl_func);
2220 if (DECL_VISIBILITY_SPECIFIED (tmpl_func))
2222 DECL_VISIBILITY_SPECIFIED (decl) = 1;
2223 DECL_VISIBILITY (decl) = DECL_VISIBILITY (tmpl_func);
2227 /* If DECL is a friend declaration, declared using an
2228 unqualified name, the namespace associated with DECL may
2229 have been set incorrectly. For example, in:
2231 template <typename T> void f(T);
2233 struct S { friend void f<int>(int); }
2236 we will have set the DECL_CONTEXT for the friend
2237 declaration to N, rather than to the global namespace. */
2238 if (DECL_NAMESPACE_SCOPE_P (decl))
2239 DECL_CONTEXT (decl) = DECL_CONTEXT (tmpl);
2241 if (is_friend && !have_def)
2242 /* This is not really a declaration of a specialization.
2243 It's just the name of an instantiation. But, it's not
2244 a request for an instantiation, either. */
2245 SET_DECL_IMPLICIT_INSTANTIATION (decl);
2246 else if (DECL_CONSTRUCTOR_P (decl) || DECL_DESTRUCTOR_P (decl))
2247 /* This is indeed a specialization. In case of constructors
2248 and destructors, we need in-charge and not-in-charge
2249 versions in V3 ABI. */
2250 clone_function_decl (decl, /*update_method_vec_p=*/0);
2252 /* Register this specialization so that we can find it
2254 decl = register_specialization (decl, gen_tmpl, targs, is_friend);
2261 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2262 parameters. These are represented in the same format used for
2263 DECL_TEMPLATE_PARMS. */
2266 comp_template_parms (tree parms1, tree parms2)
2271 if (parms1 == parms2)
2274 for (p1 = parms1, p2 = parms2;
2275 p1 != NULL_TREE && p2 != NULL_TREE;
2276 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2))
2278 tree t1 = TREE_VALUE (p1);
2279 tree t2 = TREE_VALUE (p2);
2282 gcc_assert (TREE_CODE (t1) == TREE_VEC);
2283 gcc_assert (TREE_CODE (t2) == TREE_VEC);
2285 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
2288 for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
2290 tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
2291 tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
2293 /* If either of the template parameters are invalid, assume
2294 they match for the sake of error recovery. */
2295 if (parm1 == error_mark_node || parm2 == error_mark_node)
2298 if (TREE_CODE (parm1) != TREE_CODE (parm2))
2301 if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM
2302 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1)
2303 == TEMPLATE_TYPE_PARAMETER_PACK (parm2)))
2305 else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
2310 if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
2311 /* One set of parameters has more parameters lists than the
2318 /* Determine whether PARM is a parameter pack. */
2320 template_parameter_pack_p (tree parm)
2322 /* Determine if we have a non-type template parameter pack. */
2323 if (TREE_CODE (parm) == PARM_DECL)
2324 return (DECL_TEMPLATE_PARM_P (parm)
2325 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)));
2327 /* If this is a list of template parameters, we could get a
2328 TYPE_DECL or a TEMPLATE_DECL. */
2329 if (TREE_CODE (parm) == TYPE_DECL || TREE_CODE (parm) == TEMPLATE_DECL)
2330 parm = TREE_TYPE (parm);
2332 return ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
2333 || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM)
2334 && TEMPLATE_TYPE_PARAMETER_PACK (parm));
2337 /* Determine whether PARMS describes a variadic template parameter
2338 list, i.e., one that is terminated by a template parameter pack. */
2340 template_parms_variadic_p (tree parms)
2342 int nparms = TREE_VEC_LENGTH (parms);
2343 tree last_parm = TREE_VALUE (TREE_VEC_ELT (parms, nparms - 1));
2345 return template_parameter_pack_p (last_parm);
2348 /* Determine whether ARGS describes a variadic template args list,
2349 i.e., one that is terminated by a template argument pack. */
2351 template_args_variadic_p (tree args)
2356 if (args == NULL_TREE)
2359 args = INNERMOST_TEMPLATE_ARGS (args);
2360 nargs = TREE_VEC_LENGTH (args);
2365 last_parm = TREE_VEC_ELT (args, nargs - 1);
2367 return ARGUMENT_PACK_P (last_parm);
2370 /* Generate a new name for the parameter pack name NAME (an
2371 IDENTIFIER_NODE) that incorporates its */
2373 make_ith_pack_parameter_name (tree name, int i)
2375 /* Munge the name to include the parameter index. */
2379 sprintf(numbuf, "%i", i);
2380 newname = (char*)alloca (IDENTIFIER_LENGTH (name) + strlen(numbuf) + 2);
2381 sprintf(newname, "%s#%i", IDENTIFIER_POINTER (name), i);
2382 return get_identifier (newname);
2385 /* Structure used to track the progress of find_parameter_pack_r. */
2386 struct find_parameter_pack_data
2388 tree* parameter_packs;
2389 struct pointer_set_t *visited;
2392 /* Identifiers all of the argument packs that occur in a template
2393 argument and appends them to the TREE_LIST inside DATA, which is a
2394 find_parameter_pack_Data structure. This is a subroutine of
2395 make_pack_expansion and uses_parameter_packs. */
2397 find_parameter_packs_r (tree *tp, int *walk_subtrees, void* data)
2400 struct find_parameter_pack_data* ppd =
2401 (struct find_parameter_pack_data*)data;
2405 tree context = TYPE_CONTEXT (t);
2406 walk_tree (&context, &find_parameter_packs_r, ppd, ppd->visited);
2409 /* This switch statement will return immediately if we don't find a
2411 switch (TREE_CODE (t))
2413 case TEMPLATE_PARM_INDEX:
2414 if (TEMPLATE_PARM_PARAMETER_PACK (t))
2418 case BOUND_TEMPLATE_TEMPLATE_PARM:
2419 /* Check the template arguments. */
2420 walk_tree (&TYPE_TI_ARGS (t), &find_parameter_packs_r, ppd,
2423 /* Dig out the underlying TEMPLATE_TEMPLATE_PARM. */
2424 t = TYPE_TI_TEMPLATE (t);
2425 if (DECL_P (t) && TREE_TYPE (t))
2431 case TEMPLATE_TYPE_PARM:
2432 case TEMPLATE_TEMPLATE_PARM:
2433 if (TEMPLATE_TYPE_PARAMETER_PACK (t))
2438 if (FUNCTION_PARAMETER_PACK_P (t))
2440 /* We don't want to walk into the type of a PARM_DECL,
2441 because we don't want to see the type parameter pack.*/
2448 if (TYPE_PTRMEMFUNC_P (t))
2454 if (TYPE_TEMPLATE_INFO (t))
2456 tree args = TREE_VALUE (TYPE_TEMPLATE_INFO (t));
2457 walk_tree (&args, &find_parameter_packs_r, ppd, ppd->visited);
2464 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)
2465 && TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
2471 case TYPE_PACK_EXPANSION:
2472 case EXPR_PACK_EXPANSION:
2477 walk_tree (&TYPE_MAX_VALUE (t), &find_parameter_packs_r,
2486 /* Add this parameter pack to the list. */
2487 *ppd->parameter_packs = tree_cons (NULL_TREE, t, *ppd->parameter_packs);
2492 /* Determines if the expression or type T uses any parameter packs. */
2494 uses_parameter_packs (tree t)
2496 tree parameter_packs = NULL_TREE;
2497 struct find_parameter_pack_data ppd;
2498 ppd.parameter_packs = ¶meter_packs;
2499 ppd.visited = pointer_set_create ();
2500 walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
2501 pointer_set_destroy (ppd.visited);
2502 return parameter_packs != NULL_TREE;
2505 /* Turn ARG, which may be an expression, type, or a TREE_LIST
2506 representation a base-class initializer into a parameter pack
2507 expansion. If all goes well, the resulting node will be an
2508 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
2511 make_pack_expansion (tree arg)
2514 tree parameter_packs = NULL_TREE;
2515 bool for_types = false;
2516 struct find_parameter_pack_data ppd;
2518 if (!arg || arg == error_mark_node)
2521 if (TREE_CODE (arg) == TREE_LIST)
2523 /* The only time we will see a TREE_LIST here is for a base
2524 class initializer. In this case, the TREE_PURPOSE will be a
2525 _TYPE node (representing the base class expansion we're
2526 initializing) and the TREE_VALUE will be a TREE_LIST
2527 containing the initialization arguments.
2529 The resulting expansion looks somewhat different from most
2530 expansions. Rather than returning just one _EXPANSION, we
2531 return a TREE_LIST whose TREE_PURPOSE is a
2532 TYPE_PACK_EXPANSION containing the bases that will be
2533 initialized. The TREE_VALUE will be identical to the
2534 original TREE_VALUE, which is a list of arguments that will
2535 be passed to each base. We do not introduce any new pack
2536 expansion nodes into the TREE_VALUE (although it is possible
2537 that some already exist), because the TREE_PURPOSE and
2538 TREE_VALUE all need to be expanded together with the same
2539 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
2540 resulting TREE_PURPOSE will mention the parameter packs in
2541 both the bases and the arguments to the bases. */
2544 tree parameter_packs = NULL_TREE;
2546 /* Determine which parameter packs will be used by the base
2548 ppd.visited = pointer_set_create ();
2549 ppd.parameter_packs = ¶meter_packs;
2550 walk_tree (&TREE_PURPOSE (arg), &find_parameter_packs_r,
2553 if (parameter_packs == NULL_TREE)
2555 error ("base initializer expansion %<%T%> contains no parameter packs", arg);
2556 pointer_set_destroy (ppd.visited);
2557 return error_mark_node;
2560 if (TREE_VALUE (arg) != void_type_node)
2562 /* Collect the sets of parameter packs used in each of the
2563 initialization arguments. */
2564 for (value = TREE_VALUE (arg); value; value = TREE_CHAIN (value))
2566 /* Determine which parameter packs will be expanded in this
2568 walk_tree (&TREE_VALUE (value), &find_parameter_packs_r,
2573 pointer_set_destroy (ppd.visited);
2575 /* Create the pack expansion type for the base type. */
2576 purpose = make_node (TYPE_PACK_EXPANSION);
2577 SET_PACK_EXPANSION_PATTERN (purpose, TREE_PURPOSE (arg));
2578 PACK_EXPANSION_PARAMETER_PACKS (purpose) = parameter_packs;
2580 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
2581 they will rarely be compared to anything. */
2582 SET_TYPE_STRUCTURAL_EQUALITY (purpose);
2584 return tree_cons (purpose, TREE_VALUE (arg), NULL_TREE);
2587 if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
2590 /* Build the PACK_EXPANSION_* node. */
2591 result = make_node (for_types ? TYPE_PACK_EXPANSION : EXPR_PACK_EXPANSION);
2592 SET_PACK_EXPANSION_PATTERN (result, arg);
2593 if (TREE_CODE (result) == EXPR_PACK_EXPANSION)
2595 /* Propagate type and const-expression information. */
2596 TREE_TYPE (result) = TREE_TYPE (arg);
2597 TREE_CONSTANT (result) = TREE_CONSTANT (arg);
2600 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
2601 they will rarely be compared to anything. */
2602 SET_TYPE_STRUCTURAL_EQUALITY (result);
2604 /* Determine which parameter packs will be expanded. */
2605 ppd.parameter_packs = ¶meter_packs;
2606 ppd.visited = pointer_set_create ();
2607 walk_tree (&arg, &find_parameter_packs_r, &ppd, ppd.visited);
2608 pointer_set_destroy (ppd.visited);
2610 /* Make sure we found some parameter packs. */
2611 if (parameter_packs == NULL_TREE)
2614 error ("expansion pattern %<%T%> contains no argument packs", arg);
2616 error ("expansion pattern %<%E%> contains no argument packs", arg);
2617 return error_mark_node;
2619 PACK_EXPANSION_PARAMETER_PACKS (result) = parameter_packs;
2624 /* Checks T for any "bare" parameter packs, which have not yet been
2625 expanded, and issues an error if any are found. This operation can
2626 only be done on full expressions or types (e.g., an expression
2627 statement, "if" condition, etc.), because we could have expressions like:
2629 foo(f(g(h(args)))...)
2631 where "args" is a parameter pack. check_for_bare_parameter_packs
2632 should not be called for the subexpressions args, h(args),
2633 g(h(args)), or f(g(h(args))), because we would produce erroneous
2636 Returns TRUE if there were no bare parameter packs, returns FALSE
2637 (and emits an error) if there were bare parameter packs.*/
2639 check_for_bare_parameter_packs (tree t)
2641 tree parameter_packs = NULL_TREE;
2642 struct find_parameter_pack_data ppd;
2644 if (!processing_template_decl || !t || t == error_mark_node)
2647 if (TREE_CODE (t) == TYPE_DECL)
2650 ppd.parameter_packs = ¶meter_packs;
2651 ppd.visited = pointer_set_create ();
2652 walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
2653 pointer_set_destroy (ppd.visited);
2655 if (parameter_packs)
2657 error ("parameter packs not expanded with `...':");
2658 while (parameter_packs)
2660 tree pack = TREE_VALUE (parameter_packs);
2661 tree name = NULL_TREE;
2663 if (TREE_CODE (pack) == TEMPLATE_TYPE_PARM
2664 || TREE_CODE (pack) == TEMPLATE_TEMPLATE_PARM)
2665 name = TYPE_NAME (pack);
2666 else if (TREE_CODE (pack) == TEMPLATE_PARM_INDEX)
2667 name = DECL_NAME (TEMPLATE_PARM_DECL (pack));
2669 name = DECL_NAME (pack);
2670 inform (" %qD", name);
2672 parameter_packs = TREE_CHAIN (parameter_packs);
2681 /* Expand any parameter packs that occur in the template arguments in
2684 expand_template_argument_pack (tree args)
2686 tree result_args = NULL_TREE;
2687 int in_arg, out_arg = 0, nargs = args ? TREE_VEC_LENGTH (args) : 0;
2688 int num_result_args = -1;
2690 /* First, determine if we need to expand anything, and the number of
2691 slots we'll need. */
2692 for (in_arg = 0; in_arg < nargs; ++in_arg)
2694 tree arg = TREE_VEC_ELT (args, in_arg);
2695 if (ARGUMENT_PACK_P (arg))
2697 int num_packed = TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg));
2698 if (num_result_args < 0)
2699 num_result_args = in_arg + num_packed;
2701 num_result_args += num_packed;
2705 if (num_result_args >= 0)
2710 /* If no expansion is necessary, we're done. */
2711 if (num_result_args < 0)
2714 /* Expand arguments. */
2715 result_args = make_tree_vec (num_result_args);
2716 for (in_arg = 0; in_arg < nargs; ++in_arg)
2718 tree arg = TREE_VEC_ELT (args, in_arg);
2719 if (ARGUMENT_PACK_P (arg))
2721 tree packed = ARGUMENT_PACK_ARGS (arg);
2722 int i, num_packed = TREE_VEC_LENGTH (packed);
2723 for (i = 0; i < num_packed; ++i, ++out_arg)
2724 TREE_VEC_ELT (result_args, out_arg) = TREE_VEC_ELT(packed, i);
2728 TREE_VEC_ELT (result_args, out_arg) = arg;
2736 /* Complain if DECL shadows a template parameter.
2738 [temp.local]: A template-parameter shall not be redeclared within its
2739 scope (including nested scopes). */
2742 check_template_shadow (tree decl)
2746 /* If we're not in a template, we can't possibly shadow a template
2748 if (!current_template_parms)
2751 /* Figure out what we're shadowing. */
2752 if (TREE_CODE (decl) == OVERLOAD)
2753 decl = OVL_CURRENT (decl);
2754 olddecl = innermost_non_namespace_value (DECL_NAME (decl));
2756 /* If there's no previous binding for this name, we're not shadowing
2757 anything, let alone a template parameter. */
2761 /* If we're not shadowing a template parameter, we're done. Note
2762 that OLDDECL might be an OVERLOAD (or perhaps even an
2763 ERROR_MARK), so we can't just blithely assume it to be a _DECL
2765 if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
2768 /* We check for decl != olddecl to avoid bogus errors for using a
2769 name inside a class. We check TPFI to avoid duplicate errors for
2770 inline member templates. */
2772 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms))
2775 error ("declaration of %q+#D", decl);
2776 error (" shadows template parm %q+#D", olddecl);
2779 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
2780 ORIG_LEVEL, DECL, and TYPE. */
2783 build_template_parm_index (int index,
2789 tree t = make_node (TEMPLATE_PARM_INDEX);
2790 TEMPLATE_PARM_IDX (t) = index;
2791 TEMPLATE_PARM_LEVEL (t) = level;
2792 TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
2793 TEMPLATE_PARM_DECL (t) = decl;
2794 TREE_TYPE (t) = type;
2795 TREE_CONSTANT (t) = TREE_CONSTANT (decl);
2796 TREE_INVARIANT (t) = TREE_INVARIANT (decl);
2797 TREE_READONLY (t) = TREE_READONLY (decl);
2802 /* Find the canonical type parameter for the given template type
2803 parameter. Returns the canonical type parameter, which may be TYPE
2804 if no such parameter existed. */
2806 canonical_type_parameter (tree type)
2809 int idx = TEMPLATE_TYPE_IDX (type);
2810 if (!canonical_template_parms)
2811 canonical_template_parms = VEC_alloc (tree, gc, idx+1);
2813 while (VEC_length (tree, canonical_template_parms) <= (unsigned)idx)
2814 VEC_safe_push (tree, gc, canonical_template_parms, NULL_TREE);
2816 list = VEC_index (tree, canonical_template_parms, idx);
2817 while (list && !comptypes (type, TREE_VALUE (list), COMPARE_STRUCTURAL))
2818 list = TREE_CHAIN (list);
2821 return TREE_VALUE (list);
2824 VEC_replace(tree, canonical_template_parms, idx,
2825 tree_cons (NULL_TREE, type,
2826 VEC_index (tree, canonical_template_parms, idx)));
2831 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
2832 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
2833 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
2834 new one is created. */
2837 reduce_template_parm_level (tree index, tree type, int levels)
2839 if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
2840 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
2841 != TEMPLATE_PARM_LEVEL (index) - levels))
2843 tree orig_decl = TEMPLATE_PARM_DECL (index);
2846 decl = build_decl (TREE_CODE (orig_decl), DECL_NAME (orig_decl), type);
2847 TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl);
2848 TREE_INVARIANT (decl) = TREE_INVARIANT (orig_decl);
2849 TREE_READONLY (decl) = TREE_READONLY (orig_decl);
2850 DECL_ARTIFICIAL (decl) = 1;
2851 SET_DECL_TEMPLATE_PARM_P (decl);
2853 t = build_template_parm_index (TEMPLATE_PARM_IDX (index),
2854 TEMPLATE_PARM_LEVEL (index) - levels,
2855 TEMPLATE_PARM_ORIG_LEVEL (index),
2857 TEMPLATE_PARM_DESCENDANTS (index) = t;
2858 TEMPLATE_PARM_PARAMETER_PACK (t)
2859 = TEMPLATE_PARM_PARAMETER_PACK (index);
2861 /* Template template parameters need this. */
2862 if (TREE_CODE (decl) != CONST_DECL)
2863 DECL_TEMPLATE_PARMS (decl)
2864 = DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index));
2867 return TEMPLATE_PARM_DESCENDANTS (index);
2870 /* Process information from new template parameter PARM and append it to the
2871 LIST being built. This new parameter is a non-type parameter iff
2872 IS_NON_TYPE is true. This new parameter is a parameter
2873 pack iff IS_PARAMETER_PACK is true. */
2876 process_template_parm (tree list, tree parm, bool is_non_type,
2877 bool is_parameter_pack)
2884 gcc_assert (TREE_CODE (parm) == TREE_LIST);
2885 defval = TREE_PURPOSE (parm);
2889 tree p = tree_last (list);
2891 if (p && TREE_VALUE (p) != error_mark_node)
2894 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
2895 idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
2897 idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
2907 parm = TREE_VALUE (parm);
2909 SET_DECL_TEMPLATE_PARM_P (parm);
2911 if (TREE_TYPE (parm) == error_mark_node)
2913 err_parm_list = build_tree_list (defval, parm);
2914 TREE_VALUE (err_parm_list) = error_mark_node;
2915 return chainon (list, err_parm_list);
2921 The top-level cv-qualifiers on the template-parameter are
2922 ignored when determining its type. */
2923 TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
2924 if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
2926 err_parm_list = build_tree_list (defval, parm);
2927 TREE_VALUE (err_parm_list) = error_mark_node;
2928 return chainon (list, err_parm_list);
2931 if (uses_parameter_packs (TREE_TYPE (parm)) && !is_parameter_pack)
2933 /* This template parameter is not a parameter pack, but it
2934 should be. Complain about "bare" parameter packs. */
2935 check_for_bare_parameter_packs (TREE_TYPE (parm));
2937 /* Recover by calling this a parameter pack. */
2938 is_parameter_pack = true;
2942 /* A template parameter is not modifiable. */
2943 TREE_CONSTANT (parm) = 1;
2944 TREE_INVARIANT (parm) = 1;
2945 TREE_READONLY (parm) = 1;
2946 decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
2947 TREE_CONSTANT (decl) = 1;
2948 TREE_INVARIANT (decl) = 1;
2949 TREE_READONLY (decl) = 1;
2950 DECL_INITIAL (parm) = DECL_INITIAL (decl)
2951 = build_template_parm_index (idx, processing_template_decl,
2952 processing_template_decl,
2953 decl, TREE_TYPE (parm));
2955 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm))
2956 = is_parameter_pack;
2961 parm = TREE_VALUE (TREE_VALUE (parm));
2963 if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
2965 t = make_aggr_type (TEMPLATE_TEMPLATE_PARM);
2966 /* This is for distinguishing between real templates and template
2967 template parameters */
2968 TREE_TYPE (parm) = t;
2969 TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t;
2974 t = make_aggr_type (TEMPLATE_TYPE_PARM);
2975 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
2976 decl = build_decl (TYPE_DECL, parm, t);
2979 TYPE_NAME (t) = decl;
2980 TYPE_STUB_DECL (t) = decl;
2982 TEMPLATE_TYPE_PARM_INDEX (t)
2983 = build_template_parm_index (idx, processing_template_decl,
2984 processing_template_decl,
2985 decl, TREE_TYPE (parm));
2986 TEMPLATE_TYPE_PARAMETER_PACK (t) = is_parameter_pack;
2987 TYPE_CANONICAL (t) = canonical_type_parameter (t);
2989 DECL_ARTIFICIAL (decl) = 1;
2990 SET_DECL_TEMPLATE_PARM_P (decl);
2992 parm = build_tree_list (defval, parm);
2993 return chainon (list, parm);
2996 /* The end of a template parameter list has been reached. Process the
2997 tree list into a parameter vector, converting each parameter into a more
2998 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3002 end_template_parm_list (tree parms)
3006 tree saved_parmlist = make_tree_vec (list_length (parms));
3008 current_template_parms
3009 = tree_cons (size_int (processing_template_decl),
3010 saved_parmlist, current_template_parms);
3012 for (parm = parms, nparms = 0; parm; parm = next, nparms++)
3014 next = TREE_CHAIN (parm);
3015 TREE_VEC_ELT (saved_parmlist, nparms) = parm;
3016 TREE_CHAIN (parm) = NULL_TREE;
3019 --processing_template_parmlist;
3021 return saved_parmlist;
3024 /* end_template_decl is called after a template declaration is seen. */
3027 end_template_decl (void)
3029 reset_specialization ();
3031 if (! processing_template_decl)
3034 /* This matches the pushlevel in begin_template_parm_list. */
3037 --processing_template_decl;
3038 current_template_parms = TREE_CHAIN (current_template_parms);
3041 /* Within the declaration of a template, return all levels of template
3042 parameters that apply. The template parameters are represented as
3043 a TREE_VEC, in the form documented in cp-tree.h for template
3047 current_template_args (void)
3050 tree args = NULL_TREE;
3051 int length = TMPL_PARMS_DEPTH (current_template_parms);
3054 /* If there is only one level of template parameters, we do not
3055 create a TREE_VEC of TREE_VECs. Instead, we return a single
3056 TREE_VEC containing the arguments. */
3058 args = make_tree_vec (length);
3060 for (header = current_template_parms; header; header = TREE_CHAIN (header))
3062 tree a = copy_node (TREE_VALUE (header));
3065 TREE_TYPE (a) = NULL_TREE;
3066 for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
3068 tree t = TREE_VEC_ELT (a, i);
3070 /* T will be a list if we are called from within a
3071 begin/end_template_parm_list pair, but a vector directly
3072 if within a begin/end_member_template_processing pair. */
3073 if (TREE_CODE (t) == TREE_LIST)
3077 if (t != error_mark_node)
3079 if (TREE_CODE (t) == TYPE_DECL
3080 || TREE_CODE (t) == TEMPLATE_DECL)
3084 if (TEMPLATE_TYPE_PARAMETER_PACK (t))
3086 /* Turn this argument into a TYPE_ARGUMENT_PACK
3087 with a single element, which expands T. */
3088 tree vec = make_tree_vec (1);
3089 TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
3091 t = make_node (TYPE_ARGUMENT_PACK);
3092 SET_ARGUMENT_PACK_ARGS (t, vec);
3097 t = DECL_INITIAL (t);
3099 if (TEMPLATE_PARM_PARAMETER_PACK (t))
3101 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3102 with a single element, which expands T. */
3103 tree vec = make_tree_vec (1);
3104 tree type = TREE_TYPE (TEMPLATE_PARM_DECL (t));
3105 TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
3107 t = make_node (NONTYPE_ARGUMENT_PACK);
3108 SET_ARGUMENT_PACK_ARGS (t, vec);
3109 TREE_TYPE (t) = type;
3113 TREE_VEC_ELT (a, i) = t;
3118 TREE_VEC_ELT (args, --l) = a;
3126 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
3127 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
3128 a member template. Used by push_template_decl below. */
3131 build_template_decl (tree decl, tree parms, bool member_template_p)
3133 tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
3134 DECL_TEMPLATE_PARMS (tmpl) = parms;
3135 DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
3136 DECL_MEMBER_TEMPLATE_P (tmpl) = member_template_p;
3137 if (DECL_LANG_SPECIFIC (decl))
3139 DECL_STATIC_FUNCTION_P (tmpl) = DECL_STATIC_FUNCTION_P (decl);
3140 DECL_CONSTRUCTOR_P (tmpl) = DECL_CONSTRUCTOR_P (decl);
3141 DECL_DESTRUCTOR_P (tmpl) = DECL_DESTRUCTOR_P (decl);
3142 DECL_NONCONVERTING_P (tmpl) = DECL_NONCONVERTING_P (decl);
3143 DECL_ASSIGNMENT_OPERATOR_P (tmpl) = DECL_ASSIGNMENT_OPERATOR_P (decl);
3144 if (DECL_OVERLOADED_OPERATOR_P (decl))
3145 SET_OVERLOADED_OPERATOR_CODE (tmpl,
3146 DECL_OVERLOADED_OPERATOR_P (decl));
3152 struct template_parm_data
3154 /* The level of the template parameters we are currently
3158 /* The index of the specialization argument we are currently
3162 /* An array whose size is the number of template parameters. The
3163 elements are nonzero if the parameter has been used in any one
3164 of the arguments processed so far. */
3167 /* An array whose size is the number of template arguments. The
3168 elements are nonzero if the argument makes use of template
3169 parameters of this level. */
3170 int* arg_uses_template_parms;
3173 /* Subroutine of push_template_decl used to see if each template
3174 parameter in a partial specialization is used in the explicit
3175 argument list. If T is of the LEVEL given in DATA (which is
3176 treated as a template_parm_data*), then DATA->PARMS is marked
3180 mark_template_parm (tree t, void* data)
3184 struct template_parm_data* tpd = (struct template_parm_data*) data;
3186 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
3188 level = TEMPLATE_PARM_LEVEL (t);
3189 idx = TEMPLATE_PARM_IDX (t);
3193 level = TEMPLATE_TYPE_LEVEL (t);
3194 idx = TEMPLATE_TYPE_IDX (t);
3197 if (level == tpd->level)
3199 tpd->parms[idx] = 1;
3200 tpd->arg_uses_template_parms[tpd->current_arg] = 1;
3203 /* Return zero so that for_each_template_parm will continue the
3204 traversal of the tree; we want to mark *every* template parm. */
3208 /* Process the partial specialization DECL. */
3211 process_partial_specialization (tree decl)
3213 tree type = TREE_TYPE (decl);
3214 tree maintmpl = CLASSTYPE_TI_TEMPLATE (type);
3215 tree specargs = CLASSTYPE_TI_ARGS (type);
3216 tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
3217 tree inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
3218 tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
3219 int nargs = TREE_VEC_LENGTH (inner_args);
3220 int ntparms = TREE_VEC_LENGTH (inner_parms);
3222 int did_error_intro = 0;
3223 struct template_parm_data tpd;
3224 struct template_parm_data tpd2;
3226 /* We check that each of the template parameters given in the
3227 partial specialization is used in the argument list to the
3228 specialization. For example:
3230 template <class T> struct S;
3231 template <class T> struct S<T*>;
3233 The second declaration is OK because `T*' uses the template
3234 parameter T, whereas
3236 template <class T> struct S<int>;
3238 is no good. Even trickier is:
3249 The S2<T> declaration is actually invalid; it is a
3250 full-specialization. Of course,
3253 struct S2<T (*)(U)>;
3255 or some such would have been OK. */
3256 tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
3257 tpd.parms = (int *) alloca (sizeof (int) * ntparms);
3258 memset (tpd.parms, 0, sizeof (int) * ntparms);
3260 tpd.arg_uses_template_parms = (int *) alloca (sizeof (int) * nargs);
3261 memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
3262 for (i = 0; i < nargs; ++i)
3264 tpd.current_arg = i;
3265 for_each_template_parm (TREE_VEC_ELT (inner_args, i),
3266 &mark_template_parm,
3270 for (i = 0; i < ntparms; ++i)
3271 if (tpd.parms[i] == 0)
3273 /* One of the template parms was not used in the
3275 if (!did_error_intro)
3277 error ("template parameters not used in partial specialization:");
3278 did_error_intro = 1;
3281 error (" %qD", TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
3284 /* [temp.class.spec]
3286 The argument list of the specialization shall not be identical to
3287 the implicit argument list of the primary template. */
3288 if (comp_template_args
3290 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
3292 error ("partial specialization %qT does not specialize any template arguments", type);
3294 /* [temp.class.spec]
3296 A partially specialized non-type argument expression shall not
3297 involve template parameters of the partial specialization except
3298 when the argument expression is a simple identifier.
3300 The type of a template parameter corresponding to a specialized
3301 non-type argument shall not be dependent on a parameter of the
3304 Also, we verify that pack expansions only occur at the
3305 end of the argument list. */
3306 gcc_assert (nargs == DECL_NTPARMS (maintmpl));
3308 for (i = 0; i < nargs; ++i)
3310 tree parm = TREE_VALUE (TREE_VEC_ELT (main_inner_parms, i));
3311 tree arg = TREE_VEC_ELT (inner_args, i);
3312 tree packed_args = NULL_TREE;
3315 if (ARGUMENT_PACK_P (arg))
3317 /* Extract the arguments from the argument pack. We'll be
3318 iterating over these in the following loop. */
3319 packed_args = ARGUMENT_PACK_ARGS (arg);
3320 len = TREE_VEC_LENGTH (packed_args);
3323 for (j = 0; j < len; j++)
3326 /* Get the Jth argument in the parameter pack. */
3327 arg = TREE_VEC_ELT (packed_args, j);
3329 if (PACK_EXPANSION_P (arg))
3331 /* Pack expansions must come at the end of the
3333 if ((packed_args && j < len - 1)
3334 || (!packed_args && i < nargs - 1))
3336 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
3337 error ("parameter pack argument %qE must be at the end of the template argument list", arg);
3339 error ("parameter pack argument %qT must be at the end of the template argument list", arg);
3343 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
3344 /* We only care about the pattern. */
3345 arg = PACK_EXPANSION_PATTERN (arg);
3347 if (/* These first two lines are the `non-type' bit. */
3349 && TREE_CODE (arg) != TEMPLATE_DECL
3350 /* This next line is the `argument expression is not just a
3351 simple identifier' condition and also the `specialized
3352 non-type argument' bit. */
3353 && TREE_CODE (arg) != TEMPLATE_PARM_INDEX)
3355 if ((!packed_args && tpd.arg_uses_template_parms[i])
3356 || (packed_args && uses_template_parms (arg)))
3357 error ("template argument %qE involves template parameter(s)",
3361 /* Look at the corresponding template parameter,
3362 marking which template parameters its type depends
3364 tree type = TREE_TYPE (parm);
3368 /* We haven't yet initialized TPD2. Do so now. */
3369 tpd2.arg_uses_template_parms
3370 = (int *) alloca (sizeof (int) * nargs);
3371 /* The number of parameters here is the number in the
3372 main template, which, as checked in the assertion
3374 tpd2.parms = (int *) alloca (sizeof (int) * nargs);
3376 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
3379 /* Mark the template parameters. But this time, we're
3380 looking for the template parameters of the main
3381 template, not in the specialization. */
3382 tpd2.current_arg = i;
3383 tpd2.arg_uses_template_parms[i] = 0;
3384 memset (tpd2.parms, 0, sizeof (int) * nargs);
3385 for_each_template_parm (type,
3386 &mark_template_parm,
3390 if (tpd2.arg_uses_template_parms [i])
3392 /* The type depended on some template parameters.
3393 If they are fully specialized in the
3394 specialization, that's OK. */
3396 for (j = 0; j < nargs; ++j)
3397 if (tpd2.parms[j] != 0
3398 && tpd.arg_uses_template_parms [j])
3400 error ("type %qT of template argument %qE depends "
3401 "on template parameter(s)",
3412 if (retrieve_specialization (maintmpl, specargs,
3413 /*class_specializations_p=*/true))
3414 /* We've already got this specialization. */
3417 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
3418 = tree_cons (specargs, inner_parms,
3419 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
3420 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
3424 /* Check that a template declaration's use of default arguments is not
3425 invalid. Here, PARMS are the template parameters. IS_PRIMARY is
3426 nonzero if DECL is the thing declared by a primary template.
3427 IS_PARTIAL is nonzero if DECL is a partial specialization.
3430 IS_FRIEND_DECL is nonzero if DECL is a friend function template
3431 declaration (but not a definition); 1 indicates a declaration, 2
3432 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
3433 emitted for extraneous default arguments.
3435 Returns TRUE if there were no errors found, FALSE otherwise. */
3438 check_default_tmpl_args (tree decl, tree parms, int is_primary,
3439 int is_partial, int is_friend_decl)
3442 int last_level_to_check;
3444 bool no_errors = true;
3448 A default template-argument shall not be specified in a
3449 function template declaration or a function template definition, nor
3450 in the template-parameter-list of the definition of a member of a
3453 if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
3454 /* You can't have a function template declaration in a local
3455 scope, nor you can you define a member of a class template in a
3459 if (current_class_type
3460 && !TYPE_BEING_DEFINED (current_class_type)
3461 && DECL_LANG_SPECIFIC (decl)
3462 /* If this is either a friend defined in the scope of the class
3463 or a member function. */
3464 && (DECL_FUNCTION_MEMBER_P (decl)
3465 ? same_type_p (DECL_CONTEXT (decl), current_class_type)
3466 : DECL_FRIEND_CONTEXT (decl)
3467 ? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type)
3469 /* And, if it was a member function, it really was defined in
3470 the scope of the class. */
3471 && (!DECL_FUNCTION_MEMBER_P (decl)
3472 || DECL_INITIALIZED_IN_CLASS_P (decl)))
3473 /* We already checked these parameters when the template was
3474 declared, so there's no need to do it again now. This function
3475 was defined in class scope, but we're processing it's body now
3476 that the class is complete. */
3479 /* Core issue 226 (C++0x only): the following only applies to class
3481 if ((cxx_dialect == cxx98) || TREE_CODE (decl) != FUNCTION_DECL)
3485 If a template-parameter has a default template-argument, all
3486 subsequent template-parameters shall have a default
3487 template-argument supplied. */
3488 for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
3490 tree inner_parms = TREE_VALUE (parm_level);
3491 int ntparms = TREE_VEC_LENGTH (inner_parms);
3492 int seen_def_arg_p = 0;
3495 for (i = 0; i < ntparms; ++i)
3497 tree parm = TREE_VEC_ELT (inner_parms, i);
3499 if (parm == error_mark_node)
3502 if (TREE_PURPOSE (parm))
3504 else if (seen_def_arg_p)
3506 error ("no default argument for %qD", TREE_VALUE (parm));
3507 /* For better subsequent error-recovery, we indicate that
3508 there should have been a default argument. */
3509 TREE_PURPOSE (parm) = error_mark_node;
3516 if (((cxx_dialect == cxx98) && TREE_CODE (decl) != TYPE_DECL)
3520 /* For an ordinary class template, default template arguments are
3521 allowed at the innermost level, e.g.:
3522 template <class T = int>
3524 but, in a partial specialization, they're not allowed even
3525 there, as we have in [temp.class.spec]:
3527 The template parameter list of a specialization shall not
3528 contain default template argument values.
3530 So, for a partial specialization, or for a function template
3531 (in C++98/C++03), we look at all of them. */
3534 /* But, for a primary class template that is not a partial
3535 specialization we look at all template parameters except the
3537 parms = TREE_CHAIN (parms);
3539 /* Figure out what error message to issue. */
3540 if (is_friend_decl == 2)
3541 msg = "default template arguments may not be used in function template friend re-declaration";
3542 else if (is_friend_decl)
3543 msg = "default template arguments may not be used in function template friend declarations";
3544 else if (TREE_CODE (decl) == FUNCTION_DECL && (cxx_dialect == cxx98))
3545 msg = "default template arguments may not be used in function templates";
3546 else if (is_partial)
3547 msg = "default template arguments may not be used in partial specializations";
3549 msg = "default argument for template parameter for class enclosing %qD";
3551 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
3552 /* If we're inside a class definition, there's no need to
3553 examine the parameters to the class itself. On the one
3554 hand, they will be checked when the class is defined, and,
3555 on the other, default arguments are valid in things like:
3556 template <class T = double>
3557 struct S { template <class U> void f(U); };
3558 Here the default argument for `S' has no bearing on the
3559 declaration of `f'. */
3560 last_level_to_check = template_class_depth (current_class_type) + 1;
3562 /* Check everything. */
3563 last_level_to_check = 0;
3565 for (parm_level = parms;
3566 parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
3567 parm_level = TREE_CHAIN (parm_level))
3569 tree inner_parms = TREE_VALUE (parm_level);
3573 ntparms = TREE_VEC_LENGTH (inner_parms);
3574 for (i = 0; i < ntparms; ++i)
3576 if (TREE_VEC_ELT (inner_parms, i) == error_mark_node)
3579 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
3584 if (is_friend_decl == 2)
3591 /* Clear out the default argument so that we are not
3593 TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
3597 /* At this point, if we're still interested in issuing messages,
3598 they must apply to classes surrounding the object declared. */
3600 msg = "default argument for template parameter for class enclosing %qD";
3606 /* Worker for push_template_decl_real, called via
3607 for_each_template_parm. DATA is really an int, indicating the
3608 level of the parameters we are interested in. If T is a template
3609 parameter of that level, return nonzero. */
3612 template_parm_this_level_p (tree t, void* data)
3614 int this_level = *(int *)data;
3617 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
3618 level = TEMPLATE_PARM_LEVEL (t);
3620 level = TEMPLATE_TYPE_LEVEL (t);
3621 return level == this_level;
3624 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
3625 parameters given by current_template_args, or reuses a
3626 previously existing one, if appropriate. Returns the DECL, or an
3627 equivalent one, if it is replaced via a call to duplicate_decls.
3629 If IS_FRIEND is true, DECL is a friend declaration. */
3632 push_template_decl_real (tree decl, bool is_friend)
3640 int new_template_p = 0;
3641 /* True if the template is a member template, in the sense of
3643 bool member_template_p = false;
3645 if (decl == error_mark_node)
3648 /* See if this is a partial specialization. */
3649 is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl)
3650 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
3651 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)));
3653 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl))
3657 /* For a friend, we want the context of the friend function, not
3658 the type of which it is a friend. */
3659 ctx = DECL_CONTEXT (decl);
3660 else if (CP_DECL_CONTEXT (decl)
3661 && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
3662 /* In the case of a virtual function, we want the class in which
3664 ctx = CP_DECL_CONTEXT (decl);
3666 /* Otherwise, if we're currently defining some class, the DECL
3667 is assumed to be a member of the class. */
3668 ctx = current_scope ();
3670 if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
3673 if (!DECL_CONTEXT (decl))
3674 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
3676 /* See if this is a primary template. */
3677 if (is_friend && ctx)
3678 /* A friend template that specifies a class context, i.e.
3679 template <typename T> friend void A<T>::f();
3683 primary = template_parm_scope_p ();
3687 if (DECL_CLASS_SCOPE_P (decl))
3688 member_template_p = true;
3689 if (TREE_CODE (decl) == TYPE_DECL
3690 && ANON_AGGRNAME_P (DECL_NAME (decl)))
3691 error ("template class without a name");
3692 else if (TREE_CODE (decl) == FUNCTION_DECL)
3694 if (DECL_DESTRUCTOR_P (decl))
3698 A destructor shall not be a member template. */
3699 error ("destructor %qD declared as member template", decl);
3700 return error_mark_node;
3702 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl))
3703 && (!TYPE_ARG_TYPES (TREE_TYPE (decl))
3704 || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
3705 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
3706 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl))))
3707 == void_list_node)))
3709 /* [basic.stc.dynamic.allocation]
3711 An allocation function can be a function
3712 template. ... Template allocation functions shall
3713 have two or more parameters. */
3714 error ("invalid template declaration of %qD", decl);
3715 return error_mark_node;
3718 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
3719 && CLASS_TYPE_P (TREE_TYPE (decl)))
3723 error ("template declaration of %q#D", decl);
3724 return error_mark_node;
3728 /* Check to see that the rules regarding the use of default
3729 arguments are not being violated. */
3730 check_default_tmpl_args (decl, current_template_parms,
3731 primary, is_partial, /*is_friend_decl=*/0);
3733 /* Ensure that there are no parameter packs in the type of this
3734 declaration that have not been expanded. */
3735 if (TREE_CODE (decl) == FUNCTION_DECL)
3737 /* Check each of the arguments individually to see if there are
3738 any bare parameter packs. */
3739 tree type = TREE_TYPE (decl);
3740 tree arg = DECL_ARGUMENTS (decl);
3741 tree argtype = TYPE_ARG_TYPES (type);
3743 while (arg && argtype)
3745 if (!FUNCTION_PARAMETER_PACK_P (arg)
3746 && !check_for_bare_parameter_packs (TREE_TYPE (arg)))
3748 /* This is a PARM_DECL that contains unexpanded parameter
3749 packs. We have already complained about this in the
3750 check_for_bare_parameter_packs call, so just replace
3751 these types with ERROR_MARK_NODE. */
3752 TREE_TYPE (arg) = error_mark_node;
3753 TREE_VALUE (argtype) = error_mark_node;
3756 arg = TREE_CHAIN (arg);
3757 argtype = TREE_CHAIN (argtype);
3760 /* Check for bare parameter packs in the return type and the
3761 exception specifiers. */
3762 check_for_bare_parameter_packs (TREE_TYPE (type));
3763 check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type));
3766 check_for_bare_parameter_packs (TREE_TYPE (decl));
3769 return process_partial_specialization (decl);
3771 /* A primary class template can only have one parameter pack, at the
3772 end of the template parameter list. */
3773 if (primary && TREE_CODE (decl) == TYPE_DECL)
3776 = INNERMOST_TEMPLATE_PARMS (current_template_parms);
3777 int i, len = TREE_VEC_LENGTH (inner_parms);
3778 for (i = 0; i < len - 1; i++)
3780 tree parm = TREE_VALUE (TREE_VEC_ELT (inner_parms, i));
3782 if (template_parameter_pack_p (parm))
3784 if (TREE_CODE (parm) == PARM_DECL)
3785 error ("parameter pack %qE must be at the end of the"
3786 " template parameter list", parm);
3788 error ("parameter pack %qT must be at the end of the"
3789 " template parameter list", TREE_TYPE (parm));
3794 args = current_template_args ();
3797 || TREE_CODE (ctx) == FUNCTION_DECL
3798 || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
3799 || (is_friend && !DECL_TEMPLATE_INFO (decl)))
3801 if (DECL_LANG_SPECIFIC (decl)
3802 && DECL_TEMPLATE_INFO (decl)
3803 && DECL_TI_TEMPLATE (decl))
3804 tmpl = DECL_TI_TEMPLATE (decl);
3805 /* If DECL is a TYPE_DECL for a class-template, then there won't
3806 be DECL_LANG_SPECIFIC. The information equivalent to
3807 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
3808 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
3809 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
3810 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
3812 /* Since a template declaration already existed for this
3813 class-type, we must be redeclaring it here. Make sure
3814 that the redeclaration is valid. */
3815 redeclare_class_template (TREE_TYPE (decl),
3816 current_template_parms);
3817 /* We don't need to create a new TEMPLATE_DECL; just use the
3818 one we already had. */
3819 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
3823 tmpl = build_template_decl (decl, current_template_parms,
3827 if (DECL_LANG_SPECIFIC (decl)
3828 && DECL_TEMPLATE_SPECIALIZATION (decl))
3830 /* A specialization of a member template of a template
3832 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
3833 DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
3834 DECL_TEMPLATE_INFO (decl) = NULL_TREE;
3840 tree a, t, current, parms;
3843 if (TREE_CODE (decl) == TYPE_DECL)
3845 if ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (decl)))
3846 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
3847 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
3848 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
3849 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
3852 error ("%qD does not declare a template type", decl);
3856 else if (!DECL_LANG_SPECIFIC (decl) || !DECL_TEMPLATE_INFO (decl))
3858 error ("template definition of non-template %q#D", decl);
3862 tmpl = DECL_TI_TEMPLATE (decl);
3864 if (DECL_FUNCTION_TEMPLATE_P (tmpl)
3865 && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
3866 && DECL_TEMPLATE_SPECIALIZATION (decl)
3867 && DECL_MEMBER_TEMPLATE_P (tmpl))
3871 /* The declaration is a specialization of a member
3872 template, declared outside the class. Therefore, the
3873 innermost template arguments will be NULL, so we
3874 replace them with the arguments determined by the
3875 earlier call to check_explicit_specialization. */
3876 args = DECL_TI_ARGS (decl);
3879 = build_template_decl (decl, current_template_parms,
3881 DECL_TEMPLATE_RESULT (new_tmpl) = decl;
3882 TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
3883 DECL_TI_TEMPLATE (decl) = new_tmpl;
3884 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
3885 DECL_TEMPLATE_INFO (new_tmpl)
3886 = tree_cons (tmpl, args, NULL_TREE);
3888 register_specialization (new_tmpl,
3889 most_general_template (tmpl),
3895 /* Make sure the template headers we got make sense. */
3897 parms = DECL_TEMPLATE_PARMS (tmpl);
3898 i = TMPL_PARMS_DEPTH (parms);
3899 if (TMPL_ARGS_DEPTH (args) != i)
3901 error ("expected %d levels of template parms for %q#D, got %d",
3902 i, decl, TMPL_ARGS_DEPTH (args));
3905 for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
3907 a = TMPL_ARGS_LEVEL (args, i);
3908 t = INNERMOST_TEMPLATE_PARMS (parms);
3910 if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
3912 if (current == decl)
3913 error ("got %d template parameters for %q#D",
3914 TREE_VEC_LENGTH (a), decl);
3916 error ("got %d template parameters for %q#T",
3917 TREE_VEC_LENGTH (a), current);
3918 error (" but %d required", TREE_VEC_LENGTH (t));
3919 return error_mark_node;
3922 /* Perhaps we should also check that the parms are used in the
3923 appropriate qualifying scopes in the declarator? */
3925 if (current == decl)
3928 current = TYPE_CONTEXT (current);
3932 DECL_TEMPLATE_RESULT (tmpl) = decl;
3933 TREE_TYPE (tmpl) = TREE_TYPE (decl);
3935 /* Push template declarations for global functions and types. Note
3936 that we do not try to push a global template friend declared in a
3937 template class; such a thing may well depend on the template
3938 parameters of the class. */
3939 if (new_template_p && !ctx
3940 && !(is_friend && template_class_depth (current_class_type) > 0))
3942 tmpl = pushdecl_namespace_level (tmpl, is_friend);
3943 if (tmpl == error_mark_node)
3944 return error_mark_node;
3946 /* Hide template friend classes that haven't been declared yet. */
3947 if (is_friend && TREE_CODE (decl) == TYPE_DECL)
3949 DECL_ANTICIPATED (tmpl) = 1;
3950 DECL_FRIEND_P (tmpl) = 1;
3956 DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
3957 if (DECL_CONV_FN_P (tmpl))
3959 int depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
3961 /* It is a conversion operator. See if the type converted to
3962 depends on innermost template operands. */
3964 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl)),
3966 DECL_TEMPLATE_CONV_FN_P (tmpl) = 1;
3970 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
3971 back to its most general template. If TMPL is a specialization,
3972 ARGS may only have the innermost set of arguments. Add the missing
3973 argument levels if necessary. */
3974 if (DECL_TEMPLATE_INFO (tmpl))
3975 args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);
3977 info = tree_cons (tmpl, args, NULL_TREE);
3979 if (DECL_IMPLICIT_TYPEDEF_P (decl))
3980 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
3981 else if (DECL_LANG_SPECIFIC (decl))
3982 DECL_TEMPLATE_INFO (decl) = info;
3984 return DECL_TEMPLATE_RESULT (tmpl);
3988 push_template_decl (tree decl)
3990 return push_template_decl_real (decl, false);
3993 /* Called when a class template TYPE is redeclared with the indicated
3994 template PARMS, e.g.:
3996 template <class T> struct S;
3997 template <class T> struct S {}; */
4000 redeclare_class_template (tree type, tree parms)
4006 if (!TYPE_TEMPLATE_INFO (type))
4008 error ("%qT is not a template type", type);
4012 tmpl = TYPE_TI_TEMPLATE (type);
4013 if (!PRIMARY_TEMPLATE_P (tmpl))
4014 /* The type is nested in some template class. Nothing to worry
4015 about here; there are no new template parameters for the nested
4021 error ("template specifiers not specified in declaration of %qD",
4026 parms = INNERMOST_TEMPLATE_PARMS (parms);
4027 tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
4029 if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
4031 error ("previous declaration %q+D", tmpl);
4032 error ("used %d template parameter(s) instead of %d",
4033 TREE_VEC_LENGTH (tmpl_parms),
4034 TREE_VEC_LENGTH (parms));
4038 for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
4045 if (TREE_VEC_ELT (tmpl_parms, i) == error_mark_node
4046 || TREE_VEC_ELT (parms, i) == error_mark_node)
4049 tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
4050 parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
4051 tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i));
4052 parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
4054 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
4056 if (tmpl_parm != error_mark_node
4057 && (TREE_CODE (tmpl_parm) != TREE_CODE (parm)
4058 || (TREE_CODE (tmpl_parm) != TYPE_DECL
4059 && !same_type_p (TREE_TYPE (tmpl_parm), TREE_TYPE (parm)))))
4061 error ("template parameter %q+#D", tmpl_parm);
4062 error ("redeclared here as %q#D", parm);
4066 if (tmpl_default != NULL_TREE && parm_default != NULL_TREE)
4068 /* We have in [temp.param]:
4070 A template-parameter may not be given default arguments
4071 by two different declarations in the same scope. */
4072 error ("redefinition of default argument for %q#D", parm);
4073 error ("%J original definition appeared here", tmpl_parm);
4077 if (parm_default != NULL_TREE)
4078 /* Update the previous template parameters (which are the ones
4079 that will really count) with the new default value. */
4080 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default;
4081 else if (tmpl_default != NULL_TREE)
4082 /* Update the new parameters, too; they'll be used as the
4083 parameters for any members. */
4084 TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default;
4090 /* Simplify EXPR if it is a non-dependent expression. Returns the
4091 (possibly simplified) expression. */
4094 fold_non_dependent_expr (tree expr)
4096 if (expr == NULL_TREE)
4099 /* If we're in a template, but EXPR isn't value dependent, simplify
4100 it. We're supposed to treat:
4102 template <typename T> void f(T[1 + 1]);
4103 template <typename T> void f(T[2]);
4105 as two declarations of the same function, for example. */
4106 if (processing_template_decl
4107 && !type_dependent_expression_p (expr)
4108 && !value_dependent_expression_p (expr))
4110 HOST_WIDE_INT saved_processing_template_decl;
4112 saved_processing_template_decl = processing_template_decl;
4113 processing_template_decl = 0;
4114 expr = tsubst_copy_and_build (expr,
4117 /*in_decl=*/NULL_TREE,
4118 /*function_p=*/false,
4119 /*integral_constant_expression_p=*/true);
4120 processing_template_decl = saved_processing_template_decl;
4125 /* EXPR is an expression which is used in a constant-expression context.
4126 For instance, it could be a VAR_DECL with a constant initializer.
4127 Extract the innest constant expression.
4129 This is basically a more powerful version of
4130 integral_constant_value, which can be used also in templates where
4131 initializers can maintain a syntactic rather than semantic form
4132 (even if they are non-dependent, for access-checking purposes). */
4135 fold_decl_constant_value (tree expr)
4137 tree const_expr = expr;
4140 expr = fold_non_dependent_expr (const_expr);
4141 const_expr = integral_constant_value (expr);
4143 while (expr != const_expr);
4148 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
4149 must be a function or a pointer-to-function type, as specified
4150 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
4151 and check that the resulting function has external linkage. */
4154 convert_nontype_argument_function (tree type, tree expr)
4159 fn = instantiate_type (type, fns, tf_none);
4160 if (fn == error_mark_node)
4161 return error_mark_node;
4164 if (TREE_CODE (fn_no_ptr) == ADDR_EXPR)
4165 fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0);
4166 if (TREE_CODE (fn_no_ptr) == BASELINK)
4167 fn_no_ptr = BASELINK_FUNCTIONS (fn_no_ptr);
4169 /* [temp.arg.nontype]/1
4171 A template-argument for a non-type, non-template template-parameter
4174 -- the address of an object or function with external linkage. */
4175 if (!DECL_EXTERNAL_LINKAGE_P (fn_no_ptr))
4177 error ("%qE is not a valid template argument for type %qT "
4178 "because function %qD has not external linkage",
4179 expr, type, fn_no_ptr);
4186 /* Attempt to convert the non-type template parameter EXPR to the
4187 indicated TYPE. If the conversion is successful, return the
4188 converted value. If the conversion is unsuccessful, return
4189 NULL_TREE if we issued an error message, or error_mark_node if we
4190 did not. We issue error messages for out-and-out bad template
4191 parameters, but not simply because the conversion failed, since we
4192 might be just trying to do argument deduction. Both TYPE and EXPR
4193 must be non-dependent.
4195 The conversion follows the special rules described in
4196 [temp.arg.nontype], and it is much more strict than an implicit
4199 This function is called twice for each template argument (see
4200 lookup_template_class for a more accurate description of this
4201 problem). This means that we need to handle expressions which
4202 are not valid in a C++ source, but can be created from the
4203 first call (for instance, casts to perform conversions). These
4204 hacks can go away after we fix the double coercion problem. */
4207 convert_nontype_argument (tree type, tree expr)
4211 /* Detect immediately string literals as invalid non-type argument.
4212 This special-case is not needed for correctness (we would easily
4213 catch this later), but only to provide better diagnostic for this
4214 common user mistake. As suggested by DR 100, we do not mention
4215 linkage issues in the diagnostic as this is not the point. */
4216 if (TREE_CODE (expr) == STRING_CST)
4218 error ("%qE is not a valid template argument for type %qT "
4219 "because string literals can never be used in this context",
4224 /* If we are in a template, EXPR may be non-dependent, but still
4225 have a syntactic, rather than semantic, form. For example, EXPR
4226 might be a SCOPE_REF, rather than the VAR_DECL to which the
4227 SCOPE_REF refers. Preserving the qualifying scope is necessary
4228 so that access checking can be performed when the template is
4229 instantiated -- but here we need the resolved form so that we can
4230 convert the argument. */
4231 expr = fold_non_dependent_expr (expr);
4232 if (error_operand_p (expr))
4233 return error_mark_node;
4234 expr_type = TREE_TYPE (expr);
4236 /* HACK: Due to double coercion, we can get a
4237 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
4238 which is the tree that we built on the first call (see
4239 below when coercing to reference to object or to reference to
4240 function). We just strip everything and get to the arg.
4241 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
4243 if (TREE_CODE (expr) == NOP_EXPR)
4245 if (TYPE_REF_OBJ_P (type) || TYPE_REFFN_P (type))
4247 /* ??? Maybe we could use convert_from_reference here, but we
4248 would need to relax its constraints because the NOP_EXPR
4249 could actually change the type to something more cv-qualified,
4250 and this is not folded by convert_from_reference. */
4251 tree addr = TREE_OPERAND (expr, 0);
4252 gcc_assert (TREE_CODE (expr_type) == REFERENCE_TYPE);
4253 gcc_assert (TREE_CODE (addr) == ADDR_EXPR);
4254 gcc_assert (TREE_CODE (TREE_TYPE (addr)) == POINTER_TYPE);
4255 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4256 (TREE_TYPE (expr_type),
4257 TREE_TYPE (TREE_TYPE (addr))));
4259 expr = TREE_OPERAND (addr, 0);
4260 expr_type = TREE_TYPE (expr);
4263 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
4264 parameter is a pointer to object, through decay and
4265 qualification conversion. Let's strip everything. */
4266 else if (TYPE_PTROBV_P (type))
4269 gcc_assert (TREE_CODE (expr) == ADDR_EXPR);
4270 gcc_assert (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE);
4271 /* Skip the ADDR_EXPR only if it is part of the decay for
4272 an array. Otherwise, it is part of the original argument
4273 in the source code. */
4274 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == ARRAY_TYPE)
4275 expr = TREE_OPERAND (expr, 0);
4276 expr_type = TREE_TYPE (expr);
4280 /* [temp.arg.nontype]/5, bullet 1
4282 For a non-type template-parameter of integral or enumeration type,
4283 integral promotions (_conv.prom_) and integral conversions
4284 (_conv.integral_) are applied. */
4285 if (INTEGRAL_TYPE_P (type))
4287 if (!INTEGRAL_TYPE_P (expr_type))
4288 return error_mark_node;
4290 expr = fold_decl_constant_value (expr);
4291 /* Notice that there are constant expressions like '4 % 0' which
4292 do not fold into integer constants. */
4293 if (TREE_CODE (expr) != INTEGER_CST)
4295 error ("%qE is not a valid template argument for type %qT "
4296 "because it is a non-constant expression", expr, type);
4300 /* At this point, an implicit conversion does what we want,
4301 because we already know that the expression is of integral
4303 expr = ocp_convert (type, expr, CONV_IMPLICIT, LOOKUP_PROTECT);
4304 if (expr == error_mark_node)
4305 return error_mark_node;
4307 /* Conversion was allowed: fold it to a bare integer constant. */
4310 /* [temp.arg.nontype]/5, bullet 2
4312 For a non-type template-parameter of type pointer to object,
4313 qualification conversions (_conv.qual_) and the array-to-pointer
4314 conversion (_conv.array_) are applied. */
4315 else if (TYPE_PTROBV_P (type))
4317 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
4319 A template-argument for a non-type, non-template template-parameter
4320 shall be one of: [...]
4322 -- the name of a non-type template-parameter;
4323 -- the address of an object or function with external linkage, [...]
4324 expressed as "& id-expression" where the & is optional if the name
4325 refers to a function or array, or if the corresponding
4326 template-parameter is a reference.
4328 Here, we do not care about functions, as they are invalid anyway
4329 for a parameter of type pointer-to-object. */
4331 if (DECL_P (expr) && DECL_TEMPLATE_PARM_P (expr))
4332 /* Non-type template parameters are OK. */
4334 else if (TREE_CODE (expr) != ADDR_EXPR
4335 && TREE_CODE (expr_type) != ARRAY_TYPE)
4337 if (TREE_CODE (expr) == VAR_DECL)
4339 error ("%qD is not a valid template argument "
4340 "because %qD is a variable, not the address of "
4345 /* Other values, like integer constants, might be valid
4346 non-type arguments of some other type. */
4347 return error_mark_node;
4353 decl = ((TREE_CODE (expr) == ADDR_EXPR)
4354 ? TREE_OPERAND (expr, 0) : expr);
4355 if (TREE_CODE (decl) != VAR_DECL)
4357 error ("%qE is not a valid template argument of type %qT "
4358 "because %qE is not a variable",
4362 else if (!DECL_EXTERNAL_LINKAGE_P (decl))
4364 error ("%qE is not a valid template argument of type %qT "
4365 "because %qD does not have external linkage",
4371 expr = decay_conversion (expr);
4372 if (expr == error_mark_node)
4373 return error_mark_node;
4375 expr = perform_qualification_conversions (type, expr);
4376 if (expr == error_mark_node)
4377 return error_mark_node;
4379 /* [temp.arg.nontype]/5, bullet 3
4381 For a non-type template-parameter of type reference to object, no
4382 conversions apply. The type referred to by the reference may be more
4383 cv-qualified than the (otherwise identical) type of the
4384 template-argument. The template-parameter is bound directly to the
4385 template-argument, which must be an lvalue. */
4386 else if (TYPE_REF_OBJ_P (type))
4388 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type),
4390 return error_mark_node;
4392 if (!at_least_as_qualified_p (TREE_TYPE (type), expr_type))
4394 error ("%qE is not a valid template argument for type %qT "
4395 "because of conflicts in cv-qualification", expr, type);
4399 if (!real_lvalue_p (expr))
4401 error ("%qE is not a valid template argument for type %qT "
4402 "because it is not an lvalue", expr, type);
4406 /* [temp.arg.nontype]/1
4408 A template-argument for a non-type, non-template template-parameter
4409 shall be one of: [...]
4411 -- the address of an object or function with external linkage. */
4412 if (!DECL_EXTERNAL_LINKAGE_P (expr))
4414 error ("%qE is not a valid template argument for type %qT "
4415 "because object %qD has not external linkage",
4420 expr = build_nop (type, build_address (expr));
4422 /* [temp.arg.nontype]/5, bullet 4
4424 For a non-type template-parameter of type pointer to function, only
4425 the function-to-pointer conversion (_conv.func_) is applied. If the
4426 template-argument represents a set of overloaded functions (or a
4427 pointer to such), the matching function is selected from the set
4429 else if (TYPE_PTRFN_P (type))
4431 /* If the argument is a template-id, we might not have enough
4432 context information to decay the pointer. */
4433 if (!type_unknown_p (expr_type))
4435 expr = decay_conversion (expr);
4436 if (expr == error_mark_node)
4437 return error_mark_node;
4440 expr = convert_nontype_argument_function (type, expr);
4441 if (!expr || expr == error_mark_node)
4444 /* [temp.arg.nontype]/5, bullet 5
4446 For a non-type template-parameter of type reference to function, no
4447 conversions apply. If the template-argument represents a set of
4448 overloaded functions, the matching function is selected from the set
4450 else if (TYPE_REFFN_P (type))
4452 if (TREE_CODE (expr) == ADDR_EXPR)
4454 error ("%qE is not a valid template argument for type %qT "
4455 "because it is a pointer", expr, type);
4456 inform ("try using %qE instead", TREE_OPERAND (expr, 0));
4460 expr = convert_nontype_argument_function (TREE_TYPE (type), expr);
4461 if (!expr || expr == error_mark_node)
4464 expr = build_nop (type, build_address (expr));
4466 /* [temp.arg.nontype]/5, bullet 6
4468 For a non-type template-parameter of type pointer to member function,
4469 no conversions apply. If the template-argument represents a set of
4470 overloaded member functions, the matching member function is selected
4471 from the set (_over.over_). */
4472 else if (TYPE_PTRMEMFUNC_P (type))
4474 expr = instantiate_type (type, expr, tf_none);
4475 if (expr == error_mark_node)
4476 return error_mark_node;
4478 /* There is no way to disable standard conversions in
4479 resolve_address_of_overloaded_function (called by
4480 instantiate_type). It is possible that the call succeeded by
4481 converting &B::I to &D::I (where B is a base of D), so we need
4482 to reject this conversion here.
4484 Actually, even if there was a way to disable standard conversions,
4485 it would still be better to reject them here so that we can
4486 provide a superior diagnostic. */
4487 if (!same_type_p (TREE_TYPE (expr), type))
4489 /* Make sure we are just one standard conversion off. */
4490 gcc_assert (can_convert (type, TREE_TYPE (expr)));
4491 error ("%qE is not a valid template argument for type %qT "
4492 "because it is of type %qT", expr, type,
4494 inform ("standard conversions are not allowed in this context");
4498 /* [temp.arg.nontype]/5, bullet 7
4500 For a non-type template-parameter of type pointer to data member,
4501 qualification conversions (_conv.qual_) are applied. */
4502 else if (TYPE_PTRMEM_P (type))
4504 expr = perform_qualification_conversions (type, expr);
4505 if (expr == error_mark_node)
4508 /* A template non-type parameter must be one of the above. */
4512 /* Sanity check: did we actually convert the argument to the
4514 gcc_assert (same_type_p (type, TREE_TYPE (expr)));
4519 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
4520 template template parameters. Both PARM_PARMS and ARG_PARMS are
4521 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
4524 Consider the example:
4525 template <class T> class A;
4526 template<template <class U> class TT> class B;
4528 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
4529 the parameters to A, and OUTER_ARGS contains A. */
4532 coerce_template_template_parms (tree parm_parms,
4534 tsubst_flags_t complain,
4538 int nparms, nargs, i;
4541 gcc_assert (TREE_CODE (parm_parms) == TREE_VEC);
4542 gcc_assert (TREE_CODE (arg_parms) == TREE_VEC);
4544 nparms = TREE_VEC_LENGTH (parm_parms);
4545 nargs = TREE_VEC_LENGTH (arg_parms);
4547 if (nargs != nparms)
4550 for (i = 0; i < nparms; ++i)
4552 if (TREE_VEC_ELT (parm_parms, i) == error_mark_node
4553 || TREE_VEC_ELT (arg_parms, i) == error_mark_node)
4556 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
4557 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
4559 if (arg == NULL_TREE || arg == error_mark_node
4560 || parm == NULL_TREE || parm == error_mark_node)
4563 if (TREE_CODE (arg) != TREE_CODE (parm))
4566 switch (TREE_CODE (parm))
4569 /* We encounter instantiations of templates like
4570 template <template <template <class> class> class TT>
4573 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
4574 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
4576 if (!coerce_template_template_parms
4577 (parmparm, argparm, complain, in_decl, outer_args))
4583 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm))
4584 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg)))
4585 /* One is a parameter pack, the other is not. */
4590 /* The tsubst call is used to handle cases such as
4592 template <int> class C {};
4593 template <class T, template <T> class TT> class D {};
4596 i.e. the parameter list of TT depends on earlier parameters. */
4597 if (!dependent_type_p (TREE_TYPE (arg))
4599 (tsubst (TREE_TYPE (parm), outer_args, complain, in_decl),
4603 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm))
4604 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg)))
4605 /* One is a parameter pack, the other is not. */
4616 /* Convert the indicated template ARG as necessary to match the
4617 indicated template PARM. Returns the converted ARG, or
4618 error_mark_node if the conversion was unsuccessful. Error and
4619 warning messages are issued under control of COMPLAIN. This
4620 conversion is for the Ith parameter in the parameter list. ARGS is
4621 the full set of template arguments deduced so far. */
4624 convert_template_argument (tree parm,
4627 tsubst_flags_t complain,
4632 int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
4633 tree check_arg = arg;
4635 if (TREE_CODE (arg) == TREE_LIST
4636 && TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF)
4638 /* The template argument was the name of some
4639 member function. That's usually
4640 invalid, but static members are OK. In any
4641 case, grab the underlying fields/functions
4642 and issue an error later if required. */
4643 arg = TREE_VALUE (arg);
4644 TREE_TYPE (arg) = unknown_type_node;
4647 requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
4648 requires_type = (TREE_CODE (parm) == TYPE_DECL
4649 || requires_tmpl_type);
4651 /* When determining whether a argument pack expansion is a template,
4652 look at the pattern. */
4653 if (TREE_CODE (check_arg) == TYPE_PACK_EXPANSION)
4654 check_arg = PACK_EXPANSION_PATTERN (check_arg);
4657 ((TREE_CODE (check_arg) == TEMPLATE_DECL
4658 && TREE_CODE (DECL_TEMPLATE_RESULT (check_arg)) == TYPE_DECL)
4659 || TREE_CODE (check_arg) == TEMPLATE_TEMPLATE_PARM
4660 || TREE_CODE (check_arg) == UNBOUND_CLASS_TEMPLATE);
4663 && (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4664 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE))
4665 arg = TYPE_STUB_DECL (arg);
4667 is_type = TYPE_P (arg) || is_tmpl_type;
4669 if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
4670 && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
4672 pedwarn ("to refer to a type member of a template parameter, "
4673 "use %<typename %E%>", arg);
4675 arg = make_typename_type (TREE_OPERAND (arg, 0),
4676 TREE_OPERAND (arg, 1),
4678 complain & tf_error);
4681 if (is_type != requires_type)
4685 if (complain & tf_error)
4687 error ("type/value mismatch at argument %d in template "
4688 "parameter list for %qD",
4691 error (" expected a constant of type %qT, got %qT",
4693 (is_tmpl_type ? DECL_NAME (arg) : arg));
4694 else if (requires_tmpl_type)
4695 error (" expected a class template, got %qE", arg);
4697 error (" expected a type, got %qE", arg);
4700 return error_mark_node;
4702 if (is_tmpl_type ^ requires_tmpl_type)
4704 if (in_decl && (complain & tf_error))
4706 error ("type/value mismatch at argument %d in template "
4707 "parameter list for %qD",
4710 error (" expected a type, got %qT", DECL_NAME (arg));
4712 error (" expected a class template, got %qT", arg);
4714 return error_mark_node;
4719 if (requires_tmpl_type)
4721 if (TREE_CODE (TREE_TYPE (arg)) == UNBOUND_CLASS_TEMPLATE)
4722 /* The number of argument required is not known yet.
4723 Just accept it for now. */
4724 val = TREE_TYPE (arg);
4727 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
4731 /* When determining whether a pack expansion is a template,
4732 look at the pattern. */
4733 if (TREE_CODE (check_arg) == TYPE_PACK_EXPANSION)
4734 check_arg = PACK_EXPANSION_PATTERN (check_arg);
4736 argparm = DECL_INNERMOST_TEMPLATE_PARMS (check_arg);
4738 if (coerce_template_template_parms (parmparm, argparm,
4744 /* TEMPLATE_TEMPLATE_PARM node is preferred over
4746 if (val != error_mark_node)
4748 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val))
4749 val = TREE_TYPE (val);
4750 else if (TREE_CODE (val) == TYPE_PACK_EXPANSION
4751 && DECL_TEMPLATE_TEMPLATE_PARM_P (check_arg))
4753 val = TREE_TYPE (check_arg);
4754 val = make_pack_expansion (val);
4760 if (in_decl && (complain & tf_error))
4762 error ("type/value mismatch at argument %d in "
4763 "template parameter list for %qD",
4765 error (" expected a template of type %qD, got %qD",
4769 val = error_mark_node;
4775 /* We only form one instance of each template specialization.
4776 Therefore, if we use a non-canonical variant (i.e., a
4777 typedef), any future messages referring to the type will use
4778 the typedef, which is confusing if those future uses do not
4779 themselves also use the typedef. */
4781 val = canonical_type_variant (val);
4785 tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl);
4787 if (invalid_nontype_parm_type_p (t, complain))
4788 return error_mark_node;
4790 if (!uses_template_parms (arg) && !uses_template_parms (t))
4791 /* We used to call digest_init here. However, digest_init
4792 will report errors, which we don't want when complain
4793 is zero. More importantly, digest_init will try too
4794 hard to convert things: for example, `0' should not be
4795 converted to pointer type at this point according to
4796 the standard. Accepting this is not merely an
4797 extension, since deciding whether or not these
4798 conversions can occur is part of determining which
4799 function template to call, or whether a given explicit
4800 argument specification is valid. */
4801 val = convert_nontype_argument (t, arg);
4805 if (val == NULL_TREE)
4806 val = error_mark_node;
4807 else if (val == error_mark_node && (complain & tf_error))
4808 error ("could not convert template argument %qE to %qT", arg, t);
4814 /* Coerces the remaining template arguments in INNER_ARGS (from
4815 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
4816 Returns the coerced argument pack. PARM_IDX is the position of this
4817 parameter in the template parameter list. ARGS is the original
4818 template argument list. */
4820 coerce_template_parameter_pack (tree parms,
4828 tsubst_flags_t complain)
4830 tree parm = TREE_VEC_ELT (parms, parm_idx);
4831 int nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
4834 tree packed_types = NULL_TREE;
4836 if (arg_idx > nargs)
4839 packed_args = make_tree_vec (nargs - arg_idx);
4841 if (TREE_CODE (TREE_VALUE (parm)) == PARM_DECL
4842 && uses_parameter_packs (TREE_TYPE (TREE_VALUE (parm))))
4844 /* When the template parameter is a non-type template
4845 parameter pack whose type uses parameter packs, we need
4846 to look at each of the template arguments
4847 separately. Build a vector of the types for these
4848 non-type template parameters in PACKED_TYPES. */
4850 = make_pack_expansion (TREE_TYPE (TREE_VALUE (parm)));
4851 packed_types = tsubst_pack_expansion (expansion, args,
4854 if (packed_types == error_mark_node)
4855 return error_mark_node;
4857 /* Check that we have the right number of arguments. */
4859 && !PACK_EXPANSION_P (TREE_VEC_ELT (inner_args, arg_idx))
4860 && nargs - arg_idx != TREE_VEC_LENGTH (packed_types))
4863 = TREE_VEC_LENGTH (parms) - 1 + TREE_VEC_LENGTH (packed_types);
4864 error ("wrong number of template arguments (%d, should be %d)",
4865 nargs, needed_parms);
4866 return error_mark_node;
4869 /* If we aren't able to check the actual arguments now
4870 (because they haven't been expanded yet), we can at least
4871 verify that all of the types used for the non-type
4872 template parameter pack are, in fact, valid for non-type
4873 template parameters. */
4875 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args, arg_idx)))
4877 int j, len = TREE_VEC_LENGTH (packed_types);
4878 for (j = 0; j < len; ++j)
4880 tree t = TREE_VEC_ELT (packed_types, j);
4881 if (invalid_nontype_parm_type_p (t, complain))
4882 return error_mark_node;
4887 /* Convert the remaining arguments, which will be a part of the
4888 parameter pack "parm". */
4889 for (; arg_idx < nargs; ++arg_idx)
4891 tree arg = TREE_VEC_ELT (inner_args, arg_idx);
4892 tree actual_parm = TREE_VALUE (parm);
4894 if (packed_types && !PACK_EXPANSION_P (arg))
4896 /* When we have a vector of types (corresponding to the
4897 non-type template parameter pack that uses parameter
4898 packs in its type, as mention above), and the
4899 argument is not an expansion (which expands to a
4900 currently unknown number of arguments), clone the
4901 parm and give it the next type in PACKED_TYPES. */
4902 actual_parm = copy_node (actual_parm);
4903 TREE_TYPE (actual_parm) =
4904 TREE_VEC_ELT (packed_types, arg_idx - parm_idx);
4907 arg = convert_template_argument (actual_parm,
4908 arg, new_args, complain, parm_idx,
4910 if (arg == error_mark_node)
4912 TREE_VEC_ELT (packed_args, arg_idx - parm_idx) = arg;
4915 if (TREE_CODE (TREE_VALUE (parm)) == TYPE_DECL
4916 || TREE_CODE (TREE_VALUE (parm)) == TEMPLATE_DECL)
4917 argument_pack = make_node (TYPE_ARGUMENT_PACK);
4920 argument_pack = make_node (NONTYPE_ARGUMENT_PACK);
4921 TREE_TYPE (argument_pack) = TREE_TYPE (TREE_VALUE (parm));
4922 TREE_CONSTANT (argument_pack) = 1;
4925 SET_ARGUMENT_PACK_ARGS (argument_pack, packed_args);
4926 return argument_pack;
4929 /* Convert all template arguments to their appropriate types, and
4930 return a vector containing the innermost resulting template
4931 arguments. If any error occurs, return error_mark_node. Error and
4932 warning messages are issued under control of COMPLAIN.
4934 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
4935 for arguments not specified in ARGS. Otherwise, if
4936 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
4937 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
4938 USE_DEFAULT_ARGS is false, then all arguments must be specified in
4942 coerce_template_parms (tree parms,
4945 tsubst_flags_t complain,
4946 bool require_all_args,
4947 bool use_default_args)
4949 int nparms, nargs, parm_idx, arg_idx, lost = 0;
4952 tree new_inner_args;
4953 bool saved_skip_evaluation;
4955 /* When used as a boolean value, indicates whether this is a
4956 variadic template parameter list. Since it's an int, we can also
4957 subtract it from nparms to get the number of non-variadic
4962 = expand_template_argument_pack (INNERMOST_TEMPLATE_ARGS (args));
4964 nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
4965 nparms = TREE_VEC_LENGTH (parms);
4967 /* Determine if there are any parameter packs. */
4968 for (parm_idx = 0; parm_idx < nparms; ++parm_idx)
4970 tree tparm = TREE_VALUE (TREE_VEC_ELT (parms, parm_idx));
4971 if (template_parameter_pack_p (tparm))
4978 if ((nargs > nparms - variadic_p && !variadic_p)
4979 || (nargs < nparms - variadic_p
4981 && (!use_default_args
4982 || (TREE_VEC_ELT (parms, nargs) != error_mark_node
4983 && !TREE_PURPOSE (TREE_VEC_ELT (parms, nargs))))))
4985 if (complain & tf_error)
4987 const char *or_more = "";
4990 or_more = " or more";
4994 error ("wrong number of template arguments (%d, should be %d%s)",
4995 nargs, nparms, or_more);
4998 error ("provided for %q+D", in_decl);
5001 return error_mark_node;
5004 /* We need to evaluate the template arguments, even though this
5005 template-id may be nested within a "sizeof". */
5006 saved_skip_evaluation = skip_evaluation;
5007 skip_evaluation = false;
5008 new_inner_args = make_tree_vec (nparms);
5009 new_args = add_outermost_template_args (args, new_inner_args);
5010 for (parm_idx = 0, arg_idx = 0; parm_idx < nparms; parm_idx++, arg_idx++)
5015 /* Get the Ith template parameter. */
5016 parm = TREE_VEC_ELT (parms, parm_idx);
5018 if (parm == error_mark_node)
5020 TREE_VEC_ELT (new_inner_args, arg_idx) = error_mark_node;
5024 /* Calculate the next argument. */
5025 if (template_parameter_pack_p (TREE_VALUE (parm)))
5027 /* All remaining arguments will be placed in the
5028 template parameter pack PARM. */
5029 arg = coerce_template_parameter_pack (parms, parm_idx, args,
5030 inner_args, arg_idx,
5034 /* Store this argument. */
5035 if (arg == error_mark_node)
5037 TREE_VEC_ELT (new_inner_args, parm_idx) = arg;
5039 /* We are done with all of the arguments. */
5044 else if (arg_idx < nargs)
5046 arg = TREE_VEC_ELT (inner_args, arg_idx);
5048 if (arg && PACK_EXPANSION_P (arg))
5050 /* If ARG is a pack expansion, but PARM is not a
5051 template parameter pack (if it were, we would have
5052 handled it above), we're trying to expand into a
5053 fixed-length argument list. */
5054 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
5055 error ("cannot expand %<%E%> into a fixed-length "
5056 "argument list", arg);
5058 error ("cannot expand %<%T%> into a fixed-length "
5059 "argument list", arg);
5062 else if (require_all_args)
5063 /* There must be a default arg in this case. */
5064 arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
5069 if (arg == error_mark_node)
5071 if (complain & tf_error)
5072 error ("template argument %d is invalid", arg_idx + 1);
5075 /* This only occurs if there was an error in the template
5076 parameter list itself (which we would already have
5077 reported) that we are trying to recover from, e.g., a class
5078 template with a parameter list such as
5079 template<typename..., typename>. */
5080 return error_mark_node;
5082 arg = convert_template_argument (TREE_VALUE (parm),
5083 arg, new_args, complain,
5086 if (arg == error_mark_node)
5088 TREE_VEC_ELT (new_inner_args, arg_idx) = arg;
5090 skip_evaluation = saved_skip_evaluation;
5093 return error_mark_node;
5095 return new_inner_args;
5098 /* Returns 1 if template args OT and NT are equivalent. */
5101 template_args_equal (tree ot, tree nt)
5106 if (TREE_CODE (nt) == TREE_VEC)
5107 /* For member templates */
5108 return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt);
5109 else if (PACK_EXPANSION_P (ot))
5110 return PACK_EXPANSION_P (nt)
5111 && template_args_equal (PACK_EXPANSION_PATTERN (ot),
5112 PACK_EXPANSION_PATTERN (nt));
5113 else if (TYPE_P (nt))
5114 return TYPE_P (ot) && same_type_p (ot, nt);
5115 else if (TREE_CODE (ot) == TREE_VEC || TYPE_P (ot))
5118 return cp_tree_equal (ot, nt);
5121 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
5122 of template arguments. Returns 0 otherwise. */
5125 comp_template_args (tree oldargs, tree newargs)
5129 oldargs = expand_template_argument_pack (oldargs);
5130 newargs = expand_template_argument_pack (newargs);
5132 if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
5135 for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
5137 tree nt = TREE_VEC_ELT (newargs, i);
5138 tree ot = TREE_VEC_ELT (oldargs, i);
5140 if (! template_args_equal (ot, nt))
5147 add_pending_template (tree d)
5149 tree ti = (TYPE_P (d)
5150 ? CLASSTYPE_TEMPLATE_INFO (d)
5151 : DECL_TEMPLATE_INFO (d));
5155 if (TI_PENDING_TEMPLATE_FLAG (ti))
5158 /* We are called both from instantiate_decl, where we've already had a
5159 tinst_level pushed, and instantiate_template, where we haven't.
5161 level = !(current_tinst_level && TINST_DECL (current_tinst_level) == d);
5164 push_tinst_level (d);
5166 pt = tree_cons (current_tinst_level, d, NULL_TREE);
5167 if (last_pending_template)
5168 TREE_CHAIN (last_pending_template) = pt;
5170 pending_templates = pt;
5172 last_pending_template = pt;
5174 TI_PENDING_TEMPLATE_FLAG (ti) = 1;
5181 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
5182 ARGLIST. Valid choices for FNS are given in the cp-tree.def
5183 documentation for TEMPLATE_ID_EXPR. */
5186 lookup_template_function (tree fns, tree arglist)
5190 if (fns == error_mark_node || arglist == error_mark_node)
5191 return error_mark_node;
5193 gcc_assert (!arglist || TREE_CODE (arglist) == TREE_VEC);
5194 gcc_assert (fns && (is_overloaded_fn (fns)
5195 || TREE_CODE (fns) == IDENTIFIER_NODE));
5197 if (BASELINK_P (fns))
5199 BASELINK_FUNCTIONS (fns) = build2 (TEMPLATE_ID_EXPR,
5201 BASELINK_FUNCTIONS (fns),
5206 type = TREE_TYPE (fns);
5207 if (TREE_CODE (fns) == OVERLOAD || !type)
5208 type = unknown_type_node;
5210 return build2 (TEMPLATE_ID_EXPR, type, fns, arglist);
5213 /* Within the scope of a template class S<T>, the name S gets bound
5214 (in build_self_reference) to a TYPE_DECL for the class, not a
5215 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
5216 or one of its enclosing classes, and that type is a template,
5217 return the associated TEMPLATE_DECL. Otherwise, the original
5218 DECL is returned. */
5221 maybe_get_template_decl_from_type_decl (tree decl)
5223 return (decl != NULL_TREE
5224 && TREE_CODE (decl) == TYPE_DECL
5225 && DECL_ARTIFICIAL (decl)
5226 && CLASS_TYPE_P (TREE_TYPE (decl))
5227 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
5228 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl;
5231 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
5232 parameters, find the desired type.
5234 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
5236 IN_DECL, if non-NULL, is the template declaration we are trying to
5239 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
5240 the class we are looking up.
5242 Issue error and warning messages under control of COMPLAIN.
5244 If the template class is really a local class in a template
5245 function, then the FUNCTION_CONTEXT is the function in which it is
5248 ??? Note that this function is currently called *twice* for each
5249 template-id: the first time from the parser, while creating the
5250 incomplete type (finish_template_type), and the second type during the
5251 real instantiation (instantiate_template_class). This is surely something
5252 that we want to avoid. It also causes some problems with argument
5253 coercion (see convert_nontype_argument for more information on this). */
5256 lookup_template_class (tree d1,
5261 tsubst_flags_t complain)
5263 tree template = NULL_TREE, parmlist;
5266 timevar_push (TV_NAME_LOOKUP);
5268 if (TREE_CODE (d1) == IDENTIFIER_NODE)
5270 tree value = innermost_non_namespace_value (d1);
5271 if (value && DECL_TEMPLATE_TEMPLATE_PARM_P (value))
5276 push_decl_namespace (context);
5277 template = lookup_name (d1);
5278 template = maybe_get_template_decl_from_type_decl (template);
5280 pop_decl_namespace ();
5283 context = DECL_CONTEXT (template);
5285 else if (TREE_CODE (d1) == TYPE_DECL && IS_AGGR_TYPE (TREE_TYPE (d1)))
5287 tree type = TREE_TYPE (d1);
5289 /* If we are declaring a constructor, say A<T>::A<T>, we will get
5290 an implicit typename for the second A. Deal with it. */
5291 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5292 type = TREE_TYPE (type);
5294 if (CLASSTYPE_TEMPLATE_INFO (type))
5296 template = CLASSTYPE_TI_TEMPLATE (type);
5297 d1 = DECL_NAME (template);
5300 else if (TREE_CODE (d1) == ENUMERAL_TYPE
5301 || (TYPE_P (d1) && IS_AGGR_TYPE (d1)))
5303 template = TYPE_TI_TEMPLATE (d1);
5304 d1 = DECL_NAME (template);
5306 else if (TREE_CODE (d1) == TEMPLATE_DECL
5307 && TREE_CODE (DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL)
5310 d1 = DECL_NAME (template);
5311 context = DECL_CONTEXT (template);
5314 /* Issue an error message if we didn't find a template. */
5317 if (complain & tf_error)
5318 error ("%qT is not a template", d1);
5319 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5322 if (TREE_CODE (template) != TEMPLATE_DECL
5323 /* Make sure it's a user visible template, if it was named by
5325 || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (template)
5326 && !PRIMARY_TEMPLATE_P (template)))
5328 if (complain & tf_error)
5330 error ("non-template type %qT used as a template", d1);
5332 error ("for template declaration %q+D", in_decl);
5334 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5337 complain &= ~tf_user;
5339 if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
5341 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
5342 template arguments */
5347 parmlist = DECL_INNERMOST_TEMPLATE_PARMS (template);
5349 /* Consider an example where a template template parameter declared as
5351 template <class T, class U = std::allocator<T> > class TT
5353 The template parameter level of T and U are one level larger than
5354 of TT. To proper process the default argument of U, say when an
5355 instantiation `TT<int>' is seen, we need to build the full
5356 arguments containing {int} as the innermost level. Outer levels,
5357 available when not appearing as default template argument, can be
5358 obtained from `current_template_args ()'.
5360 Suppose that TT is later substituted with std::vector. The above
5361 instantiation is `TT<int, std::allocator<T> >' with TT at
5362 level 1, and T at level 2, while the template arguments at level 1
5363 becomes {std::vector} and the inner level 2 is {int}. */
5365 if (current_template_parms)
5366 arglist = add_to_template_args (current_template_args (), arglist);
5368 arglist2 = coerce_template_parms (parmlist, arglist, template,
5370 /*require_all_args=*/true,
5371 /*use_default_args=*/true);
5372 if (arglist2 == error_mark_node
5373 || (!uses_template_parms (arglist2)
5374 && check_instantiated_args (template, arglist2, complain)))
5375 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5377 parm = bind_template_template_parm (TREE_TYPE (template), arglist2);
5378 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, parm);
5382 tree template_type = TREE_TYPE (template);
5385 tree found = NULL_TREE;
5388 int is_partial_instantiation;
5390 gen_tmpl = most_general_template (template);
5391 parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
5392 parm_depth = TMPL_PARMS_DEPTH (parmlist);
5393 arg_depth = TMPL_ARGS_DEPTH (arglist);
5395 if (arg_depth == 1 && parm_depth > 1)
5397 /* We've been given an incomplete set of template arguments.
5400 template <class T> struct S1 {
5401 template <class U> struct S2 {};
5402 template <class U> struct S2<U*> {};
5405 we will be called with an ARGLIST of `U*', but the
5406 TEMPLATE will be `template <class T> template
5407 <class U> struct S1<T>::S2'. We must fill in the missing
5410 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)),
5412 arg_depth = TMPL_ARGS_DEPTH (arglist);
5415 /* Now we should have enough arguments. */
5416 gcc_assert (parm_depth == arg_depth);
5418 /* From here on, we're only interested in the most general
5420 template = gen_tmpl;
5422 /* Calculate the BOUND_ARGS. These will be the args that are
5423 actually tsubst'd into the definition to create the
5427 /* We have multiple levels of arguments to coerce, at once. */
5429 int saved_depth = TMPL_ARGS_DEPTH (arglist);
5431 tree bound_args = make_tree_vec (parm_depth);
5433 for (i = saved_depth,
5434 t = DECL_TEMPLATE_PARMS (template);
5435 i > 0 && t != NULL_TREE;
5436 --i, t = TREE_CHAIN (t))
5438 tree a = coerce_template_parms (TREE_VALUE (t),
5441 /*require_all_args=*/true,
5442 /*use_default_args=*/true);
5444 /* Don't process further if one of the levels fails. */
5445 if (a == error_mark_node)
5447 /* Restore the ARGLIST to its full size. */
5448 TREE_VEC_LENGTH (arglist) = saved_depth;
5449 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5452 SET_TMPL_ARGS_LEVEL (bound_args, i, a);
5454 /* We temporarily reduce the length of the ARGLIST so
5455 that coerce_template_parms will see only the arguments
5456 corresponding to the template parameters it is
5458 TREE_VEC_LENGTH (arglist)--;
5461 /* Restore the ARGLIST to its full size. */
5462 TREE_VEC_LENGTH (arglist) = saved_depth;
5464 arglist = bound_args;
5468 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist),
5469 INNERMOST_TEMPLATE_ARGS (arglist),
5472 /*require_all_args=*/true,
5473 /*use_default_args=*/true);
5475 if (arglist == error_mark_node)
5476 /* We were unable to bind the arguments. */
5477 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5479 /* In the scope of a template class, explicit references to the
5480 template class refer to the type of the template, not any
5481 instantiation of it. For example, in:
5483 template <class T> class C { void f(C<T>); }
5485 the `C<T>' is just the same as `C'. Outside of the
5486 class, however, such a reference is an instantiation. */
5487 if (comp_template_args (TYPE_TI_ARGS (template_type),
5490 found = template_type;
5492 if (!entering_scope && PRIMARY_TEMPLATE_P (template))
5496 for (ctx = current_class_type;
5497 ctx && TREE_CODE (ctx) != NAMESPACE_DECL;
5499 ? TYPE_CONTEXT (ctx)
5500 : DECL_CONTEXT (ctx)))
5501 if (TYPE_P (ctx) && same_type_p (ctx, template_type))
5504 /* We're not in the scope of the class, so the
5505 TEMPLATE_TYPE is not the type we want after all. */
5511 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
5513 /* If we already have this specialization, return it. */
5514 found = retrieve_specialization (template, arglist,
5515 /*class_specializations_p=*/false);
5517 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
5519 /* This type is a "partial instantiation" if any of the template
5520 arguments still involve template parameters. Note that we set
5521 IS_PARTIAL_INSTANTIATION for partial specializations as
5523 is_partial_instantiation = uses_template_parms (arglist);
5525 /* If the deduced arguments are invalid, then the binding
5527 if (!is_partial_instantiation
5528 && check_instantiated_args (template,
5529 INNERMOST_TEMPLATE_ARGS (arglist),
5531 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5533 if (!is_partial_instantiation
5534 && !PRIMARY_TEMPLATE_P (template)
5535 && TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL)
5537 found = xref_tag_from_type (TREE_TYPE (template),
5538 DECL_NAME (template),
5539 /*tag_scope=*/ts_global);
5540 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
5543 context = tsubst (DECL_CONTEXT (template), arglist,
5546 context = global_namespace;
5548 /* Create the type. */
5549 if (TREE_CODE (template_type) == ENUMERAL_TYPE)
5551 if (!is_partial_instantiation)
5553 set_current_access_from_decl (TYPE_NAME (template_type));
5554 t = start_enum (TYPE_IDENTIFIER (template_type));
5557 /* We don't want to call start_enum for this type, since
5558 the values for the enumeration constants may involve
5559 template parameters. And, no one should be interested
5560 in the enumeration constants for such a type. */
5561 t = make_node (ENUMERAL_TYPE);
5565 t = make_aggr_type (TREE_CODE (template_type));
5566 CLASSTYPE_DECLARED_CLASS (t)
5567 = CLASSTYPE_DECLARED_CLASS (template_type);
5568 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
5569 TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);
5571 /* A local class. Make sure the decl gets registered properly. */
5572 if (context == current_function_decl)
5573 pushtag (DECL_NAME (template), t, /*tag_scope=*/ts_current);
5575 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type), arglist))
5576 /* This instantiation is another name for the primary
5577 template type. Set the TYPE_CANONICAL field
5579 TYPE_CANONICAL (t) = template_type;
5580 else if (any_template_arguments_need_structural_equality_p (arglist))
5581 /* Some of the template arguments require structural
5582 equality testing, so this template class requires
5583 structural equality testing. */
5584 SET_TYPE_STRUCTURAL_EQUALITY (t);
5587 /* If we called start_enum or pushtag above, this information
5588 will already be set up. */
5591 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5593 type_decl = create_implicit_typedef (DECL_NAME (template), t);
5594 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
5595 TYPE_STUB_DECL (t) = type_decl;
5596 DECL_SOURCE_LOCATION (type_decl)
5597 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type));
5600 type_decl = TYPE_NAME (t);
5602 TREE_PRIVATE (type_decl)
5603 = TREE_PRIVATE (TYPE_STUB_DECL (template_type));
5604 TREE_PROTECTED (type_decl)
5605 = TREE_PROTECTED (TYPE_STUB_DECL (template_type));
5606 DECL_IN_SYSTEM_HEADER (type_decl)
5607 = DECL_IN_SYSTEM_HEADER (template);
5608 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type))
5610 DECL_VISIBILITY_SPECIFIED (type_decl) = 1;
5611 DECL_VISIBILITY (type_decl) = CLASSTYPE_VISIBILITY (template_type);
5614 /* Set up the template information. We have to figure out which
5615 template is the immediate parent if this is a full
5617 if (parm_depth == 1 || is_partial_instantiation
5618 || !PRIMARY_TEMPLATE_P (template))
5619 /* This case is easy; there are no member templates involved. */
5623 /* This is a full instantiation of a member template. Look
5624 for a partial instantiation of which this is an instance. */
5626 for (found = DECL_TEMPLATE_INSTANTIATIONS (template);
5627 found; found = TREE_CHAIN (found))
5630 tree tmpl = CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found));
5632 /* We only want partial instantiations, here, not
5633 specializations or full instantiations. */
5634 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found))
5635 || !uses_template_parms (TREE_VALUE (found)))
5638 /* Temporarily reduce by one the number of levels in the
5639 ARGLIST and in FOUND so as to avoid comparing the
5640 last set of arguments. */
5641 TREE_VEC_LENGTH (arglist)--;
5642 TREE_VEC_LENGTH (TREE_PURPOSE (found)) --;
5644 /* See if the arguments match. If they do, then TMPL is
5645 the partial instantiation we want. */
5646 success = comp_template_args (TREE_PURPOSE (found), arglist);
5648 /* Restore the argument vectors to their full size. */
5649 TREE_VEC_LENGTH (arglist)++;
5650 TREE_VEC_LENGTH (TREE_PURPOSE (found))++;
5661 /* There was no partial instantiation. This happens
5662 where C<T> is a member template of A<T> and it's used
5665 template <typename T> struct B { A<T>::C<int> m; };
5668 Create the partial instantiation.
5670 TREE_VEC_LENGTH (arglist)--;
5671 found = tsubst (template, arglist, complain, NULL_TREE);
5672 TREE_VEC_LENGTH (arglist)++;
5676 SET_TYPE_TEMPLATE_INFO (t, tree_cons (found, arglist, NULL_TREE));
5677 DECL_TEMPLATE_INSTANTIATIONS (template)
5678 = tree_cons (arglist, t,
5679 DECL_TEMPLATE_INSTANTIATIONS (template));
5681 if (TREE_CODE (t) == ENUMERAL_TYPE
5682 && !is_partial_instantiation)
5683 /* Now that the type has been registered on the instantiations
5684 list, we set up the enumerators. Because the enumeration
5685 constants may involve the enumeration type itself, we make
5686 sure to register the type first, and then create the
5687 constants. That way, doing tsubst_expr for the enumeration
5688 constants won't result in recursive calls here; we'll find
5689 the instantiation and exit above. */
5690 tsubst_enum (template_type, t, arglist);
5692 if (is_partial_instantiation)
5693 /* If the type makes use of template parameters, the
5694 code that generates debugging information will crash. */
5695 DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1;
5697 /* Possibly limit visibility based on template args. */
5698 TREE_PUBLIC (type_decl) = 1;
5699 determine_visibility (type_decl);
5701 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
5703 timevar_pop (TV_NAME_LOOKUP);
5710 struct pointer_set_t *visited;
5713 /* Called from for_each_template_parm via walk_tree. */
5716 for_each_template_parm_r (tree *tp, int *walk_subtrees, void *d)
5719 struct pair_fn_data *pfd = (struct pair_fn_data *) d;
5720 tree_fn_t fn = pfd->fn;
5721 void *data = pfd->data;
5724 && for_each_template_parm (TYPE_CONTEXT (t), fn, data, pfd->visited))
5725 return error_mark_node;
5727 switch (TREE_CODE (t))
5730 if (TYPE_PTRMEMFUNC_P (t))
5736 if (!TYPE_TEMPLATE_INFO (t))
5738 else if (for_each_template_parm (TREE_VALUE (TYPE_TEMPLATE_INFO (t)),
5739 fn, data, pfd->visited))
5740 return error_mark_node;
5744 if (for_each_template_parm (TYPE_MIN_VALUE (t),
5745 fn, data, pfd->visited)
5746 || for_each_template_parm (TYPE_MAX_VALUE (t),
5747 fn, data, pfd->visited))
5748 return error_mark_node;
5752 /* Since we're not going to walk subtrees, we have to do this
5754 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data,
5756 return error_mark_node;
5760 /* Check the return type. */
5761 if (for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
5762 return error_mark_node;
5764 /* Check the parameter types. Since default arguments are not
5765 instantiated until they are needed, the TYPE_ARG_TYPES may
5766 contain expressions that involve template parameters. But,
5767 no-one should be looking at them yet. And, once they're
5768 instantiated, they don't contain template parameters, so
5769 there's no point in looking at them then, either. */
5773 for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm))
5774 if (for_each_template_parm (TREE_VALUE (parm), fn, data,
5776 return error_mark_node;
5778 /* Since we've already handled the TYPE_ARG_TYPES, we don't
5779 want walk_tree walking into them itself. */
5785 if (for_each_template_parm (TYPE_FIELDS (t), fn, data,
5787 return error_mark_node;
5792 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
5793 && for_each_template_parm (DECL_TI_ARGS (t), fn, data,
5795 return error_mark_node;
5800 if (TREE_CODE (t) == CONST_DECL && DECL_TEMPLATE_PARM_P (t)
5801 && for_each_template_parm (DECL_INITIAL (t), fn, data,
5803 return error_mark_node;
5804 if (DECL_CONTEXT (t)
5805 && for_each_template_parm (DECL_CONTEXT (t), fn, data,
5807 return error_mark_node;
5810 case BOUND_TEMPLATE_TEMPLATE_PARM:
5811 /* Record template parameters such as `T' inside `TT<T>'. */
5812 if (for_each_template_parm (TYPE_TI_ARGS (t), fn, data, pfd->visited))
5813 return error_mark_node;
5816 case TEMPLATE_TEMPLATE_PARM:
5817 case TEMPLATE_TYPE_PARM:
5818 case TEMPLATE_PARM_INDEX:
5819 if (fn && (*fn)(t, data))
5820 return error_mark_node;
5822 return error_mark_node;
5826 /* A template template parameter is encountered. */
5827 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)
5828 && for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited))
5829 return error_mark_node;
5831 /* Already substituted template template parameter */
5837 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t), fn,
5838 data, pfd->visited))
5839 return error_mark_node;
5843 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))
5844 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
5845 (TREE_TYPE (t)), fn, data,
5847 return error_mark_node;
5852 /* If there's no type, then this thing must be some expression
5853 involving template parameters. */
5854 if (!fn && !TREE_TYPE (t))
5855 return error_mark_node;
5860 case REINTERPRET_CAST_EXPR:
5861 case CONST_CAST_EXPR:
5862 case STATIC_CAST_EXPR:
5863 case DYNAMIC_CAST_EXPR:
5867 case PSEUDO_DTOR_EXPR:
5869 return error_mark_node;
5876 /* We didn't find any template parameters we liked. */
5880 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
5881 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
5882 call FN with the parameter and the DATA.
5883 If FN returns nonzero, the iteration is terminated, and
5884 for_each_template_parm returns 1. Otherwise, the iteration
5885 continues. If FN never returns a nonzero value, the value
5886 returned by for_each_template_parm is 0. If FN is NULL, it is
5887 considered to be the function which always returns 1. */
5890 for_each_template_parm (tree t, tree_fn_t fn, void* data,
5891 struct pointer_set_t *visited)
5893 struct pair_fn_data pfd;
5900 /* Walk the tree. (Conceptually, we would like to walk without
5901 duplicates, but for_each_template_parm_r recursively calls
5902 for_each_template_parm, so we would need to reorganize a fair
5903 bit to use walk_tree_without_duplicates, so we keep our own
5906 pfd.visited = visited;
5908 pfd.visited = pointer_set_create ();
5909 result = walk_tree (&t,
5910 for_each_template_parm_r,
5912 pfd.visited) != NULL_TREE;
5917 pointer_set_destroy (pfd.visited);
5924 /* Returns true if T depends on any template parameter. */
5927 uses_template_parms (tree t)
5930 int saved_processing_template_decl;
5932 saved_processing_template_decl = processing_template_decl;
5933 if (!saved_processing_template_decl)
5934 processing_template_decl = 1;
5936 dependent_p = dependent_type_p (t);
5937 else if (TREE_CODE (t) == TREE_VEC)
5938 dependent_p = any_dependent_template_arguments_p (t);
5939 else if (TREE_CODE (t) == TREE_LIST)
5940 dependent_p = (uses_template_parms (TREE_VALUE (t))
5941 || uses_template_parms (TREE_CHAIN (t)));
5942 else if (TREE_CODE (t) == TYPE_DECL)
5943 dependent_p = dependent_type_p (TREE_TYPE (t));
5946 || TREE_CODE (t) == TEMPLATE_PARM_INDEX
5947 || TREE_CODE (t) == OVERLOAD
5948 || TREE_CODE (t) == BASELINK
5949 || TREE_CODE (t) == IDENTIFIER_NODE
5950 || TREE_CODE (t) == TRAIT_EXPR
5951 || CONSTANT_CLASS_P (t))
5952 dependent_p = (type_dependent_expression_p (t)
5953 || value_dependent_expression_p (t));
5956 gcc_assert (t == error_mark_node);
5957 dependent_p = false;
5960 processing_template_decl = saved_processing_template_decl;
5965 /* Returns true if T depends on any template parameter with level LEVEL. */
5968 uses_template_parms_level (tree t, int level)
5970 return for_each_template_parm (t, template_parm_this_level_p, &level, NULL);
5973 static int tinst_depth;
5974 extern int max_tinst_depth;
5975 #ifdef GATHER_STATISTICS
5978 static int tinst_level_tick;
5979 static int last_template_error_tick;
5981 /* We're starting to instantiate D; record the template instantiation context
5982 for diagnostics and to restore it later. */
5985 push_tinst_level (tree d)
5989 if (tinst_depth >= max_tinst_depth)
5991 /* If the instantiation in question still has unbound template parms,
5992 we don't really care if we can't instantiate it, so just return.
5993 This happens with base instantiation for implicit `typename'. */
5994 if (uses_template_parms (d))
5997 last_template_error_tick = tinst_level_tick;
5998 error ("template instantiation depth exceeds maximum of %d (use "
5999 "-ftemplate-depth-NN to increase the maximum) instantiating %qD",
6000 max_tinst_depth, d);
6002 print_instantiation_context ();
6007 new = make_node (TINST_LEVEL);
6008 TINST_DECL (new) = d;
6009 TINST_LOCATION (new) = input_location;
6010 TINST_IN_SYSTEM_HEADER_P (new) = in_system_header;
6011 TREE_CHAIN (new) = current_tinst_level;
6012 current_tinst_level = new;
6015 #ifdef GATHER_STATISTICS
6016 if (tinst_depth > depth_reached)
6017 depth_reached = tinst_depth;
6024 /* We're done instantiating this template; return to the instantiation
6028 pop_tinst_level (void)
6030 tree old = current_tinst_level;
6032 /* Restore the filename and line number stashed away when we started
6033 this instantiation. */
6034 input_location = TINST_LOCATION (old);
6035 in_system_header = TINST_IN_SYSTEM_HEADER_P (old);
6036 current_tinst_level = TREE_CHAIN (old);
6041 /* We're instantiating a deferred template; restore the template
6042 instantiation context in which the instantiation was requested, which
6043 is one step out from LEVEL. */
6046 reopen_tinst_level (tree level)
6051 for (t = level; t; t = TREE_CHAIN (t))
6054 current_tinst_level = level;
6058 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
6059 vector of template arguments, as for tsubst.
6061 Returns an appropriate tsubst'd friend declaration. */
6064 tsubst_friend_function (tree decl, tree args)
6068 if (TREE_CODE (decl) == FUNCTION_DECL
6069 && DECL_TEMPLATE_INSTANTIATION (decl)
6070 && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
6071 /* This was a friend declared with an explicit template
6072 argument list, e.g.:
6076 to indicate that f was a template instantiation, not a new
6077 function declaration. Now, we have to figure out what
6078 instantiation of what template. */
6080 tree template_id, arglist, fns;
6083 tree ns = decl_namespace_context (TYPE_MAIN_DECL (current_class_type));
6085 /* Friend functions are looked up in the containing namespace scope.
6086 We must enter that scope, to avoid finding member functions of the
6087 current cless with same name. */
6088 push_nested_namespace (ns);
6089 fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args,
6090 tf_warning_or_error, NULL_TREE,
6091 /*integral_constant_expression_p=*/false);
6092 pop_nested_namespace (ns);
6093 arglist = tsubst (DECL_TI_ARGS (decl), args,
6094 tf_warning_or_error, NULL_TREE);
6095 template_id = lookup_template_function (fns, arglist);
6097 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
6098 tmpl = determine_specialization (template_id, new_friend,
6100 /*need_member_template=*/0,
6101 TREE_VEC_LENGTH (args),
6103 return instantiate_template (tmpl, new_args, tf_error);
6106 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
6108 /* The NEW_FRIEND will look like an instantiation, to the
6109 compiler, but is not an instantiation from the point of view of
6110 the language. For example, we might have had:
6112 template <class T> struct S {
6113 template <class U> friend void f(T, U);
6116 Then, in S<int>, template <class U> void f(int, U) is not an
6117 instantiation of anything. */
6118 if (new_friend == error_mark_node)
6119 return error_mark_node;
6121 DECL_USE_TEMPLATE (new_friend) = 0;
6122 if (TREE_CODE (decl) == TEMPLATE_DECL)
6124 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0;
6125 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend))
6126 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
6129 /* The mangled name for the NEW_FRIEND is incorrect. The function
6130 is not a template instantiation and should not be mangled like
6131 one. Therefore, we forget the mangling here; we'll recompute it
6132 later if we need it. */
6133 if (TREE_CODE (new_friend) != TEMPLATE_DECL)
6135 SET_DECL_RTL (new_friend, NULL_RTX);
6136 SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE);
6139 if (DECL_NAMESPACE_SCOPE_P (new_friend))
6142 tree new_friend_template_info;
6143 tree new_friend_result_template_info;
6145 int new_friend_is_defn;
6147 /* We must save some information from NEW_FRIEND before calling
6148 duplicate decls since that function will free NEW_FRIEND if
6150 new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
6151 new_friend_is_defn =
6152 (DECL_INITIAL (DECL_TEMPLATE_RESULT
6153 (template_for_substitution (new_friend)))
6155 if (TREE_CODE (new_friend) == TEMPLATE_DECL)
6157 /* This declaration is a `primary' template. */
6158 DECL_PRIMARY_TEMPLATE (new_friend) = new_friend;
6160 new_friend_result_template_info
6161 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend));
6164 new_friend_result_template_info = NULL_TREE;
6166 /* Make the init_value nonzero so pushdecl knows this is a defn. */
6167 if (new_friend_is_defn)
6168 DECL_INITIAL (new_friend) = error_mark_node;
6170 /* Inside pushdecl_namespace_level, we will push into the
6171 current namespace. However, the friend function should go
6172 into the namespace of the template. */
6173 ns = decl_namespace_context (new_friend);
6174 push_nested_namespace (ns);
6175 old_decl = pushdecl_namespace_level (new_friend, /*is_friend=*/true);
6176 pop_nested_namespace (ns);
6178 if (old_decl == error_mark_node)
6179 return error_mark_node;
6181 if (old_decl != new_friend)
6183 /* This new friend declaration matched an existing
6184 declaration. For example, given:
6186 template <class T> void f(T);
6187 template <class U> class C {
6188 template <class T> friend void f(T) {}
6191 the friend declaration actually provides the definition
6192 of `f', once C has been instantiated for some type. So,
6193 old_decl will be the out-of-class template declaration,
6194 while new_friend is the in-class definition.
6196 But, if `f' was called before this point, the
6197 instantiation of `f' will have DECL_TI_ARGS corresponding
6198 to `T' but not to `U', references to which might appear
6199 in the definition of `f'. Previously, the most general
6200 template for an instantiation of `f' was the out-of-class
6201 version; now it is the in-class version. Therefore, we
6202 run through all specialization of `f', adding to their
6203 DECL_TI_ARGS appropriately. In particular, they need a
6204 new set of outer arguments, corresponding to the
6205 arguments for this class instantiation.
6207 The same situation can arise with something like this:
6210 template <class T> class C {
6214 when `C<int>' is instantiated. Now, `f(int)' is defined
6217 if (!new_friend_is_defn)
6218 /* On the other hand, if the in-class declaration does
6219 *not* provide a definition, then we don't want to alter
6220 existing definitions. We can just leave everything
6225 /* Overwrite whatever template info was there before, if
6226 any, with the new template information pertaining to
6228 DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
6230 if (TREE_CODE (old_decl) != TEMPLATE_DECL)
6231 reregister_specialization (new_friend,
6232 most_general_template (old_decl),
6237 tree new_friend_args;
6239 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl))
6240 = new_friend_result_template_info;
6242 new_friend_args = TI_ARGS (new_friend_template_info);
6243 for (t = DECL_TEMPLATE_SPECIALIZATIONS (old_decl);
6247 tree spec = TREE_VALUE (t);
6250 = add_outermost_template_args (new_friend_args,
6251 DECL_TI_ARGS (spec));
6254 /* Now, since specializations are always supposed to
6255 hang off of the most general template, we must move
6257 t = most_general_template (old_decl);
6260 DECL_TEMPLATE_SPECIALIZATIONS (t)
6261 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t),
6262 DECL_TEMPLATE_SPECIALIZATIONS (old_decl));
6263 DECL_TEMPLATE_SPECIALIZATIONS (old_decl) = NULL_TREE;
6268 /* The information from NEW_FRIEND has been merged into OLD_DECL
6269 by duplicate_decls. */
6270 new_friend = old_decl;
6275 tree context = DECL_CONTEXT (new_friend);
6279 template <class T> class C {
6280 template <class U> friend void C1<U>::f (); // case 1
6281 friend void C2<T>::f (); // case 2
6283 we only need to make sure CONTEXT is a complete type for
6284 case 2. To distinguish between the two cases, we note that
6285 CONTEXT of case 1 remains dependent type after tsubst while
6286 this isn't true for case 2. */
6287 ++processing_template_decl;
6288 dependent_p = dependent_type_p (context);
6289 --processing_template_decl;
6292 && !complete_type_or_else (context, NULL_TREE))
6293 return error_mark_node;
6295 if (COMPLETE_TYPE_P (context))
6297 /* Check to see that the declaration is really present, and,
6298 possibly obtain an improved declaration. */
6299 tree fn = check_classfn (context,
6300 new_friend, NULL_TREE);
6310 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
6311 template arguments, as for tsubst.
6313 Returns an appropriate tsubst'd friend type or error_mark_node on
6317 tsubst_friend_class (tree friend_tmpl, tree args)
6323 context = DECL_CONTEXT (friend_tmpl);
6327 if (TREE_CODE (context) == NAMESPACE_DECL)
6328 push_nested_namespace (context);
6330 push_nested_class (tsubst (context, args, tf_none, NULL_TREE));
6333 /* Look for a class template declaration. We look for hidden names
6334 because two friend declarations of the same template are the
6335 same. For example, in:
6338 template <typename> friend class F;
6340 template <typename> struct B {
6341 template <typename> friend class F;
6344 both F templates are the same. */
6345 tmpl = lookup_name_real (DECL_NAME (friend_tmpl), 0, 0,
6346 /*block_p=*/true, 0,
6347 LOOKUP_COMPLAIN | LOOKUP_HIDDEN);
6349 /* But, if we don't find one, it might be because we're in a
6350 situation like this:
6358 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
6359 for `S<int>', not the TEMPLATE_DECL. */
6360 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
6362 tmpl = lookup_name_prefer_type (DECL_NAME (friend_tmpl), 1);
6363 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
6366 if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
6368 /* The friend template has already been declared. Just
6369 check to see that the declarations match, and install any new
6370 default parameters. We must tsubst the default parameters,
6371 of course. We only need the innermost template parameters
6372 because that is all that redeclare_class_template will look
6374 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl))
6375 > TMPL_ARGS_DEPTH (args))
6378 parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
6379 args, tf_warning_or_error);
6380 redeclare_class_template (TREE_TYPE (tmpl), parms);
6383 friend_type = TREE_TYPE (tmpl);
6387 /* The friend template has not already been declared. In this
6388 case, the instantiation of the template class will cause the
6389 injection of this template into the global scope. */
6390 tmpl = tsubst (friend_tmpl, args, tf_warning_or_error, NULL_TREE);
6391 if (tmpl == error_mark_node)
6392 return error_mark_node;
6394 /* The new TMPL is not an instantiation of anything, so we
6395 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
6396 the new type because that is supposed to be the corresponding
6397 template decl, i.e., TMPL. */
6398 DECL_USE_TEMPLATE (tmpl) = 0;
6399 DECL_TEMPLATE_INFO (tmpl) = NULL_TREE;
6400 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0;
6401 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl))
6402 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)));
6404 /* Inject this template into the global scope. */
6405 friend_type = TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl, true));
6410 if (TREE_CODE (context) == NAMESPACE_DECL)
6411 pop_nested_namespace (context);
6413 pop_nested_class ();
6419 /* Returns zero if TYPE cannot be completed later due to circularity.
6420 Otherwise returns one. */
6423 can_complete_type_without_circularity (tree type)
6425 if (type == NULL_TREE || type == error_mark_node)
6427 else if (COMPLETE_TYPE_P (type))
6429 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
6430 return can_complete_type_without_circularity (TREE_TYPE (type));
6431 else if (CLASS_TYPE_P (type)
6432 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type)))
6439 instantiate_class_template (tree type)
6441 tree template, args, pattern, t, member;
6446 if (type == error_mark_node)
6447 return error_mark_node;
6449 if (TYPE_BEING_DEFINED (type)
6450 || COMPLETE_TYPE_P (type)
6451 || dependent_type_p (type))
6454 /* Figure out which template is being instantiated. */
6455 template = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
6456 gcc_assert (TREE_CODE (template) == TEMPLATE_DECL);
6458 /* Determine what specialization of the original template to
6460 t = most_specialized_class (type, template);
6461 if (t == error_mark_node)
6463 TYPE_BEING_DEFINED (type) = 1;
6464 return error_mark_node;
6468 /* This TYPE is actually an instantiation of a partial
6469 specialization. We replace the innermost set of ARGS with
6470 the arguments appropriate for substitution. For example,
6473 template <class T> struct S {};
6474 template <class T> struct S<T*> {};
6476 and supposing that we are instantiating S<int*>, ARGS will
6477 presently be {int*} -- but we need {int}. */
6478 pattern = TREE_TYPE (t);
6479 args = TREE_PURPOSE (t);
6483 pattern = TREE_TYPE (template);
6484 args = CLASSTYPE_TI_ARGS (type);
6487 /* If the template we're instantiating is incomplete, then clearly
6488 there's nothing we can do. */
6489 if (!COMPLETE_TYPE_P (pattern))
6492 /* If we've recursively instantiated too many templates, stop. */
6493 if (! push_tinst_level (type))
6496 /* Now we're really doing the instantiation. Mark the type as in
6497 the process of being defined. */
6498 TYPE_BEING_DEFINED (type) = 1;
6500 /* We may be in the middle of deferred access check. Disable
6502 push_deferring_access_checks (dk_no_deferred);
6504 push_to_top_level ();
6506 SET_CLASSTYPE_INTERFACE_UNKNOWN (type);
6508 /* Set the input location to the template definition. This is needed
6509 if tsubsting causes an error. */
6510 typedecl = TYPE_MAIN_DECL (type);
6511 input_location = DECL_SOURCE_LOCATION (typedecl);
6512 in_system_header = DECL_IN_SYSTEM_HEADER (typedecl);
6514 TYPE_HAS_CONSTRUCTOR (type) = TYPE_HAS_CONSTRUCTOR (pattern);
6515 TYPE_HAS_NEW_OPERATOR (type) = TYPE_HAS_NEW_OPERATOR (pattern);
6516 TYPE_HAS_ARRAY_NEW_OPERATOR (type) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern);
6517 TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern);
6518 TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern);
6519 TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern);
6520 TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern);
6521 TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern);
6522 TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern);
6523 TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern);
6524 TYPE_PACKED (type) = TYPE_PACKED (pattern);
6525 TYPE_ALIGN (type) = TYPE_ALIGN (pattern);
6526 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);
6527 TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */
6528 if (ANON_AGGR_TYPE_P (pattern))
6529 SET_ANON_AGGR_TYPE_P (type);
6530 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern))
6532 CLASSTYPE_VISIBILITY_SPECIFIED (type) = 1;
6533 CLASSTYPE_VISIBILITY (type) = CLASSTYPE_VISIBILITY (pattern);
6536 pbinfo = TYPE_BINFO (pattern);
6538 /* We should never instantiate a nested class before its enclosing
6539 class; we need to look up the nested class by name before we can
6540 instantiate it, and that lookup should instantiate the enclosing
6542 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))
6543 || COMPLETE_TYPE_P (TYPE_CONTEXT (type))
6544 || TYPE_BEING_DEFINED (TYPE_CONTEXT (type)));
6546 base_list = NULL_TREE;
6547 if (BINFO_N_BASE_BINFOS (pbinfo))
6550 tree context = TYPE_CONTEXT (type);
6554 /* We must enter the scope containing the type, as that is where
6555 the accessibility of types named in dependent bases are
6557 pushed_scope = push_scope (context ? context : global_namespace);
6559 /* Substitute into each of the bases to determine the actual
6561 for (i = 0; BINFO_BASE_ITERATE (pbinfo, i, pbase_binfo); i++)
6564 tree access = BINFO_BASE_ACCESS (pbinfo, i);
6565 tree expanded_bases = NULL_TREE;
6568 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo)))
6571 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo),
6572 args, tf_error, NULL_TREE);
6573 if (expanded_bases == error_mark_node)
6576 len = TREE_VEC_LENGTH (expanded_bases);
6579 for (idx = 0; idx < len; idx++)
6582 /* Extract the already-expanded base class. */
6583 base = TREE_VEC_ELT (expanded_bases, idx);
6585 /* Substitute to figure out the base class. */
6586 base = tsubst (BINFO_TYPE (pbase_binfo), args, tf_error,
6589 if (base == error_mark_node)
6592 base_list = tree_cons (access, base, base_list);
6593 if (BINFO_VIRTUAL_P (pbase_binfo))
6594 TREE_TYPE (base_list) = integer_type_node;
6598 /* The list is now in reverse order; correct that. */
6599 base_list = nreverse (base_list);
6602 pop_scope (pushed_scope);
6604 /* Now call xref_basetypes to set up all the base-class
6606 xref_basetypes (type, base_list);
6609 /* Now that our base classes are set up, enter the scope of the
6610 class, so that name lookups into base classes, etc. will work
6611 correctly. This is precisely analogous to what we do in
6612 begin_class_definition when defining an ordinary non-template
6616 /* Now members are processed in the order of declaration. */
6617 for (member = CLASSTYPE_DECL_LIST (pattern);
6618 member; member = TREE_CHAIN (member))
6620 tree t = TREE_VALUE (member);
6622 if (TREE_PURPOSE (member))
6626 /* Build new CLASSTYPE_NESTED_UTDS. */
6629 bool class_template_p;
6631 class_template_p = (TREE_CODE (t) != ENUMERAL_TYPE
6632 && TYPE_LANG_SPECIFIC (t)
6633 && CLASSTYPE_IS_TEMPLATE (t));
6634 /* If the member is a class template, then -- even after
6635 substitution -- there may be dependent types in the
6636 template argument list for the class. We increment
6637 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
6638 that function will assume that no types are dependent
6639 when outside of a template. */
6640 if (class_template_p)
6641 ++processing_template_decl;
6642 newtag = tsubst (t, args, tf_error, NULL_TREE);
6643 if (class_template_p)
6644 --processing_template_decl;
6645 if (newtag == error_mark_node)
6648 if (TREE_CODE (newtag) != ENUMERAL_TYPE)
6650 tree name = TYPE_IDENTIFIER (t);
6652 if (class_template_p)
6653 /* Unfortunately, lookup_template_class sets
6654 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
6655 instantiation (i.e., for the type of a member
6656 template class nested within a template class.)
6657 This behavior is required for
6658 maybe_process_partial_specialization to work
6659 correctly, but is not accurate in this case;
6660 the TAG is not an instantiation of anything.
6661 (The corresponding TEMPLATE_DECL is an
6662 instantiation, but the TYPE is not.) */
6663 CLASSTYPE_USE_TEMPLATE (newtag) = 0;
6665 /* Now, we call pushtag to put this NEWTAG into the scope of
6666 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
6667 pushtag calling push_template_decl. We don't have to do
6668 this for enums because it will already have been done in
6671 SET_IDENTIFIER_TYPE_VALUE (name, newtag);
6672 pushtag (name, newtag, /*tag_scope=*/ts_current);
6675 else if (TREE_CODE (t) == FUNCTION_DECL
6676 || DECL_FUNCTION_TEMPLATE_P (t))
6678 /* Build new TYPE_METHODS. */
6681 if (TREE_CODE (t) == TEMPLATE_DECL)
6682 ++processing_template_decl;
6683 r = tsubst (t, args, tf_error, NULL_TREE);
6684 if (TREE_CODE (t) == TEMPLATE_DECL)
6685 --processing_template_decl;
6686 set_current_access_from_decl (r);
6687 finish_member_declaration (r);
6691 /* Build new TYPE_FIELDS. */
6692 if (TREE_CODE (t) == STATIC_ASSERT)
6695 tsubst_expr (STATIC_ASSERT_CONDITION (t), args,
6696 tf_warning_or_error, NULL_TREE,
6697 /*integral_constant_expression_p=*/true);
6698 finish_static_assert (condition,
6699 STATIC_ASSERT_MESSAGE (t),
6700 STATIC_ASSERT_SOURCE_LOCATION (t),
6703 else if (TREE_CODE (t) != CONST_DECL)
6707 /* The the file and line for this declaration, to
6708 assist in error message reporting. Since we
6709 called push_tinst_level above, we don't need to
6711 input_location = DECL_SOURCE_LOCATION (t);
6713 if (TREE_CODE (t) == TEMPLATE_DECL)
6714 ++processing_template_decl;
6715 r = tsubst (t, args, tf_warning_or_error, NULL_TREE);
6716 if (TREE_CODE (t) == TEMPLATE_DECL)
6717 --processing_template_decl;
6718 if (TREE_CODE (r) == VAR_DECL)
6722 [t]he initialization (and any associated
6723 side-effects) of a static data member does
6724 not occur unless the static data member is
6725 itself used in a way that requires the
6726 definition of the static data member to
6729 Therefore, we do not substitute into the
6730 initialized for the static data member here. */
6731 finish_static_data_member_decl
6734 /*init_const_expr_p=*/false,
6735 /*asmspec_tree=*/NULL_TREE,
6737 if (DECL_INITIALIZED_IN_CLASS_P (r))
6738 check_static_variable_definition (r, TREE_TYPE (r));
6740 else if (TREE_CODE (r) == FIELD_DECL)
6742 /* Determine whether R has a valid type and can be
6743 completed later. If R is invalid, then it is
6744 replaced by error_mark_node so that it will not be
6745 added to TYPE_FIELDS. */
6746 tree rtype = TREE_TYPE (r);
6747 if (can_complete_type_without_circularity (rtype))
6748 complete_type (rtype);
6750 if (!COMPLETE_TYPE_P (rtype))
6752 cxx_incomplete_type_error (r, rtype);
6753 r = error_mark_node;
6757 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
6758 such a thing will already have been added to the field
6759 list by tsubst_enum in finish_member_declaration in the
6760 CLASSTYPE_NESTED_UTDS case above. */
6761 if (!(TREE_CODE (r) == TYPE_DECL
6762 && TREE_CODE (TREE_TYPE (r)) == ENUMERAL_TYPE
6763 && DECL_ARTIFICIAL (r)))
6765 set_current_access_from_decl (r);
6766 finish_member_declaration (r);
6773 if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t))
6775 /* Build new CLASSTYPE_FRIEND_CLASSES. */
6777 tree friend_type = t;
6778 bool adjust_processing_template_decl = false;
6780 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
6782 /* template <class T> friend class C; */
6783 friend_type = tsubst_friend_class (friend_type, args);
6784 adjust_processing_template_decl = true;
6786 else if (TREE_CODE (friend_type) == UNBOUND_CLASS_TEMPLATE)
6788 /* template <class T> friend class C::D; */
6789 friend_type = tsubst (friend_type, args,
6790 tf_warning_or_error, NULL_TREE);
6791 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
6792 friend_type = TREE_TYPE (friend_type);
6793 adjust_processing_template_decl = true;
6795 else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
6797 /* This could be either
6801 when dependent_type_p is false or
6803 template <class U> friend class T::C;
6806 friend_type = tsubst (friend_type, args,
6807 tf_warning_or_error, NULL_TREE);
6808 /* Bump processing_template_decl for correct
6809 dependent_type_p calculation. */
6810 ++processing_template_decl;
6811 if (dependent_type_p (friend_type))
6812 adjust_processing_template_decl = true;
6813 --processing_template_decl;
6815 else if (!CLASSTYPE_USE_TEMPLATE (friend_type)
6816 && hidden_name_p (TYPE_NAME (friend_type)))
6820 where C hasn't been declared yet. Let's lookup name
6821 from namespace scope directly, bypassing any name that
6822 come from dependent base class. */
6823 tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type));
6825 /* The call to xref_tag_from_type does injection for friend
6827 push_nested_namespace (ns);
6829 xref_tag_from_type (friend_type, NULL_TREE,
6830 /*tag_scope=*/ts_current);
6831 pop_nested_namespace (ns);
6833 else if (uses_template_parms (friend_type))
6834 /* friend class C<T>; */
6835 friend_type = tsubst (friend_type, args,
6836 tf_warning_or_error, NULL_TREE);
6841 where C is already declared or
6843 friend class C<int>;
6845 We don't have to do anything in these cases. */
6847 if (adjust_processing_template_decl)
6848 /* Trick make_friend_class into realizing that the friend
6849 we're adding is a template, not an ordinary class. It's
6850 important that we use make_friend_class since it will
6851 perform some error-checking and output cross-reference
6853 ++processing_template_decl;
6855 if (friend_type != error_mark_node)
6856 make_friend_class (type, friend_type, /*complain=*/false);
6858 if (adjust_processing_template_decl)
6859 --processing_template_decl;
6863 /* Build new DECL_FRIENDLIST. */
6866 /* The the file and line for this declaration, to
6867 assist in error message reporting. Since we
6868 called push_tinst_level above, we don't need to
6870 input_location = DECL_SOURCE_LOCATION (t);
6872 if (TREE_CODE (t) == TEMPLATE_DECL)
6874 ++processing_template_decl;
6875 push_deferring_access_checks (dk_no_check);
6878 r = tsubst_friend_function (t, args);
6879 add_friend (type, r, /*complain=*/false);
6880 if (TREE_CODE (t) == TEMPLATE_DECL)
6882 pop_deferring_access_checks ();
6883 --processing_template_decl;
6889 /* Set the file and line number information to whatever is given for
6890 the class itself. This puts error messages involving generated
6891 implicit functions at a predictable point, and the same point
6892 that would be used for non-template classes. */
6893 input_location = DECL_SOURCE_LOCATION (typedecl);
6895 unreverse_member_declarations (type);
6896 finish_struct_1 (type);
6897 TYPE_BEING_DEFINED (type) = 0;
6899 /* Now that the class is complete, instantiate default arguments for
6900 any member functions. We don't do this earlier because the
6901 default arguments may reference members of the class. */
6902 if (!PRIMARY_TEMPLATE_P (template))
6903 for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t))
6904 if (TREE_CODE (t) == FUNCTION_DECL
6905 /* Implicitly generated member functions will not have template
6906 information; they are not instantiations, but instead are
6907 created "fresh" for each instantiation. */
6908 && DECL_TEMPLATE_INFO (t))
6909 tsubst_default_arguments (t);
6912 pop_from_top_level ();
6913 pop_deferring_access_checks ();
6916 /* The vtable for a template class can be emitted in any translation
6917 unit in which the class is instantiated. When there is no key
6918 method, however, finish_struct_1 will already have added TYPE to
6919 the keyed_classes list. */
6920 if (TYPE_CONTAINS_VPTR_P (type) && CLASSTYPE_KEY_METHOD (type))
6921 keyed_classes = tree_cons (NULL_TREE, type, keyed_classes);
6927 tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl)
6933 else if (TYPE_P (t))
6934 r = tsubst (t, args, complain, in_decl);
6937 r = tsubst_expr (t, args, complain, in_decl,
6938 /*integral_constant_expression_p=*/true);
6939 r = fold_non_dependent_expr (r);
6944 /* Substitute ARGS into T, which is an pack expansion
6945 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
6946 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
6947 (if only a partial substitution could be performed) or
6948 ERROR_MARK_NODE if there was an error. */
6950 tsubst_pack_expansion (tree t, tree args, tsubst_flags_t complain,
6954 tree pack, packs = NULL_TREE, unsubstituted_packs = NULL_TREE;
6955 tree first_arg_pack; int i, len = -1;
6959 gcc_assert (PACK_EXPANSION_P (t));
6960 pattern = PACK_EXPANSION_PATTERN (t);
6962 /* Determine the argument packs that will instantiate the parameter
6963 packs used in the expansion expression. While we're at it,
6964 compute the number of arguments to be expanded and make sure it
6966 for (pack = PACK_EXPANSION_PARAMETER_PACKS (t); pack;
6967 pack = TREE_CHAIN (pack))
6969 tree parm_pack = TREE_VALUE (pack);
6970 tree arg_pack = NULL_TREE;
6971 tree orig_arg = NULL_TREE;
6973 if (TREE_CODE (parm_pack) == PARM_DECL)
6975 if (local_specializations)
6976 arg_pack = retrieve_local_specialization (parm_pack);
6980 int level, idx, levels;
6981 template_parm_level_and_index (parm_pack, &level, &idx);
6983 levels = TMPL_ARGS_DEPTH (args);
6984 if (level <= levels)
6985 arg_pack = TMPL_ARG (args, level, idx);
6988 orig_arg = arg_pack;
6989 if (arg_pack && TREE_CODE (arg_pack) == ARGUMENT_PACK_SELECT)
6990 arg_pack = ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack);
6992 if (arg_pack && !ARGUMENT_PACK_P (arg_pack))
6993 /* This can only happen if we forget to expand an argument
6994 pack somewhere else. Just return an error, silently. */
6996 result = make_tree_vec (1);
6997 TREE_VEC_ELT (result, 0) = error_mark_node;
7004 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack));
7006 /* It's all-or-nothing with incomplete argument packs. */
7007 if (incomplete && !ARGUMENT_PACK_INCOMPLETE_P (arg_pack))
7008 return error_mark_node;
7010 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack))
7016 first_arg_pack = arg_pack;
7018 else if (len != my_len)
7020 if (TREE_CODE (t) == TYPE_PACK_EXPANSION)
7021 error ("mismatched argument pack lengths while expanding "
7025 error ("mismatched argument pack lengths while expanding "
7028 return error_mark_node;
7031 /* Keep track of the parameter packs and their corresponding
7033 packs = tree_cons (parm_pack, arg_pack, packs);
7034 TREE_TYPE (packs) = orig_arg;
7037 /* We can't substitute for this parameter pack. */
7038 unsubstituted_packs = tree_cons (TREE_PURPOSE (pack),
7040 unsubstituted_packs);
7043 /* We cannot expand this expansion expression, because we don't have
7044 all of the argument packs we need. Substitute into the pattern
7045 and return a PACK_EXPANSION_*. The caller will need to deal with
7047 if (unsubstituted_packs)
7048 return make_pack_expansion (tsubst (pattern, args, complain,
7051 /* We could not find any argument packs that work. */
7053 return error_mark_node;
7055 /* For each argument in each argument pack, substitute into the
7057 result = make_tree_vec (len + incomplete);
7058 for (i = 0; i < len + incomplete; ++i)
7060 /* For parameter pack, change the substitution of the parameter
7061 pack to the ith argument in its argument pack, then expand
7063 for (pack = packs; pack; pack = TREE_CHAIN (pack))
7065 tree parm = TREE_PURPOSE (pack);
7067 if (TREE_CODE (parm) == PARM_DECL)
7069 /* Select the Ith argument from the pack. */
7070 tree arg = make_node (ARGUMENT_PACK_SELECT);
7071 ARGUMENT_PACK_SELECT_FROM_PACK (arg) = TREE_VALUE (pack);
7072 ARGUMENT_PACK_SELECT_INDEX (arg) = i;
7074 register_local_specialization (arg, parm);
7080 template_parm_level_and_index (parm, &level, &idx);
7084 /* Select the Ith argument from the pack. */
7085 value = make_node (ARGUMENT_PACK_SELECT);
7086 ARGUMENT_PACK_SELECT_FROM_PACK (value) = TREE_VALUE (pack);
7087 ARGUMENT_PACK_SELECT_INDEX (value) = i;
7090 /* Update the corresponding argument. */
7091 TMPL_ARG (args, level, idx) = value;
7095 /* Substitute into the PATTERN with the altered arguments. */
7096 if (TREE_CODE (t) == EXPR_PACK_EXPANSION)
7097 TREE_VEC_ELT (result, i) =
7098 tsubst_expr (pattern, args, complain, in_decl,
7099 /*integral_constant_expression_p=*/false);
7101 TREE_VEC_ELT (result, i) = tsubst (pattern, args, complain, in_decl);
7104 /* When we have incomplete argument packs, the last "expanded"
7105 result is itself a pack expansion, which allows us
7106 to deduce more arguments. */
7107 TREE_VEC_ELT (result, i) =
7108 make_pack_expansion (TREE_VEC_ELT (result, i));
7110 if (TREE_VEC_ELT (result, i) == error_mark_node)
7112 result = error_mark_node;
7117 /* Update ARGS to restore the substitution from parameter packs to
7118 their argument packs. */
7119 for (pack = packs; pack; pack = TREE_CHAIN (pack))
7121 tree parm = TREE_PURPOSE (pack);
7123 if (TREE_CODE (parm) == PARM_DECL)
7124 register_local_specialization (TREE_TYPE (pack), parm);
7128 template_parm_level_and_index (parm, &level, &idx);
7130 /* Update the corresponding argument. */
7131 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
7132 TREE_VEC_ELT (TREE_VEC_ELT (args, level -1 ), idx) =
7135 TREE_VEC_ELT (args, idx) = TREE_TYPE (pack);
7142 /* Substitute ARGS into the vector or list of template arguments T. */
7145 tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl)
7148 int len = TREE_VEC_LENGTH (t);
7149 int need_new = 0, i, expanded_len_adjust = 0, out;
7150 tree *elts = (tree *) alloca (len * sizeof (tree));
7152 for (i = 0; i < len; i++)
7154 tree orig_arg = TREE_VEC_ELT (t, i);
7157 if (TREE_CODE (orig_arg) == TREE_VEC)
7158 new_arg = tsubst_template_args (orig_arg, args, complain, in_decl);
7159 else if (PACK_EXPANSION_P (orig_arg))
7161 /* Substitute into an expansion expression. */
7162 new_arg = tsubst_pack_expansion (orig_arg, args, complain, in_decl);
7164 if (TREE_CODE (new_arg) == TREE_VEC)
7165 /* Add to the expanded length adjustment the number of
7166 expanded arguments. We subtract one from this
7167 measurement, because the argument pack expression
7168 itself is already counted as 1 in
7169 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
7170 the argument pack is empty. */
7171 expanded_len_adjust += TREE_VEC_LENGTH (new_arg) - 1;
7173 else if (ARGUMENT_PACK_P (orig_arg))
7175 /* Substitute into each of the arguments. */
7176 new_arg = make_node (TREE_CODE (orig_arg));
7178 SET_ARGUMENT_PACK_ARGS (
7180 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg),
7181 args, complain, in_decl));
7183 if (ARGUMENT_PACK_ARGS (new_arg) == error_mark_node)
7184 new_arg = error_mark_node;
7186 if (TREE_CODE (new_arg) == NONTYPE_ARGUMENT_PACK) {
7187 TREE_TYPE (new_arg) = tsubst (TREE_TYPE (orig_arg), args,
7189 TREE_CONSTANT (new_arg) = TREE_CONSTANT (orig_arg);
7191 if (TREE_TYPE (new_arg) == error_mark_node)
7192 new_arg = error_mark_node;
7196 new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl);
7198 if (new_arg == error_mark_node)
7199 return error_mark_node;
7202 if (new_arg != orig_arg)
7209 /* Make space for the expanded arguments coming from template
7211 t = make_tree_vec (len + expanded_len_adjust);
7212 for (i = 0, out = 0; i < len; i++)
7214 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t, i))
7215 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t, i)))
7216 && TREE_CODE (elts[i]) == TREE_VEC)
7220 /* Now expand the template argument pack "in place". */
7221 for (idx = 0; idx < TREE_VEC_LENGTH (elts[i]); idx++, out++)
7222 TREE_VEC_ELT (t, out) = TREE_VEC_ELT (elts[i], idx);
7226 TREE_VEC_ELT (t, out) = elts[i];
7234 /* Return the result of substituting ARGS into the template parameters
7235 given by PARMS. If there are m levels of ARGS and m + n levels of
7236 PARMS, then the result will contain n levels of PARMS. For
7237 example, if PARMS is `template <class T> template <class U>
7238 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
7239 result will be `template <int*, double, class V>'. */
7242 tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain)
7247 /* When substituting into a template, we must set
7248 PROCESSING_TEMPLATE_DECL as the template parameters may be
7249 dependent if they are based on one-another, and the dependency
7250 predicates are short-circuit outside of templates. */
7251 ++processing_template_decl;
7253 for (new_parms = &r;
7254 TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args);
7255 new_parms = &(TREE_CHAIN (*new_parms)),
7256 parms = TREE_CHAIN (parms))
7259 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms)));
7262 for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i)
7268 if (parms == error_mark_node)
7271 tuple = TREE_VEC_ELT (TREE_VALUE (parms), i);
7273 if (tuple == error_mark_node)
7276 default_value = TREE_PURPOSE (tuple);
7277 parm_decl = TREE_VALUE (tuple);
7279 parm_decl = tsubst (parm_decl, args, complain, NULL_TREE);
7280 if (TREE_CODE (parm_decl) == PARM_DECL
7281 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl), complain))
7282 parm_decl = error_mark_node;
7283 default_value = tsubst_template_arg (default_value, args,
7284 complain, NULL_TREE);
7286 tuple = build_tree_list (default_value, parm_decl);
7287 TREE_VEC_ELT (new_vec, i) = tuple;
7291 tree_cons (size_int (TMPL_PARMS_DEPTH (parms)
7292 - TMPL_ARGS_DEPTH (args)),
7293 new_vec, NULL_TREE);
7296 --processing_template_decl;
7301 /* Substitute the ARGS into the indicated aggregate (or enumeration)
7302 type T. If T is not an aggregate or enumeration type, it is
7303 handled as if by tsubst. IN_DECL is as for tsubst. If
7304 ENTERING_SCOPE is nonzero, T is the context for a template which
7305 we are presently tsubst'ing. Return the substituted value. */
7308 tsubst_aggr_type (tree t,
7310 tsubst_flags_t complain,
7317 switch (TREE_CODE (t))
7320 if (TYPE_PTRMEMFUNC_P (t))
7321 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl);
7323 /* Else fall through. */
7326 if (TYPE_TEMPLATE_INFO (t))
7331 bool saved_skip_evaluation;
7333 /* In "sizeof(X<I>)" we need to evaluate "I". */
7334 saved_skip_evaluation = skip_evaluation;
7335 skip_evaluation = false;
7337 /* First, determine the context for the type we are looking
7339 context = TYPE_CONTEXT (t);
7341 context = tsubst_aggr_type (context, args, complain,
7342 in_decl, /*entering_scope=*/1);
7344 /* Then, figure out what arguments are appropriate for the
7345 type we are trying to find. For example, given:
7347 template <class T> struct S;
7348 template <class T, class U> void f(T, U) { S<U> su; }
7350 and supposing that we are instantiating f<int, double>,
7351 then our ARGS will be {int, double}, but, when looking up
7352 S we only want {double}. */
7353 argvec = tsubst_template_args (TYPE_TI_ARGS (t), args,
7355 if (argvec == error_mark_node)
7356 r = error_mark_node;
7359 r = lookup_template_class (t, argvec, in_decl, context,
7360 entering_scope, complain);
7361 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
7364 skip_evaluation = saved_skip_evaluation;
7369 /* This is not a template type, so there's nothing to do. */
7373 return tsubst (t, args, complain, in_decl);
7377 /* Substitute into the default argument ARG (a default argument for
7378 FN), which has the indicated TYPE. */
7381 tsubst_default_argument (tree fn, tree type, tree arg)
7383 tree saved_class_ptr = NULL_TREE;
7384 tree saved_class_ref = NULL_TREE;
7386 /* This default argument came from a template. Instantiate the
7387 default argument here, not in tsubst. In the case of
7396 we must be careful to do name lookup in the scope of S<T>,
7397 rather than in the current class. */
7398 push_access_scope (fn);
7399 /* The "this" pointer is not valid in a default argument. */
7402 saved_class_ptr = current_class_ptr;
7403 cp_function_chain->x_current_class_ptr = NULL_TREE;
7404 saved_class_ref = current_class_ref;
7405 cp_function_chain->x_current_class_ref = NULL_TREE;
7408 push_deferring_access_checks(dk_no_deferred);
7409 /* The default argument expression may cause implicitly defined
7410 member functions to be synthesized, which will result in garbage
7411 collection. We must treat this situation as if we were within
7412 the body of function so as to avoid collecting live data on the
7415 arg = tsubst_expr (arg, DECL_TI_ARGS (fn),
7416 tf_warning_or_error, NULL_TREE,
7417 /*integral_constant_expression_p=*/false);
7419 pop_deferring_access_checks();
7421 /* Restore the "this" pointer. */
7424 cp_function_chain->x_current_class_ptr = saved_class_ptr;
7425 cp_function_chain->x_current_class_ref = saved_class_ref;
7428 pop_access_scope (fn);
7430 /* Make sure the default argument is reasonable. */
7431 arg = check_default_argument (type, arg);
7436 /* Substitute into all the default arguments for FN. */
7439 tsubst_default_arguments (tree fn)
7444 tmpl_args = DECL_TI_ARGS (fn);
7446 /* If this function is not yet instantiated, we certainly don't need
7447 its default arguments. */
7448 if (uses_template_parms (tmpl_args))
7451 for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
7453 arg = TREE_CHAIN (arg))
7454 if (TREE_PURPOSE (arg))
7455 TREE_PURPOSE (arg) = tsubst_default_argument (fn,
7457 TREE_PURPOSE (arg));
7460 /* Substitute the ARGS into the T, which is a _DECL. Return the
7461 result of the substitution. Issue error and warning messages under
7462 control of COMPLAIN. */
7465 tsubst_decl (tree t, tree args, tsubst_flags_t complain)
7467 location_t saved_loc;
7471 /* Set the filename and linenumber to improve error-reporting. */
7472 saved_loc = input_location;
7473 input_location = DECL_SOURCE_LOCATION (t);
7475 switch (TREE_CODE (t))
7479 /* We can get here when processing a member function template,
7480 member class template, and template template parameter of
7481 a template class. */
7482 tree decl = DECL_TEMPLATE_RESULT (t);
7487 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
7489 /* Template template parameter is treated here. */
7490 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
7491 if (new_type == error_mark_node)
7492 return error_mark_node;
7495 TREE_CHAIN (r) = NULL_TREE;
7496 TREE_TYPE (r) = new_type;
7497 DECL_TEMPLATE_RESULT (r)
7498 = build_decl (TYPE_DECL, DECL_NAME (decl), new_type);
7499 DECL_TEMPLATE_PARMS (r)
7500 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
7502 TYPE_NAME (new_type) = r;
7506 /* We might already have an instance of this template.
7507 The ARGS are for the surrounding class type, so the
7508 full args contain the tsubst'd args for the context,
7509 plus the innermost args from the template decl. */
7510 tmpl_args = DECL_CLASS_TEMPLATE_P (t)
7511 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t))
7512 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t));
7513 /* Because this is a template, the arguments will still be
7514 dependent, even after substitution. If
7515 PROCESSING_TEMPLATE_DECL is not set, the dependency
7516 predicates will short-circuit. */
7517 ++processing_template_decl;
7518 full_args = tsubst_template_args (tmpl_args, args,
7520 --processing_template_decl;
7521 if (full_args == error_mark_node)
7522 return error_mark_node;
7524 /* tsubst_template_args doesn't copy the vector if
7525 nothing changed. But, *something* should have
7527 gcc_assert (full_args != tmpl_args);
7529 spec = retrieve_specialization (t, full_args,
7530 /*class_specializations_p=*/true);
7531 if (spec != NULL_TREE)
7537 /* Make a new template decl. It will be similar to the
7538 original, but will record the current template arguments.
7539 We also create a new function declaration, which is just
7540 like the old one, but points to this new template, rather
7541 than the old one. */
7543 gcc_assert (DECL_LANG_SPECIFIC (r) != 0);
7544 TREE_CHAIN (r) = NULL_TREE;
7546 DECL_TEMPLATE_INFO (r) = build_tree_list (t, args);
7548 if (TREE_CODE (decl) == TYPE_DECL)
7551 ++processing_template_decl;
7552 new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
7553 --processing_template_decl;
7554 if (new_type == error_mark_node)
7555 return error_mark_node;
7557 TREE_TYPE (r) = new_type;
7558 CLASSTYPE_TI_TEMPLATE (new_type) = r;
7559 DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type);
7560 DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type);
7561 DECL_CONTEXT (r) = TYPE_CONTEXT (new_type);
7566 ++processing_template_decl;
7567 new_decl = tsubst (decl, args, complain, in_decl);
7568 --processing_template_decl;
7569 if (new_decl == error_mark_node)
7570 return error_mark_node;
7572 DECL_TEMPLATE_RESULT (r) = new_decl;
7573 DECL_TI_TEMPLATE (new_decl) = r;
7574 TREE_TYPE (r) = TREE_TYPE (new_decl);
7575 DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl);
7576 DECL_CONTEXT (r) = DECL_CONTEXT (new_decl);
7579 SET_DECL_IMPLICIT_INSTANTIATION (r);
7580 DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE;
7581 DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE;
7583 /* The template parameters for this new template are all the
7584 template parameters for the old template, except the
7585 outermost level of parameters. */
7586 DECL_TEMPLATE_PARMS (r)
7587 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
7590 if (PRIMARY_TEMPLATE_P (t))
7591 DECL_PRIMARY_TEMPLATE (r) = r;
7593 if (TREE_CODE (decl) != TYPE_DECL)
7594 /* Record this non-type partial instantiation. */
7595 register_specialization (r, t,
7596 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r)),
7604 tree argvec = NULL_TREE;
7612 /* Nobody should be tsubst'ing into non-template functions. */
7613 gcc_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE);
7615 if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL)
7620 /* If T is not dependent, just return it. We have to
7621 increment PROCESSING_TEMPLATE_DECL because
7622 value_dependent_expression_p assumes that nothing is
7623 dependent when PROCESSING_TEMPLATE_DECL is zero. */
7624 ++processing_template_decl;
7625 dependent_p = value_dependent_expression_p (t);
7626 --processing_template_decl;
7630 /* Calculate the most general template of which R is a
7631 specialization, and the complete set of arguments used to
7633 gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
7634 argvec = tsubst_template_args (DECL_TI_ARGS
7635 (DECL_TEMPLATE_RESULT (gen_tmpl)),
7636 args, complain, in_decl);
7638 /* Check to see if we already have this specialization. */
7639 spec = retrieve_specialization (gen_tmpl, argvec,
7640 /*class_specializations_p=*/false);
7648 /* We can see more levels of arguments than parameters if
7649 there was a specialization of a member template, like
7652 template <class T> struct S { template <class U> void f(); }
7653 template <> template <class U> void S<int>::f(U);
7655 Here, we'll be substituting into the specialization,
7656 because that's where we can find the code we actually
7657 want to generate, but we'll have enough arguments for
7658 the most general template.
7660 We also deal with the peculiar case:
7662 template <class T> struct S {
7663 template <class U> friend void f();
7665 template <class U> void f() {}
7667 template void f<double>();
7669 Here, the ARGS for the instantiation of will be {int,
7670 double}. But, we only need as many ARGS as there are
7671 levels of template parameters in CODE_PATTERN. We are
7672 careful not to get fooled into reducing the ARGS in
7675 template <class T> struct S { template <class U> void f(U); }
7676 template <class T> template <> void S<T>::f(int) {}
7678 which we can spot because the pattern will be a
7679 specialization in this case. */
7680 args_depth = TMPL_ARGS_DEPTH (args);
7682 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t)));
7683 if (args_depth > parms_depth
7684 && !DECL_TEMPLATE_SPECIALIZATION (t))
7685 args = get_innermost_template_args (args, parms_depth);
7689 /* This special case arises when we have something like this:
7691 template <class T> struct S {
7692 friend void f<int>(int, double);
7695 Here, the DECL_TI_TEMPLATE for the friend declaration
7696 will be an IDENTIFIER_NODE. We are being called from
7697 tsubst_friend_function, and we want only to create a
7698 new decl (R) with appropriate types so that we can call
7699 determine_specialization. */
7700 gen_tmpl = NULL_TREE;
7703 if (DECL_CLASS_SCOPE_P (t))
7705 if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t)))
7709 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
7710 complain, t, /*entering_scope=*/1);
7715 ctx = DECL_CONTEXT (t);
7717 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
7718 if (type == error_mark_node)
7719 return error_mark_node;
7721 /* We do NOT check for matching decls pushed separately at this
7722 point, as they may not represent instantiations of this
7723 template, and in any case are considered separate under the
7726 DECL_USE_TEMPLATE (r) = 0;
7727 TREE_TYPE (r) = type;
7728 /* Clear out the mangled name and RTL for the instantiation. */
7729 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
7730 SET_DECL_RTL (r, NULL_RTX);
7731 DECL_INITIAL (r) = NULL_TREE;
7732 DECL_CONTEXT (r) = ctx;
7734 if (member && DECL_CONV_FN_P (r))
7735 /* Type-conversion operator. Reconstruct the name, in
7736 case it's the name of one of the template's parameters. */
7737 DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type));
7739 DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args,
7741 DECL_RESULT (r) = NULL_TREE;
7743 TREE_STATIC (r) = 0;
7744 TREE_PUBLIC (r) = TREE_PUBLIC (t);
7745 DECL_EXTERNAL (r) = 1;
7746 /* If this is an instantiation of a function with internal
7747 linkage, we already know what object file linkage will be
7748 assigned to the instantiation. */
7749 DECL_INTERFACE_KNOWN (r) = !TREE_PUBLIC (r);
7750 DECL_DEFER_OUTPUT (r) = 0;
7751 TREE_CHAIN (r) = NULL_TREE;
7752 DECL_PENDING_INLINE_INFO (r) = 0;
7753 DECL_PENDING_INLINE_P (r) = 0;
7754 DECL_SAVED_TREE (r) = NULL_TREE;
7756 if (DECL_CLONED_FUNCTION (r))
7758 DECL_CLONED_FUNCTION (r) = tsubst (DECL_CLONED_FUNCTION (t),
7760 TREE_CHAIN (r) = TREE_CHAIN (DECL_CLONED_FUNCTION (r));
7761 TREE_CHAIN (DECL_CLONED_FUNCTION (r)) = r;
7764 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
7765 this in the special friend case mentioned above where
7766 GEN_TMPL is NULL. */
7769 DECL_TEMPLATE_INFO (r)
7770 = tree_cons (gen_tmpl, argvec, NULL_TREE);
7771 SET_DECL_IMPLICIT_INSTANTIATION (r);
7772 register_specialization (r, gen_tmpl, argvec, false);
7774 /* We're not supposed to instantiate default arguments
7775 until they are called, for a template. But, for a
7778 template <class T> void f ()
7779 { extern void g(int i = T()); }
7781 we should do the substitution when the template is
7782 instantiated. We handle the member function case in
7783 instantiate_class_template since the default arguments
7784 might refer to other members of the class. */
7786 && !PRIMARY_TEMPLATE_P (gen_tmpl)
7787 && !uses_template_parms (argvec))
7788 tsubst_default_arguments (r);
7791 DECL_TEMPLATE_INFO (r) = NULL_TREE;
7793 /* Copy the list of befriending classes. */
7794 for (friends = &DECL_BEFRIENDING_CLASSES (r);
7796 friends = &TREE_CHAIN (*friends))
7798 *friends = copy_node (*friends);
7799 TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends),
7804 if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r))
7806 maybe_retrofit_in_chrg (r);
7807 if (DECL_CONSTRUCTOR_P (r))
7808 grok_ctor_properties (ctx, r);
7809 /* If this is an instantiation of a member template, clone it.
7810 If it isn't, that'll be handled by
7811 clone_constructors_and_destructors. */
7812 if (PRIMARY_TEMPLATE_P (gen_tmpl))
7813 clone_function_decl (r, /*update_method_vec_p=*/0);
7815 else if (IDENTIFIER_OPNAME_P (DECL_NAME (r))
7816 && !grok_op_properties (r, (complain & tf_error) != 0))
7817 return error_mark_node;
7819 if (DECL_FRIEND_P (t) && DECL_FRIEND_CONTEXT (t))
7820 SET_DECL_FRIEND_CONTEXT (r,
7821 tsubst (DECL_FRIEND_CONTEXT (t),
7822 args, complain, in_decl));
7824 /* Possibly limit visibility based on template args. */
7825 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
7826 if (DECL_VISIBILITY_SPECIFIED (t))
7828 DECL_VISIBILITY_SPECIFIED (r) = 0;
7830 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
7832 determine_visibility (r);
7838 tree type = NULL_TREE;
7840 tree expanded_types = NULL_TREE;
7841 tree prev_r = NULL_TREE;
7842 tree first_r = NULL_TREE;
7844 if (FUNCTION_PARAMETER_PACK_P (t))
7846 /* If there is a local specialization that isn't a
7847 parameter pack, it means that we're doing a "simple"
7848 substitution from inside tsubst_pack_expansion. Just
7849 return the local specialization (which will be a single
7851 tree spec = NULL_TREE;
7852 if (local_specializations)
7853 spec = retrieve_local_specialization (t);
7855 && TREE_CODE (spec) == PARM_DECL
7856 && TREE_CODE (TREE_TYPE (spec)) != TYPE_PACK_EXPANSION)
7859 /* Expand the TYPE_PACK_EXPANSION that provides the types for
7860 the parameters in this function parameter pack. */
7861 expanded_types = tsubst_pack_expansion (TREE_TYPE (t), args,
7863 if (TREE_CODE (expanded_types) == TREE_VEC)
7865 len = TREE_VEC_LENGTH (expanded_types);
7867 /* Zero-length parameter packs are boring. Just substitute
7870 return tsubst (TREE_CHAIN (t), args, complain,
7875 /* All we did was update the type. Make a note of that. */
7876 type = expanded_types;
7877 expanded_types = NULL_TREE;
7881 /* Loop through all of the parameter's we'll build. When T is
7882 a function parameter pack, LEN is the number of expanded
7883 types in EXPANDED_TYPES; otherwise, LEN is 1. */
7885 for (i = 0; i < len; ++i)
7889 if (DECL_TEMPLATE_PARM_P (t))
7890 SET_DECL_TEMPLATE_PARM_P (r);
7893 /* We're on the Ith parameter of the function parameter
7896 /* Get the Ith type. */
7897 type = TREE_VEC_ELT (expanded_types, i);
7900 /* Rename the parameter to include the index. */
7902 make_ith_pack_parameter_name (DECL_NAME (r), i);
7905 /* We're dealing with a normal parameter. */
7906 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
7908 type = type_decays_to (type);
7909 TREE_TYPE (r) = type;
7910 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
7912 if (DECL_INITIAL (r))
7914 if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
7915 DECL_INITIAL (r) = TREE_TYPE (r);
7917 DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
7921 DECL_CONTEXT (r) = NULL_TREE;
7923 if (!DECL_TEMPLATE_PARM_P (r))
7924 DECL_ARG_TYPE (r) = type_passed_as (type);
7926 /* Keep track of the first new parameter we
7927 generate. That's what will be returned to the
7932 /* Build a proper chain of parameters when substituting
7933 into a function parameter pack. */
7935 TREE_CHAIN (prev_r) = r;
7939 TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args,
7940 complain, TREE_CHAIN (t));
7942 /* FIRST_R contains the start of the chain we've built. */
7952 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
7953 if (type == error_mark_node)
7954 return error_mark_node;
7955 TREE_TYPE (r) = type;
7956 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
7958 /* DECL_INITIAL gives the number of bits in a bit-field. */
7960 = tsubst_expr (DECL_INITIAL (t), args,
7962 /*integral_constant_expression_p=*/true);
7963 /* We don't have to set DECL_CONTEXT here; it is set by
7964 finish_member_declaration. */
7965 TREE_CHAIN (r) = NULL_TREE;
7966 if (VOID_TYPE_P (type))
7967 error ("instantiation of %q+D as type %qT", r, type);
7972 /* We reach here only for member using decls. */
7973 if (DECL_DEPENDENT_P (t))
7975 r = do_class_using_decl
7976 (tsubst_copy (USING_DECL_SCOPE (t), args, complain, in_decl),
7977 tsubst_copy (DECL_NAME (t), args, complain, in_decl));
7979 r = error_mark_node;
7984 TREE_CHAIN (r) = NULL_TREE;
7991 tree argvec = NULL_TREE;
7992 tree gen_tmpl = NULL_TREE;
7994 tree tmpl = NULL_TREE;
7996 tree type = NULL_TREE;
7999 if (TREE_CODE (t) == TYPE_DECL)
8001 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8002 if (TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
8003 || t == TYPE_MAIN_DECL (TREE_TYPE (t)))
8005 /* If this is the canonical decl, we don't have to
8006 mess with instantiations, and often we can't (for
8007 typename, template type parms and such). Note that
8008 TYPE_NAME is not correct for the above test if
8009 we've copied the type for a typedef. */
8010 r = TYPE_NAME (type);
8015 /* Check to see if we already have the specialization we
8018 if (DECL_CLASS_SCOPE_P (t) || DECL_NAMESPACE_SCOPE_P (t))
8020 /* T is a static data member or namespace-scope entity.
8021 We have to substitute into namespace-scope variables
8022 (even though such entities are never templates) because
8025 template <class T> void f() { extern T t; }
8027 where the entity referenced is not known until
8028 instantiation time. */
8030 ctx = DECL_CONTEXT (t);
8031 if (DECL_CLASS_SCOPE_P (t))
8033 ctx = tsubst_aggr_type (ctx, args,
8035 in_decl, /*entering_scope=*/1);
8036 /* If CTX is unchanged, then T is in fact the
8037 specialization we want. That situation occurs when
8038 referencing a static data member within in its own
8039 class. We can use pointer equality, rather than
8040 same_type_p, because DECL_CONTEXT is always
8042 if (ctx == DECL_CONTEXT (t))
8048 tmpl = DECL_TI_TEMPLATE (t);
8049 gen_tmpl = most_general_template (tmpl);
8050 argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl);
8051 spec = (retrieve_specialization
8053 /*class_specializations_p=*/false));
8058 /* A local variable. */
8060 /* Subsequent calls to pushdecl will fill this in. */
8062 spec = retrieve_local_specialization (t);
8064 /* If we already have the specialization we need, there is
8065 nothing more to do. */
8072 /* Create a new node for the specialization we need. */
8074 if (TREE_CODE (r) == VAR_DECL)
8076 /* Even if the original location is out of scope, the
8077 newly substituted one is not. */
8078 DECL_DEAD_FOR_LOCAL (r) = 0;
8079 DECL_INITIALIZED_P (r) = 0;
8080 DECL_TEMPLATE_INSTANTIATED (r) = 0;
8081 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8082 if (type == error_mark_node)
8083 return error_mark_node;
8084 if (TREE_CODE (type) == FUNCTION_TYPE)
8086 /* It may seem that this case cannot occur, since:
8091 declares a function, not a variable. However:
8094 template <typename T> void g() { T t; }
8095 template void g<f>();
8097 is an attempt to declare a variable with function
8099 error ("variable %qD has function type",
8100 /* R is not yet sufficiently initialized, so we
8101 just use its name. */
8103 return error_mark_node;
8105 type = complete_type (type);
8106 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
8107 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t);
8108 type = check_var_type (DECL_NAME (r), type);
8110 if (DECL_HAS_VALUE_EXPR_P (t))
8112 tree ve = DECL_VALUE_EXPR (t);
8113 ve = tsubst_expr (ve, args, complain, in_decl,
8114 /*constant_expression_p=*/false);
8115 SET_DECL_VALUE_EXPR (r, ve);
8118 else if (DECL_SELF_REFERENCE_P (t))
8119 SET_DECL_SELF_REFERENCE_P (r);
8120 TREE_TYPE (r) = type;
8121 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
8122 DECL_CONTEXT (r) = ctx;
8123 /* Clear out the mangled name and RTL for the instantiation. */
8124 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
8125 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
8126 SET_DECL_RTL (r, NULL_RTX);
8127 /* The initializer must not be expanded until it is required;
8129 DECL_INITIAL (r) = NULL_TREE;
8130 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
8131 SET_DECL_RTL (r, NULL_RTX);
8132 DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0;
8133 if (TREE_CODE (r) == VAR_DECL)
8135 /* Possibly limit visibility based on template args. */
8136 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
8137 if (DECL_VISIBILITY_SPECIFIED (t))
8139 DECL_VISIBILITY_SPECIFIED (r) = 0;
8141 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
8143 determine_visibility (r);
8148 /* A static data member declaration is always marked
8149 external when it is declared in-class, even if an
8150 initializer is present. We mimic the non-template
8152 DECL_EXTERNAL (r) = 1;
8154 register_specialization (r, gen_tmpl, argvec, false);
8155 DECL_TEMPLATE_INFO (r) = tree_cons (tmpl, argvec, NULL_TREE);
8156 SET_DECL_IMPLICIT_INSTANTIATION (r);
8159 register_local_specialization (r, t);
8161 TREE_CHAIN (r) = NULL_TREE;
8170 /* Restore the file and line information. */
8171 input_location = saved_loc;
8176 /* Substitute into the ARG_TYPES of a function type. */
8179 tsubst_arg_types (tree arg_types,
8181 tsubst_flags_t complain,
8184 tree remaining_arg_types;
8185 tree type = NULL_TREE;
8187 tree expanded_args = NULL_TREE;
8190 if (!arg_types || arg_types == void_list_node)
8193 remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types),
8194 args, complain, in_decl);
8195 if (remaining_arg_types == error_mark_node)
8196 return error_mark_node;
8198 if (PACK_EXPANSION_P (TREE_VALUE (arg_types)))
8200 /* For a pack expansion, perform substitution on the
8201 entire expression. Later on, we'll handle the arguments
8203 expanded_args = tsubst_pack_expansion (TREE_VALUE (arg_types),
8204 args, complain, in_decl);
8206 if (TREE_CODE (expanded_args) == TREE_VEC)
8207 /* So that we'll spin through the parameters, one by one. */
8208 i = TREE_VEC_LENGTH (expanded_args);
8211 /* We only partially substituted into the parameter
8212 pack. Our type is TYPE_PACK_EXPANSION. */
8213 type = expanded_args;
8214 expanded_args = NULL_TREE;
8222 type = TREE_VEC_ELT (expanded_args, i);
8224 type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
8226 if (type == error_mark_node)
8227 return error_mark_node;
8228 if (VOID_TYPE_P (type))
8230 if (complain & tf_error)
8232 error ("invalid parameter type %qT", type);
8234 error ("in declaration %q+D", in_decl);
8236 return error_mark_node;
8239 /* Do array-to-pointer, function-to-pointer conversion, and ignore
8240 top-level qualifiers as required. */
8241 type = TYPE_MAIN_VARIANT (type_decays_to (type));
8243 /* We do not substitute into default arguments here. The standard
8244 mandates that they be instantiated only when needed, which is
8245 done in build_over_call. */
8246 default_arg = TREE_PURPOSE (arg_types);
8248 if (default_arg && TREE_CODE (default_arg) == DEFAULT_ARG)
8250 /* We've instantiated a template before its default arguments
8251 have been parsed. This can happen for a nested template
8252 class, and is not an error unless we require the default
8253 argument in a call of this function. */
8254 remaining_arg_types =
8255 tree_cons (default_arg, type, remaining_arg_types);
8256 VEC_safe_push (tree, gc, DEFARG_INSTANTIATIONS (default_arg),
8257 remaining_arg_types);
8260 remaining_arg_types =
8261 hash_tree_cons (default_arg, type, remaining_arg_types);
8264 return remaining_arg_types;
8267 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
8268 *not* handle the exception-specification for FNTYPE, because the
8269 initial substitution of explicitly provided template parameters
8270 during argument deduction forbids substitution into the
8271 exception-specification:
8275 All references in the function type of the function template to the
8276 corresponding template parameters are replaced by the specified tem-
8277 plate argument values. If a substitution in a template parameter or
8278 in the function type of the function template results in an invalid
8279 type, type deduction fails. [Note: The equivalent substitution in
8280 exception specifications is done only when the function is instanti-
8281 ated, at which point a program is ill-formed if the substitution
8282 results in an invalid type.] */
8285 tsubst_function_type (tree t,
8287 tsubst_flags_t complain,
8294 /* The TYPE_CONTEXT is not used for function/method types. */
8295 gcc_assert (TYPE_CONTEXT (t) == NULL_TREE);
8297 /* Substitute the return type. */
8298 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8299 if (return_type == error_mark_node)
8300 return error_mark_node;
8301 /* The standard does not presently indicate that creation of a
8302 function type with an invalid return type is a deduction failure.
8303 However, that is clearly analogous to creating an array of "void"
8304 or a reference to a reference. This is core issue #486. */
8305 if (TREE_CODE (return_type) == ARRAY_TYPE
8306 || TREE_CODE (return_type) == FUNCTION_TYPE)
8308 if (complain & tf_error)
8310 if (TREE_CODE (return_type) == ARRAY_TYPE)
8311 error ("function returning an array");
8313 error ("function returning a function");
8315 return error_mark_node;
8318 /* Substitute the argument types. */
8319 arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args,
8321 if (arg_types == error_mark_node)
8322 return error_mark_node;
8324 if (TYPE_QUALS (return_type) != TYPE_UNQUALIFIED
8325 && in_decl != NULL_TREE
8326 && !TREE_NO_WARNING (in_decl)
8327 && (SCALAR_TYPE_P (return_type) || VOID_TYPE_P (return_type)))
8328 warning (OPT_Wreturn_type,
8329 "type qualifiers ignored on function return type");
8331 /* Construct a new type node and return it. */
8332 if (TREE_CODE (t) == FUNCTION_TYPE)
8333 fntype = build_function_type (return_type, arg_types);
8336 tree r = TREE_TYPE (TREE_VALUE (arg_types));
8337 if (! IS_AGGR_TYPE (r))
8341 Type deduction may fail for any of the following
8344 -- Attempting to create "pointer to member of T" when T
8345 is not a class type. */
8346 if (complain & tf_error)
8347 error ("creating pointer to member function of non-class type %qT",
8349 return error_mark_node;
8352 fntype = build_method_type_directly (r, return_type,
8353 TREE_CHAIN (arg_types));
8355 fntype = cp_build_qualified_type_real (fntype, TYPE_QUALS (t), complain);
8356 fntype = cp_build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t));
8361 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
8362 ARGS into that specification, and return the substituted
8363 specification. If there is no specification, return NULL_TREE. */
8366 tsubst_exception_specification (tree fntype,
8368 tsubst_flags_t complain,
8374 specs = TYPE_RAISES_EXCEPTIONS (fntype);
8375 new_specs = NULL_TREE;
8378 if (! TREE_VALUE (specs))
8385 tree expanded_specs = NULL_TREE;
8387 if (PACK_EXPANSION_P (TREE_VALUE (specs)))
8389 /* Expand the pack expansion type. */
8390 expanded_specs = tsubst_pack_expansion (TREE_VALUE (specs),
8393 len = TREE_VEC_LENGTH (expanded_specs);
8396 for (i = 0; i < len; ++i)
8399 spec = TREE_VEC_ELT (expanded_specs, i);
8401 spec = tsubst (TREE_VALUE (specs), args, complain, in_decl);
8402 if (spec == error_mark_node)
8404 new_specs = add_exception_specifier (new_specs, spec,
8408 specs = TREE_CHAIN (specs);
8414 /* Take the tree structure T and replace template parameters used
8415 therein with the argument vector ARGS. IN_DECL is an associated
8416 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
8417 Issue error and warning messages under control of COMPLAIN. Note
8418 that we must be relatively non-tolerant of extensions here, in
8419 order to preserve conformance; if we allow substitutions that
8420 should not be allowed, we may allow argument deductions that should
8421 not succeed, and therefore report ambiguous overload situations
8422 where there are none. In theory, we could allow the substitution,
8423 but indicate that it should have failed, and allow our caller to
8424 make sure that the right thing happens, but we don't try to do this
8427 This function is used for dealing with types, decls and the like;
8428 for expressions, use tsubst_expr or tsubst_copy. */
8431 tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
8435 if (t == NULL_TREE || t == error_mark_node
8436 || t == integer_type_node
8437 || t == void_type_node
8438 || t == char_type_node
8439 || t == unknown_type_node
8440 || TREE_CODE (t) == NAMESPACE_DECL)
8444 return tsubst_decl (t, args, complain);
8446 if (TREE_CODE (t) == IDENTIFIER_NODE)
8447 type = IDENTIFIER_TYPE_VALUE (t);
8449 type = TREE_TYPE (t);
8451 gcc_assert (type != unknown_type_node);
8454 && TREE_CODE (t) != TYPENAME_TYPE
8455 && TREE_CODE (t) != IDENTIFIER_NODE
8456 && TREE_CODE (t) != FUNCTION_TYPE
8457 && TREE_CODE (t) != METHOD_TYPE)
8458 type = tsubst (type, args, complain, in_decl);
8459 if (type == error_mark_node)
8460 return error_mark_node;
8462 switch (TREE_CODE (t))
8467 return tsubst_aggr_type (t, args, complain, in_decl,
8468 /*entering_scope=*/0);
8471 case IDENTIFIER_NODE:
8483 if (t == integer_type_node)
8486 if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
8487 && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
8491 tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);
8493 max = tsubst_expr (omax, args, complain, in_decl,
8494 /*integral_constant_expression_p=*/false);
8495 max = fold_decl_constant_value (max);
8497 if (TREE_CODE (max) != INTEGER_CST
8498 && TREE_CODE (max) != TEMPLATE_PARM_INDEX
8499 && !at_function_scope_p ())
8501 if (complain & tf_error)
8502 error ("array bound is not an integer constant");
8503 return error_mark_node;
8508 Type deduction may fail for any of the following
8511 Attempting to create an array with a size that is
8512 zero or negative. */
8513 if (integer_zerop (max) && !(complain & tf_error))
8514 /* We must fail if performing argument deduction (as
8515 indicated by the state of complain), so that
8516 another substitution can be found. */
8517 return error_mark_node;
8518 else if (TREE_CODE (max) == INTEGER_CST
8519 && INT_CST_LT (max, integer_zero_node))
8521 if (complain & tf_error)
8522 error ("creating array with negative size (%qE)", max);
8524 return error_mark_node;
8527 return compute_array_index_type (NULL_TREE, max);
8530 case TEMPLATE_TYPE_PARM:
8531 case TEMPLATE_TEMPLATE_PARM:
8532 case BOUND_TEMPLATE_TEMPLATE_PARM:
8533 case TEMPLATE_PARM_INDEX:
8538 tree arg = NULL_TREE;
8542 gcc_assert (TREE_VEC_LENGTH (args) > 0);
8543 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM
8544 || TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM
8545 || TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
8547 idx = TEMPLATE_TYPE_IDX (t);
8548 level = TEMPLATE_TYPE_LEVEL (t);
8552 idx = TEMPLATE_PARM_IDX (t);
8553 level = TEMPLATE_PARM_LEVEL (t);
8556 levels = TMPL_ARGS_DEPTH (args);
8557 if (level <= levels)
8559 arg = TMPL_ARG (args, level, idx);
8561 if (arg && TREE_CODE (arg) == ARGUMENT_PACK_SELECT)
8562 /* See through ARGUMENT_PACK_SELECT arguments. */
8563 arg = ARGUMENT_PACK_SELECT_ARG (arg);
8566 if (arg == error_mark_node)
8567 return error_mark_node;
8568 else if (arg != NULL_TREE)
8570 if (ARGUMENT_PACK_P (arg))
8571 /* If ARG is an argument pack, we don't actually want to
8572 perform a substitution here, because substitutions
8573 for argument packs are only done
8574 element-by-element. We can get to this point when
8575 substituting the type of a non-type template
8576 parameter pack, when that type actually contains
8577 template parameter packs from an outer template, e.g.,
8579 template<typename... Types> struct A {
8580 template<Types... Values> struct B { };
8584 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
8587 gcc_assert (TYPE_P (arg));
8589 /* cv-quals from the template are discarded when
8590 substituting in a function or reference type. */
8591 if (TREE_CODE (arg) == FUNCTION_TYPE
8592 || TREE_CODE (arg) == METHOD_TYPE
8593 || TREE_CODE (arg) == REFERENCE_TYPE)
8594 quals = cp_type_quals (arg);
8596 quals = cp_type_quals (arg) | cp_type_quals (t);
8598 return cp_build_qualified_type_real
8599 (arg, quals, complain | tf_ignore_bad_quals);
8601 else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
8603 /* We are processing a type constructed from a
8604 template template parameter. */
8605 tree argvec = tsubst (TYPE_TI_ARGS (t),
8606 args, complain, in_decl);
8607 if (argvec == error_mark_node)
8608 return error_mark_node;
8610 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
8611 are resolving nested-types in the signature of a
8612 member function templates. Otherwise ARG is a
8613 TEMPLATE_DECL and is the real template to be
8615 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
8616 arg = TYPE_NAME (arg);
8618 r = lookup_template_class (arg,
8621 /*entering_scope=*/0,
8623 return cp_build_qualified_type_real
8624 (r, TYPE_QUALS (t), complain);
8627 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
8632 /* This can happen during the attempted tsubst'ing in
8633 unify. This means that we don't yet have any information
8634 about the template parameter in question. */
8637 /* If we get here, we must have been looking at a parm for a
8638 more deeply nested template. Make a new version of this
8639 template parameter, but with a lower level. */
8640 switch (TREE_CODE (t))
8642 case TEMPLATE_TYPE_PARM:
8643 case TEMPLATE_TEMPLATE_PARM:
8644 case BOUND_TEMPLATE_TEMPLATE_PARM:
8645 if (cp_type_quals (t))
8647 r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
8648 r = cp_build_qualified_type_real
8649 (r, cp_type_quals (t),
8650 complain | (TREE_CODE (t) == TEMPLATE_TYPE_PARM
8651 ? tf_ignore_bad_quals : 0));
8656 TEMPLATE_TYPE_PARM_INDEX (r)
8657 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t),
8659 TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r);
8660 TYPE_MAIN_VARIANT (r) = r;
8661 TYPE_POINTER_TO (r) = NULL_TREE;
8662 TYPE_REFERENCE_TO (r) = NULL_TREE;
8664 if (TREE_CODE (r) == TEMPLATE_TEMPLATE_PARM)
8665 /* We have reduced the level of the template
8666 template parameter, but not the levels of its
8667 template parameters, so canonical_type_parameter
8668 will not be able to find the canonical template
8669 template parameter for this level. Thus, we
8670 require structural equality checking to compare
8671 TEMPLATE_TEMPLATE_PARMs. */
8672 SET_TYPE_STRUCTURAL_EQUALITY (r);
8673 else if (TYPE_STRUCTURAL_EQUALITY_P (t))
8674 SET_TYPE_STRUCTURAL_EQUALITY (r);
8676 TYPE_CANONICAL (r) = canonical_type_parameter (r);
8678 if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
8680 tree argvec = tsubst (TYPE_TI_ARGS (t), args,
8682 if (argvec == error_mark_node)
8683 return error_mark_node;
8685 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r)
8686 = tree_cons (TYPE_TI_TEMPLATE (t), argvec, NULL_TREE);
8691 case TEMPLATE_PARM_INDEX:
8692 r = reduce_template_parm_level (t, type, levels);
8704 tree purpose, value, chain;
8706 if (t == void_list_node)
8709 purpose = TREE_PURPOSE (t);
8712 purpose = tsubst (purpose, args, complain, in_decl);
8713 if (purpose == error_mark_node)
8714 return error_mark_node;
8716 value = TREE_VALUE (t);
8719 value = tsubst (value, args, complain, in_decl);
8720 if (value == error_mark_node)
8721 return error_mark_node;
8723 chain = TREE_CHAIN (t);
8724 if (chain && chain != void_type_node)
8726 chain = tsubst (chain, args, complain, in_decl);
8727 if (chain == error_mark_node)
8728 return error_mark_node;
8730 if (purpose == TREE_PURPOSE (t)
8731 && value == TREE_VALUE (t)
8732 && chain == TREE_CHAIN (t))
8734 return hash_tree_cons (purpose, value, chain);
8738 /* We should never be tsubsting a binfo. */
8742 /* A vector of template arguments. */
8744 return tsubst_template_args (t, args, complain, in_decl);
8747 case REFERENCE_TYPE:
8749 enum tree_code code;
8751 if (type == TREE_TYPE (t) && TREE_CODE (type) != METHOD_TYPE)
8754 code = TREE_CODE (t);
8759 Type deduction may fail for any of the following
8762 -- Attempting to create a pointer to reference type.
8763 -- Attempting to create a reference to a reference type or
8764 a reference to void.
8766 Core issue 106 says that creating a reference to a reference
8767 during instantiation is no longer a cause for failure. We
8768 only enforce this check in strict C++98 mode. */
8769 if ((TREE_CODE (type) == REFERENCE_TYPE
8770 && (((cxx_dialect == cxx98) && flag_iso) || code != REFERENCE_TYPE))
8771 || (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE))
8773 static location_t last_loc;
8775 /* We keep track of the last time we issued this error
8776 message to avoid spewing a ton of messages during a
8777 single bad template instantiation. */
8778 if (complain & tf_error
8779 #ifdef USE_MAPPED_LOCATION
8780 && last_loc != input_location
8782 && (last_loc.line != input_line
8783 || last_loc.file != input_filename)
8787 if (TREE_CODE (type) == VOID_TYPE)
8788 error ("forming reference to void");
8790 error ("forming %s to reference type %qT",
8791 (code == POINTER_TYPE) ? "pointer" : "reference",
8793 last_loc = input_location;
8796 return error_mark_node;
8798 else if (code == POINTER_TYPE)
8800 r = build_pointer_type (type);
8801 if (TREE_CODE (type) == METHOD_TYPE)
8802 r = build_ptrmemfunc_type (r);
8804 else if (TREE_CODE (type) == REFERENCE_TYPE)
8805 /* In C++0x, during template argument substitution, when there is an
8806 attempt to create a reference to a reference type, reference
8807 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
8809 "If a template-argument for a template-parameter T names a type
8810 that is a reference to a type A, an attempt to create the type
8811 'lvalue reference to cv T' creates the type 'lvalue reference to
8812 A,' while an attempt to create the type type rvalue reference to
8813 cv T' creates the type T"
8815 r = cp_build_reference_type
8817 TYPE_REF_IS_RVALUE (t) && TYPE_REF_IS_RVALUE (type));
8819 r = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
8820 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
8822 if (r != error_mark_node)
8823 /* Will this ever be needed for TYPE_..._TO values? */
8830 r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
8831 if (r == error_mark_node || !IS_AGGR_TYPE (r))
8835 Type deduction may fail for any of the following
8838 -- Attempting to create "pointer to member of T" when T
8839 is not a class type. */
8840 if (complain & tf_error)
8841 error ("creating pointer to member of non-class type %qT", r);
8842 return error_mark_node;
8844 if (TREE_CODE (type) == REFERENCE_TYPE)
8846 if (complain & tf_error)
8847 error ("creating pointer to member reference type %qT", type);
8848 return error_mark_node;
8850 if (TREE_CODE (type) == VOID_TYPE)
8852 if (complain & tf_error)
8853 error ("creating pointer to member of type void");
8854 return error_mark_node;
8856 gcc_assert (TREE_CODE (type) != METHOD_TYPE);
8857 if (TREE_CODE (type) == FUNCTION_TYPE)
8859 /* The type of the implicit object parameter gets its
8860 cv-qualifiers from the FUNCTION_TYPE. */
8862 tree this_type = cp_build_qualified_type (TYPE_MAIN_VARIANT (r),
8863 cp_type_quals (type));
8865 method_type = build_method_type_directly (this_type,
8867 TYPE_ARG_TYPES (type));
8868 memptr = build_ptrmemfunc_type (build_pointer_type (method_type));
8869 return cp_build_qualified_type_real (memptr, cp_type_quals (t),
8873 return cp_build_qualified_type_real (build_ptrmem_type (r, type),
8882 fntype = tsubst_function_type (t, args, complain, in_decl);
8883 if (fntype == error_mark_node)
8884 return error_mark_node;
8886 /* Substitute the exception specification. */
8887 specs = tsubst_exception_specification (t, args, complain,
8889 if (specs == error_mark_node)
8890 return error_mark_node;
8892 fntype = build_exception_variant (fntype, specs);
8897 tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
8898 if (domain == error_mark_node)
8899 return error_mark_node;
8901 /* As an optimization, we avoid regenerating the array type if
8902 it will obviously be the same as T. */
8903 if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
8906 /* These checks should match the ones in grokdeclarator.
8910 The deduction may fail for any of the following reasons:
8912 -- Attempting to create an array with an element type that
8913 is void, a function type, or a reference type, or [DR337]
8914 an abstract class type. */
8915 if (TREE_CODE (type) == VOID_TYPE
8916 || TREE_CODE (type) == FUNCTION_TYPE
8917 || TREE_CODE (type) == REFERENCE_TYPE)
8919 if (complain & tf_error)
8920 error ("creating array of %qT", type);
8921 return error_mark_node;
8923 if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
8925 if (complain & tf_error)
8926 error ("creating array of %qT, which is an abstract class type",
8928 return error_mark_node;
8931 r = build_cplus_array_type (type, domain);
8938 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
8939 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
8941 if (e1 == error_mark_node || e2 == error_mark_node)
8942 return error_mark_node;
8944 return fold_build2 (TREE_CODE (t), TREE_TYPE (t), e1, e2);
8950 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
8951 if (e == error_mark_node)
8952 return error_mark_node;
8954 return fold_build1 (TREE_CODE (t), TREE_TYPE (t), e);
8959 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
8960 in_decl, /*entering_scope=*/1);
8961 tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
8964 if (ctx == error_mark_node || f == error_mark_node)
8965 return error_mark_node;
8967 if (!IS_AGGR_TYPE (ctx))
8969 if (complain & tf_error)
8970 error ("%qT is not a class, struct, or union type", ctx);
8971 return error_mark_node;
8973 else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
8975 /* Normally, make_typename_type does not require that the CTX
8976 have complete type in order to allow things like:
8978 template <class T> struct S { typename S<T>::X Y; };
8980 But, such constructs have already been resolved by this
8981 point, so here CTX really should have complete type, unless
8982 it's a partial instantiation. */
8983 ctx = complete_type (ctx);
8984 if (!COMPLETE_TYPE_P (ctx))
8986 if (complain & tf_error)
8987 cxx_incomplete_type_error (NULL_TREE, ctx);
8988 return error_mark_node;
8992 f = make_typename_type (ctx, f, typename_type,
8993 (complain & tf_error) | tf_keep_type_decl);
8994 if (f == error_mark_node)
8996 if (TREE_CODE (f) == TYPE_DECL)
8998 complain |= tf_ignore_bad_quals;
9002 if (TREE_CODE (f) != TYPENAME_TYPE)
9004 if (TYPENAME_IS_ENUM_P (t) && TREE_CODE (f) != ENUMERAL_TYPE)
9005 error ("%qT resolves to %qT, which is not an enumeration type",
9007 else if (TYPENAME_IS_CLASS_P (t) && !CLASS_TYPE_P (f))
9008 error ("%qT resolves to %qT, which is is not a class type",
9012 return cp_build_qualified_type_real
9013 (f, cp_type_quals (f) | cp_type_quals (t), complain);
9016 case UNBOUND_CLASS_TEMPLATE:
9018 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
9019 in_decl, /*entering_scope=*/1);
9020 tree name = TYPE_IDENTIFIER (t);
9021 tree parm_list = DECL_TEMPLATE_PARMS (TYPE_NAME (t));
9023 if (ctx == error_mark_node || name == error_mark_node)
9024 return error_mark_node;
9027 parm_list = tsubst_template_parms (parm_list, args, complain);
9028 return make_unbound_class_template (ctx, name, parm_list, complain);
9038 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
9039 tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl,
9040 /*integral_constant_expression_p=*/false);
9041 if (e1 == error_mark_node || e2 == error_mark_node)
9042 return error_mark_node;
9044 return build_nt (ARRAY_REF, e1, e2, NULL_TREE, NULL_TREE);
9049 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
9050 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
9051 if (e1 == error_mark_node || e2 == error_mark_node)
9052 return error_mark_node;
9054 return build_qualified_name (/*type=*/NULL_TREE,
9055 e1, e2, QUALIFIED_NAME_IS_TEMPLATE (t));
9062 type = finish_typeof (tsubst_expr
9063 (TYPEOF_TYPE_EXPR (t), args,
9065 /*integral_constant_expression_p=*/false));
9066 return cp_build_qualified_type_real (type,
9068 | cp_type_quals (type),
9072 case TYPE_ARGUMENT_PACK:
9073 case NONTYPE_ARGUMENT_PACK:
9075 tree r = make_node (TREE_CODE (t));
9077 tsubst_template_args (ARGUMENT_PACK_ARGS (t),
9081 SET_ARGUMENT_PACK_ARGS (r, packed_out);
9083 /* For template nontype argument packs, also substitute into
9085 if (TREE_CODE (t) == NONTYPE_ARGUMENT_PACK)
9086 TREE_TYPE (r) = tsubst (TREE_TYPE (t), args, complain, in_decl);
9093 sorry ("use of %qs in template",
9094 tree_code_name [(int) TREE_CODE (t)]);
9095 return error_mark_node;
9099 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
9100 type of the expression on the left-hand side of the "." or "->"
9104 tsubst_baselink (tree baselink, tree object_type,
9105 tree args, tsubst_flags_t complain, tree in_decl)
9108 tree qualifying_scope;
9111 tree template_args = 0;
9112 bool template_id_p = false;
9114 /* A baselink indicates a function from a base class. Both the
9115 BASELINK_ACCESS_BINFO and the base class referenced may
9116 indicate bases of the template class, rather than the
9117 instantiated class. In addition, lookups that were not
9118 ambiguous before may be ambiguous now. Therefore, we perform
9119 the lookup again. */
9120 qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink));
9121 qualifying_scope = tsubst (qualifying_scope, args,
9123 fns = BASELINK_FUNCTIONS (baselink);
9124 optype = BASELINK_OPTYPE (baselink);
9125 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
9127 template_id_p = true;
9128 template_args = TREE_OPERAND (fns, 1);
9129 fns = TREE_OPERAND (fns, 0);
9131 template_args = tsubst_template_args (template_args, args,
9134 name = DECL_NAME (get_first_fn (fns));
9135 baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1);
9137 /* If lookup found a single function, mark it as used at this
9138 point. (If it lookup found multiple functions the one selected
9139 later by overload resolution will be marked as used at that
9141 if (BASELINK_P (baselink))
9142 fns = BASELINK_FUNCTIONS (baselink);
9143 if (!template_id_p && !really_overloaded_fn (fns))
9144 mark_used (OVL_CURRENT (fns));
9146 /* Add back the template arguments, if present. */
9147 if (BASELINK_P (baselink) && template_id_p)
9148 BASELINK_FUNCTIONS (baselink)
9149 = build_nt (TEMPLATE_ID_EXPR,
9150 BASELINK_FUNCTIONS (baselink),
9152 /* Update the conversion operator type. */
9153 BASELINK_OPTYPE (baselink)
9154 = tsubst (optype, args, complain, in_decl);
9157 object_type = current_class_type;
9158 return adjust_result_of_qualified_name_lookup (baselink,
9163 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
9164 true if the qualified-id will be a postfix-expression in-and-of
9165 itself; false if more of the postfix-expression follows the
9166 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
9170 tsubst_qualified_id (tree qualified_id, tree args,
9171 tsubst_flags_t complain, tree in_decl,
9172 bool done, bool address_p)
9180 gcc_assert (TREE_CODE (qualified_id) == SCOPE_REF);
9182 /* Figure out what name to look up. */
9183 name = TREE_OPERAND (qualified_id, 1);
9184 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
9187 template_args = TREE_OPERAND (name, 1);
9189 template_args = tsubst_template_args (template_args, args,
9191 name = TREE_OPERAND (name, 0);
9195 is_template = false;
9196 template_args = NULL_TREE;
9199 /* Substitute into the qualifying scope. When there are no ARGS, we
9200 are just trying to simplify a non-dependent expression. In that
9201 case the qualifying scope may be dependent, and, in any case,
9202 substituting will not help. */
9203 scope = TREE_OPERAND (qualified_id, 0);
9206 scope = tsubst (scope, args, complain, in_decl);
9207 expr = tsubst_copy (name, args, complain, in_decl);
9212 if (dependent_type_p (scope))
9213 return build_qualified_name (/*type=*/NULL_TREE,
9215 QUALIFIED_NAME_IS_TEMPLATE (qualified_id));
9217 if (!BASELINK_P (name) && !DECL_P (expr))
9219 if (TREE_CODE (expr) == BIT_NOT_EXPR)
9220 /* If this were actually a destructor call, it would have been
9221 parsed as such by the parser. */
9222 expr = error_mark_node;
9224 expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0, false);
9225 if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL
9226 ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL)
9228 if (complain & tf_error)
9230 error ("dependent-name %qE is parsed as a non-type, but "
9231 "instantiation yields a type", qualified_id);
9232 inform ("say %<typename %E%> if a type is meant", qualified_id);
9234 return error_mark_node;
9240 check_accessibility_of_qualified_id (expr, /*object_type=*/NULL_TREE,
9242 /* Remember that there was a reference to this entity. */
9246 if (expr == error_mark_node || TREE_CODE (expr) == TREE_LIST)
9248 if (complain & tf_error)
9249 qualified_name_lookup_error (scope,
9250 TREE_OPERAND (qualified_id, 1),
9252 return error_mark_node;
9256 expr = lookup_template_function (expr, template_args);
9258 if (expr == error_mark_node && complain & tf_error)
9259 qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1),
9261 else if (TYPE_P (scope))
9263 expr = (adjust_result_of_qualified_name_lookup
9264 (expr, scope, current_class_type));
9265 expr = (finish_qualified_id_expr
9266 (scope, expr, done, address_p,
9267 QUALIFIED_NAME_IS_TEMPLATE (qualified_id),
9268 /*template_arg_p=*/false));
9271 /* Expressions do not generally have reference type. */
9272 if (TREE_CODE (expr) != SCOPE_REF
9273 /* However, if we're about to form a pointer-to-member, we just
9274 want the referenced member referenced. */
9275 && TREE_CODE (expr) != OFFSET_REF)
9276 expr = convert_from_reference (expr);
9281 /* Like tsubst, but deals with expressions. This function just replaces
9282 template parms; to finish processing the resultant expression, use
9286 tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
9288 enum tree_code code;
9291 if (t == NULL_TREE || t == error_mark_node)
9294 code = TREE_CODE (t);
9299 r = retrieve_local_specialization (t);
9300 gcc_assert (r != NULL);
9301 if (TREE_CODE (r) == ARGUMENT_PACK_SELECT)
9302 r = ARGUMENT_PACK_SELECT_ARG (r);
9311 if (DECL_TEMPLATE_PARM_P (t))
9312 return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
9313 /* There is no need to substitute into namespace-scope
9315 if (DECL_NAMESPACE_SCOPE_P (t))
9317 /* If ARGS is NULL, then T is known to be non-dependent. */
9318 if (args == NULL_TREE)
9319 return integral_constant_value (t);
9321 /* Unfortunately, we cannot just call lookup_name here.
9324 template <int I> int f() {
9326 struct S { void g() { E e = a; } };
9329 When we instantiate f<7>::S::g(), say, lookup_name is not
9330 clever enough to find f<7>::a. */
9332 = tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl,
9333 /*entering_scope=*/0);
9335 for (v = TYPE_VALUES (enum_type);
9338 if (TREE_PURPOSE (v) == DECL_NAME (t))
9339 return TREE_VALUE (v);
9341 /* We didn't find the name. That should never happen; if
9342 name-lookup found it during preliminary parsing, we
9343 should find it again here during instantiation. */
9349 if (DECL_CONTEXT (t))
9353 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
9354 /*entering_scope=*/1);
9355 if (ctx != DECL_CONTEXT (t))
9357 tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
9360 if (complain & tf_error)
9361 error ("using invalid field %qD", t);
9362 return error_mark_node;
9372 if ((DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
9373 || local_variable_p (t))
9374 t = tsubst (t, args, complain, in_decl);
9379 return tsubst_baselink (t, current_class_type, args, complain, in_decl);
9382 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
9383 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
9384 args, complain, in_decl);
9385 else if (DECL_FUNCTION_TEMPLATE_P (t) && DECL_MEMBER_TEMPLATE_P (t))
9386 return tsubst (t, args, complain, in_decl);
9387 else if (DECL_CLASS_SCOPE_P (t)
9388 && uses_template_parms (DECL_CONTEXT (t)))
9390 /* Template template argument like the following example need
9393 template <template <class> class TT> struct C {};
9394 template <class T> struct D {
9395 template <class U> struct E {};
9400 We are processing the template argument `E' in #1 for
9401 the template instantiation #2. Originally, `E' is a
9402 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
9403 have to substitute this with one having context `D<int>'. */
9405 tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
9406 return lookup_field (context, DECL_NAME(t), 0, false);
9409 /* Ordinary template template argument. */
9413 case REINTERPRET_CAST_EXPR:
9414 case CONST_CAST_EXPR:
9415 case STATIC_CAST_EXPR:
9416 case DYNAMIC_CAST_EXPR:
9419 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
9420 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
9423 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
9425 /* We only want to compute the number of arguments. */
9426 tree expanded = tsubst_pack_expansion (TREE_OPERAND (t, 0), args,
9428 return build_int_cst (size_type_node, TREE_VEC_LENGTH (expanded));
9434 case TRUTH_NOT_EXPR:
9437 case UNARY_PLUS_EXPR: /* Unary + */
9445 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
9446 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
9453 object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
9454 name = TREE_OPERAND (t, 1);
9455 if (TREE_CODE (name) == BIT_NOT_EXPR)
9457 name = tsubst_copy (TREE_OPERAND (name, 0), args,
9459 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
9461 else if (TREE_CODE (name) == SCOPE_REF
9462 && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
9464 tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
9466 name = TREE_OPERAND (name, 1);
9467 name = tsubst_copy (TREE_OPERAND (name, 0), args,
9469 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
9470 name = build_qualified_name (/*type=*/NULL_TREE,
9472 /*template_p=*/false);
9474 else if (TREE_CODE (name) == BASELINK)
9475 name = tsubst_baselink (name,
9476 non_reference (TREE_TYPE (object)),
9480 name = tsubst_copy (name, args, complain, in_decl);
9481 return build_nt (COMPONENT_REF, object, name, NULL_TREE);
9487 case TRUNC_DIV_EXPR:
9489 case FLOOR_DIV_EXPR:
9490 case ROUND_DIV_EXPR:
9491 case EXACT_DIV_EXPR:
9495 case TRUNC_MOD_EXPR:
9496 case FLOOR_MOD_EXPR:
9497 case TRUTH_ANDIF_EXPR:
9498 case TRUTH_ORIF_EXPR:
9499 case TRUTH_AND_EXPR:
9516 case PREDECREMENT_EXPR:
9517 case PREINCREMENT_EXPR:
9518 case POSTDECREMENT_EXPR:
9519 case POSTINCREMENT_EXPR:
9521 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9522 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
9525 return build_qualified_name (/*type=*/NULL_TREE,
9526 tsubst_copy (TREE_OPERAND (t, 0),
9527 args, complain, in_decl),
9528 tsubst_copy (TREE_OPERAND (t, 1),
9529 args, complain, in_decl),
9530 QUALIFIED_NAME_IS_TEMPLATE (t));
9535 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9536 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
9537 NULL_TREE, NULL_TREE);
9541 int n = VL_EXP_OPERAND_LENGTH (t);
9542 tree result = build_vl_exp (CALL_EXPR, n);
9544 for (i = 0; i < n; i++)
9545 TREE_OPERAND (t, i) = tsubst_copy (TREE_OPERAND (t, i), args,
9552 case PSEUDO_DTOR_EXPR:
9555 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9556 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
9557 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
9558 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
9565 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9566 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
9567 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
9568 NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
9575 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9576 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
9577 DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
9578 DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
9582 case TEMPLATE_ID_EXPR:
9584 /* Substituted template arguments */
9585 tree fn = TREE_OPERAND (t, 0);
9586 tree targs = TREE_OPERAND (t, 1);
9588 fn = tsubst_copy (fn, args, complain, in_decl);
9590 targs = tsubst_template_args (targs, args, complain, in_decl);
9592 return lookup_template_function (fn, targs);
9597 tree purpose, value, chain;
9599 if (t == void_list_node)
9602 purpose = TREE_PURPOSE (t);
9604 purpose = tsubst_copy (purpose, args, complain, in_decl);
9605 value = TREE_VALUE (t);
9607 value = tsubst_copy (value, args, complain, in_decl);
9608 chain = TREE_CHAIN (t);
9609 if (chain && chain != void_type_node)
9610 chain = tsubst_copy (chain, args, complain, in_decl);
9611 if (purpose == TREE_PURPOSE (t)
9612 && value == TREE_VALUE (t)
9613 && chain == TREE_CHAIN (t))
9615 return tree_cons (purpose, value, chain);
9622 case TEMPLATE_TYPE_PARM:
9623 case TEMPLATE_TEMPLATE_PARM:
9624 case BOUND_TEMPLATE_TEMPLATE_PARM:
9625 case TEMPLATE_PARM_INDEX:
9627 case REFERENCE_TYPE:
9633 case UNBOUND_CLASS_TEMPLATE:
9636 return tsubst (t, args, complain, in_decl);
9638 case IDENTIFIER_NODE:
9639 if (IDENTIFIER_TYPENAME_P (t))
9641 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
9642 return mangle_conv_op_name_for_type (new_type);
9648 /* This is handled by tsubst_copy_and_build. */
9652 return build_x_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain,
9654 tsubst (TREE_TYPE (t), args, complain, in_decl));
9656 case CLEANUP_POINT_EXPR:
9657 /* We shouldn't have built any of these during initial template
9658 generation. Instead, they should be built during instantiation
9659 in response to the saved STMT_IS_FULL_EXPR_P setting. */
9663 mark_used (TREE_OPERAND (t, 1));
9666 case EXPR_PACK_EXPANSION:
9667 error ("invalid use of pack expansion expression");
9668 return error_mark_node;
9670 case NONTYPE_ARGUMENT_PACK:
9671 error ("use %<...%> to expand argument pack");
9672 return error_mark_node;
9679 /* Like tsubst_copy, but specifically for OpenMP clauses. */
9682 tsubst_omp_clauses (tree clauses, tree args, tsubst_flags_t complain,
9685 tree new_clauses = NULL, nc, oc;
9687 for (oc = clauses; oc ; oc = OMP_CLAUSE_CHAIN (oc))
9689 nc = copy_node (oc);
9690 OMP_CLAUSE_CHAIN (nc) = new_clauses;
9693 switch (OMP_CLAUSE_CODE (nc))
9695 case OMP_CLAUSE_PRIVATE:
9696 case OMP_CLAUSE_SHARED:
9697 case OMP_CLAUSE_FIRSTPRIVATE:
9698 case OMP_CLAUSE_LASTPRIVATE:
9699 case OMP_CLAUSE_REDUCTION:
9700 case OMP_CLAUSE_COPYIN:
9701 case OMP_CLAUSE_COPYPRIVATE:
9703 case OMP_CLAUSE_NUM_THREADS:
9704 case OMP_CLAUSE_SCHEDULE:
9705 OMP_CLAUSE_OPERAND (nc, 0)
9706 = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 0), args, complain,
9707 in_decl, /*integral_constant_expression_p=*/false);
9709 case OMP_CLAUSE_NOWAIT:
9710 case OMP_CLAUSE_ORDERED:
9711 case OMP_CLAUSE_DEFAULT:
9718 return finish_omp_clauses (nreverse (new_clauses));
9721 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
9724 tsubst_copy_asm_operands (tree t, tree args, tsubst_flags_t complain,
9727 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
9729 tree purpose, value, chain;
9734 if (TREE_CODE (t) != TREE_LIST)
9735 return tsubst_copy_and_build (t, args, complain, in_decl,
9736 /*function_p=*/false,
9737 /*integral_constant_expression_p=*/false);
9739 if (t == void_list_node)
9742 purpose = TREE_PURPOSE (t);
9744 purpose = RECUR (purpose);
9745 value = TREE_VALUE (t);
9747 value = RECUR (value);
9748 chain = TREE_CHAIN (t);
9749 if (chain && chain != void_type_node)
9750 chain = RECUR (chain);
9751 return tree_cons (purpose, value, chain);
9755 /* Like tsubst_copy for expressions, etc. but also does semantic
9759 tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl,
9760 bool integral_constant_expression_p)
9762 #define RECUR(NODE) \
9763 tsubst_expr ((NODE), args, complain, in_decl, \
9764 integral_constant_expression_p)
9768 if (t == NULL_TREE || t == error_mark_node)
9771 if (EXPR_HAS_LOCATION (t))
9772 input_location = EXPR_LOCATION (t);
9773 if (STATEMENT_CODE_P (TREE_CODE (t)))
9774 current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
9776 switch (TREE_CODE (t))
9778 case STATEMENT_LIST:
9780 tree_stmt_iterator i;
9781 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
9782 RECUR (tsi_stmt (i));
9786 case CTOR_INITIALIZER:
9787 finish_mem_initializers (tsubst_initializer_list
9788 (TREE_OPERAND (t, 0), args));
9792 finish_return_stmt (RECUR (TREE_OPERAND (t, 0)));
9796 tmp = RECUR (EXPR_STMT_EXPR (t));
9797 if (EXPR_STMT_STMT_EXPR_RESULT (t))
9798 finish_stmt_expr_expr (tmp, cur_stmt_expr);
9800 finish_expr_stmt (tmp);
9804 do_using_directive (RECUR (USING_STMT_NAMESPACE (t)));
9812 decl = DECL_EXPR_DECL (t);
9813 if (TREE_CODE (decl) == LABEL_DECL)
9814 finish_label_decl (DECL_NAME (decl));
9815 else if (TREE_CODE (decl) == USING_DECL)
9817 tree scope = USING_DECL_SCOPE (decl);
9818 tree name = DECL_NAME (decl);
9821 scope = RECUR (scope);
9822 decl = lookup_qualified_name (scope, name,
9823 /*is_type_p=*/false,
9824 /*complain=*/false);
9825 if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
9826 qualified_name_lookup_error (scope, name, decl);
9828 do_local_using_decl (decl, scope, name);
9832 init = DECL_INITIAL (decl);
9833 decl = tsubst (decl, args, complain, in_decl);
9834 if (decl != error_mark_node)
9836 /* By marking the declaration as instantiated, we avoid
9837 trying to instantiate it. Since instantiate_decl can't
9838 handle local variables, and since we've already done
9839 all that needs to be done, that's the right thing to
9841 if (TREE_CODE (decl) == VAR_DECL)
9842 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
9843 if (TREE_CODE (decl) == VAR_DECL
9844 && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
9845 /* Anonymous aggregates are a special case. */
9846 finish_anon_union (decl);
9849 maybe_push_decl (decl);
9850 if (TREE_CODE (decl) == VAR_DECL
9851 && DECL_PRETTY_FUNCTION_P (decl))
9853 /* For __PRETTY_FUNCTION__ we have to adjust the
9855 const char *const name
9856 = cxx_printable_name (current_function_decl, 2);
9857 init = cp_fname_init (name, &TREE_TYPE (decl));
9860 init = RECUR (init);
9861 finish_decl (decl, init, NULL_TREE);
9866 /* A DECL_EXPR can also be used as an expression, in the condition
9867 clause of an if/for/while construct. */
9872 stmt = begin_for_stmt ();
9873 RECUR (FOR_INIT_STMT (t));
9874 finish_for_init_stmt (stmt);
9875 tmp = RECUR (FOR_COND (t));
9876 finish_for_cond (tmp, stmt);
9877 tmp = RECUR (FOR_EXPR (t));
9878 finish_for_expr (tmp, stmt);
9879 RECUR (FOR_BODY (t));
9880 finish_for_stmt (stmt);
9884 stmt = begin_while_stmt ();
9885 tmp = RECUR (WHILE_COND (t));
9886 finish_while_stmt_cond (tmp, stmt);
9887 RECUR (WHILE_BODY (t));
9888 finish_while_stmt (stmt);
9892 stmt = begin_do_stmt ();
9893 RECUR (DO_BODY (t));
9894 finish_do_body (stmt);
9895 tmp = RECUR (DO_COND (t));
9896 finish_do_stmt (tmp, stmt);
9900 stmt = begin_if_stmt ();
9901 tmp = RECUR (IF_COND (t));
9902 finish_if_stmt_cond (tmp, stmt);
9903 RECUR (THEN_CLAUSE (t));
9904 finish_then_clause (stmt);
9906 if (ELSE_CLAUSE (t))
9908 begin_else_clause (stmt);
9909 RECUR (ELSE_CLAUSE (t));
9910 finish_else_clause (stmt);
9913 finish_if_stmt (stmt);
9917 if (BIND_EXPR_BODY_BLOCK (t))
9918 stmt = begin_function_body ();
9920 stmt = begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t)
9921 ? BCS_TRY_BLOCK : 0);
9923 RECUR (BIND_EXPR_BODY (t));
9925 if (BIND_EXPR_BODY_BLOCK (t))
9926 finish_function_body (stmt);
9928 finish_compound_stmt (stmt);
9932 finish_break_stmt ();
9936 finish_continue_stmt ();
9940 stmt = begin_switch_stmt ();
9941 tmp = RECUR (SWITCH_STMT_COND (t));
9942 finish_switch_cond (tmp, stmt);
9943 RECUR (SWITCH_STMT_BODY (t));
9944 finish_switch_stmt (stmt);
9947 case CASE_LABEL_EXPR:
9948 finish_case_label (RECUR (CASE_LOW (t)),
9949 RECUR (CASE_HIGH (t)));
9953 finish_label_stmt (DECL_NAME (LABEL_EXPR_LABEL (t)));
9957 tmp = GOTO_DESTINATION (t);
9958 if (TREE_CODE (tmp) != LABEL_DECL)
9959 /* Computed goto's must be tsubst'd into. On the other hand,
9960 non-computed gotos must not be; the identifier in question
9961 will have no binding. */
9964 tmp = DECL_NAME (tmp);
9965 finish_goto_stmt (tmp);
9969 tmp = finish_asm_stmt
9970 (ASM_VOLATILE_P (t),
9971 RECUR (ASM_STRING (t)),
9972 tsubst_copy_asm_operands (ASM_OUTPUTS (t), args, complain, in_decl),
9973 tsubst_copy_asm_operands (ASM_INPUTS (t), args, complain, in_decl),
9974 tsubst_copy_asm_operands (ASM_CLOBBERS (t), args, complain, in_decl));
9976 tree asm_expr = tmp;
9977 if (TREE_CODE (asm_expr) == CLEANUP_POINT_EXPR)
9978 asm_expr = TREE_OPERAND (asm_expr, 0);
9979 ASM_INPUT_P (asm_expr) = ASM_INPUT_P (t);
9986 stmt = begin_try_block ();
9987 RECUR (TRY_STMTS (t));
9988 finish_cleanup_try_block (stmt);
9989 finish_cleanup (RECUR (TRY_HANDLERS (t)), stmt);
9993 tree compound_stmt = NULL_TREE;
9995 if (FN_TRY_BLOCK_P (t))
9996 stmt = begin_function_try_block (&compound_stmt);
9998 stmt = begin_try_block ();
10000 RECUR (TRY_STMTS (t));
10002 if (FN_TRY_BLOCK_P (t))
10003 finish_function_try_block (stmt);
10005 finish_try_block (stmt);
10007 RECUR (TRY_HANDLERS (t));
10008 if (FN_TRY_BLOCK_P (t))
10009 finish_function_handler_sequence (stmt, compound_stmt);
10011 finish_handler_sequence (stmt);
10017 tree decl = HANDLER_PARMS (t);
10021 decl = tsubst (decl, args, complain, in_decl);
10022 /* Prevent instantiate_decl from trying to instantiate
10023 this variable. We've already done all that needs to be
10025 if (decl != error_mark_node)
10026 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
10028 stmt = begin_handler ();
10029 finish_handler_parms (decl, stmt);
10030 RECUR (HANDLER_BODY (t));
10031 finish_handler (stmt);
10036 tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
10039 case STATIC_ASSERT:
10042 tsubst_expr (STATIC_ASSERT_CONDITION (t),
10045 /*integral_constant_expression_p=*/true);
10046 finish_static_assert (condition,
10047 STATIC_ASSERT_MESSAGE (t),
10048 STATIC_ASSERT_SOURCE_LOCATION (t),
10049 /*member_p=*/false);
10054 tmp = tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t),
10055 args, complain, in_decl);
10056 stmt = begin_omp_parallel ();
10057 RECUR (OMP_PARALLEL_BODY (t));
10058 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp, stmt))
10059 = OMP_PARALLEL_COMBINED (t);
10064 tree clauses, decl, init, cond, incr, body, pre_body;
10066 clauses = tsubst_omp_clauses (OMP_FOR_CLAUSES (t),
10067 args, complain, in_decl);
10068 init = OMP_FOR_INIT (t);
10069 gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
10070 decl = RECUR (TREE_OPERAND (init, 0));
10071 init = RECUR (TREE_OPERAND (init, 1));
10072 cond = RECUR (OMP_FOR_COND (t));
10073 incr = RECUR (OMP_FOR_INCR (t));
10075 stmt = begin_omp_structured_block ();
10077 pre_body = push_stmt_list ();
10078 RECUR (OMP_FOR_PRE_BODY (t));
10079 pre_body = pop_stmt_list (pre_body);
10081 body = push_stmt_list ();
10082 RECUR (OMP_FOR_BODY (t));
10083 body = pop_stmt_list (body);
10085 t = finish_omp_for (EXPR_LOCATION (t), decl, init, cond, incr, body,
10088 OMP_FOR_CLAUSES (t) = clauses;
10090 add_stmt (finish_omp_structured_block (stmt));
10096 tmp = tsubst_omp_clauses (OMP_CLAUSES (t), args, complain, in_decl);
10097 stmt = push_stmt_list ();
10098 RECUR (OMP_BODY (t));
10099 stmt = pop_stmt_list (stmt);
10102 OMP_BODY (t) = stmt;
10103 OMP_CLAUSES (t) = tmp;
10111 stmt = push_stmt_list ();
10112 RECUR (OMP_BODY (t));
10113 stmt = pop_stmt_list (stmt);
10116 OMP_BODY (t) = stmt;
10121 if (OMP_ATOMIC_DEPENDENT_P (t))
10123 tree op1 = TREE_OPERAND (t, 1);
10124 tree lhs = RECUR (TREE_OPERAND (op1, 0));
10125 tree rhs = RECUR (TREE_OPERAND (op1, 1));
10126 finish_omp_atomic (TREE_CODE (op1), lhs, rhs);
10130 case EXPR_PACK_EXPANSION:
10131 error ("invalid use of pack expansion expression");
10132 return error_mark_node;
10134 case NONTYPE_ARGUMENT_PACK:
10135 error ("use %<...%> to expand argument pack");
10136 return error_mark_node;
10139 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t)));
10141 return tsubst_copy_and_build (t, args, complain, in_decl,
10142 /*function_p=*/false,
10143 integral_constant_expression_p);
10150 /* T is a postfix-expression that is not being used in a function
10151 call. Return the substituted version of T. */
10154 tsubst_non_call_postfix_expression (tree t, tree args,
10155 tsubst_flags_t complain,
10158 if (TREE_CODE (t) == SCOPE_REF)
10159 t = tsubst_qualified_id (t, args, complain, in_decl,
10160 /*done=*/false, /*address_p=*/false);
10162 t = tsubst_copy_and_build (t, args, complain, in_decl,
10163 /*function_p=*/false,
10164 /*integral_constant_expression_p=*/false);
10169 /* Like tsubst but deals with expressions and performs semantic
10170 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
10173 tsubst_copy_and_build (tree t,
10175 tsubst_flags_t complain,
10178 bool integral_constant_expression_p)
10180 #define RECUR(NODE) \
10181 tsubst_copy_and_build (NODE, args, complain, in_decl, \
10182 /*function_p=*/false, \
10183 integral_constant_expression_p)
10187 if (t == NULL_TREE || t == error_mark_node)
10190 switch (TREE_CODE (t))
10194 /* Fall through. */
10195 case IDENTIFIER_NODE:
10199 bool non_integral_constant_expression_p;
10200 const char *error_msg;
10202 if (IDENTIFIER_TYPENAME_P (t))
10204 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10205 t = mangle_conv_op_name_for_type (new_type);
10208 /* Look up the name. */
10209 decl = lookup_name (t);
10211 /* By convention, expressions use ERROR_MARK_NODE to indicate
10212 failure, not NULL_TREE. */
10213 if (decl == NULL_TREE)
10214 decl = error_mark_node;
10216 decl = finish_id_expression (t, decl, NULL_TREE,
10218 integral_constant_expression_p,
10219 /*allow_non_integral_constant_expression_p=*/false,
10220 &non_integral_constant_expression_p,
10221 /*template_p=*/false,
10223 /*address_p=*/false,
10224 /*template_arg_p=*/false,
10228 if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE)
10229 decl = unqualified_name_lookup_error (decl);
10233 case TEMPLATE_ID_EXPR:
10236 tree template = RECUR (TREE_OPERAND (t, 0));
10237 tree targs = TREE_OPERAND (t, 1);
10240 targs = tsubst_template_args (targs, args, complain, in_decl);
10242 if (TREE_CODE (template) == COMPONENT_REF)
10244 object = TREE_OPERAND (template, 0);
10245 template = TREE_OPERAND (template, 1);
10248 object = NULL_TREE;
10249 template = lookup_template_function (template, targs);
10252 return build3 (COMPONENT_REF, TREE_TYPE (template),
10253 object, template, NULL_TREE);
10255 return baselink_for_fns (template);
10260 tree r = RECUR (TREE_OPERAND (t, 0));
10262 if (REFERENCE_REF_P (t))
10264 /* A type conversion to reference type will be enclosed in
10265 such an indirect ref, but the substitution of the cast
10266 will have also added such an indirect ref. */
10267 if (TREE_CODE (TREE_TYPE (r)) == REFERENCE_TYPE)
10268 r = convert_from_reference (r);
10271 r = build_x_indirect_ref (r, "unary *");
10277 (tsubst (TREE_TYPE (t), args, complain, in_decl),
10278 RECUR (TREE_OPERAND (t, 0)));
10281 case REINTERPRET_CAST_EXPR:
10282 case CONST_CAST_EXPR:
10283 case DYNAMIC_CAST_EXPR:
10284 case STATIC_CAST_EXPR:
10289 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10290 if (integral_constant_expression_p
10291 && !cast_valid_in_integral_constant_expression_p (type))
10293 error ("a cast to a type other than an integral or "
10294 "enumeration type cannot appear in a constant-expression");
10295 return error_mark_node;
10298 op = RECUR (TREE_OPERAND (t, 0));
10300 switch (TREE_CODE (t))
10303 return build_functional_cast (type, op);
10304 case REINTERPRET_CAST_EXPR:
10305 return build_reinterpret_cast (type, op);
10306 case CONST_CAST_EXPR:
10307 return build_const_cast (type, op);
10308 case DYNAMIC_CAST_EXPR:
10309 return build_dynamic_cast (type, op);
10310 case STATIC_CAST_EXPR:
10311 return build_static_cast (type, op);
10313 gcc_unreachable ();
10317 case POSTDECREMENT_EXPR:
10318 case POSTINCREMENT_EXPR:
10319 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
10320 args, complain, in_decl);
10321 return build_x_unary_op (TREE_CODE (t), op1);
10323 case PREDECREMENT_EXPR:
10324 case PREINCREMENT_EXPR:
10328 case TRUTH_NOT_EXPR:
10329 case UNARY_PLUS_EXPR: /* Unary + */
10330 case REALPART_EXPR:
10331 case IMAGPART_EXPR:
10332 return build_x_unary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0)));
10335 op1 = TREE_OPERAND (t, 0);
10336 if (TREE_CODE (op1) == SCOPE_REF)
10337 op1 = tsubst_qualified_id (op1, args, complain, in_decl,
10338 /*done=*/true, /*address_p=*/true);
10340 op1 = tsubst_non_call_postfix_expression (op1, args, complain,
10342 if (TREE_CODE (op1) == LABEL_DECL)
10343 return finish_label_address_expr (DECL_NAME (op1));
10344 return build_x_unary_op (ADDR_EXPR, op1);
10349 case TRUNC_DIV_EXPR:
10350 case CEIL_DIV_EXPR:
10351 case FLOOR_DIV_EXPR:
10352 case ROUND_DIV_EXPR:
10353 case EXACT_DIV_EXPR:
10357 case TRUNC_MOD_EXPR:
10358 case FLOOR_MOD_EXPR:
10359 case TRUTH_ANDIF_EXPR:
10360 case TRUTH_ORIF_EXPR:
10361 case TRUTH_AND_EXPR:
10362 case TRUTH_OR_EXPR:
10377 return build_x_binary_op
10379 RECUR (TREE_OPERAND (t, 0)),
10380 (TREE_NO_WARNING (TREE_OPERAND (t, 0))
10382 : TREE_CODE (TREE_OPERAND (t, 0))),
10383 RECUR (TREE_OPERAND (t, 1)),
10384 (TREE_NO_WARNING (TREE_OPERAND (t, 1))
10386 : TREE_CODE (TREE_OPERAND (t, 1))),
10387 /*overloaded_p=*/NULL);
10390 return tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
10391 /*address_p=*/false);
10393 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
10394 args, complain, in_decl);
10395 return build_x_binary_op (ARRAY_REF, op1,
10396 (TREE_NO_WARNING (TREE_OPERAND (t, 0))
10398 : TREE_CODE (TREE_OPERAND (t, 0))),
10399 RECUR (TREE_OPERAND (t, 1)),
10400 (TREE_NO_WARNING (TREE_OPERAND (t, 1))
10402 : TREE_CODE (TREE_OPERAND (t, 1))),
10403 /*overloaded_p=*/NULL);
10406 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
10408 /* We only want to compute the number of arguments. */
10409 tree expanded = tsubst_pack_expansion (TREE_OPERAND (t, 0), args,
10410 complain, in_decl);
10411 return build_int_cst (size_type_node, TREE_VEC_LENGTH (expanded));
10416 op1 = TREE_OPERAND (t, 0);
10419 /* When there are no ARGS, we are trying to evaluate a
10420 non-dependent expression from the parser. Trying to do
10421 the substitutions may not work. */
10423 op1 = TREE_TYPE (op1);
10428 op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
10429 /*function_p=*/false,
10430 /*integral_constant_expression_p=*/false);
10434 return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t), true);
10436 return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t));
10440 tree r = build_x_modify_expr
10441 (RECUR (TREE_OPERAND (t, 0)),
10442 TREE_CODE (TREE_OPERAND (t, 1)),
10443 RECUR (TREE_OPERAND (t, 2)));
10444 /* TREE_NO_WARNING must be set if either the expression was
10445 parenthesized or it uses an operator such as >>= rather
10446 than plain assignment. In the former case, it was already
10447 set and must be copied. In the latter case,
10448 build_x_modify_expr sets it and it must not be reset
10450 if (TREE_NO_WARNING (t))
10451 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
10456 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
10457 args, complain, in_decl);
10458 /* Remember that there was a reference to this entity. */
10461 return build_x_arrow (op1);
10465 (RECUR (TREE_OPERAND (t, 0)),
10466 RECUR (TREE_OPERAND (t, 1)),
10467 RECUR (TREE_OPERAND (t, 2)),
10468 RECUR (TREE_OPERAND (t, 3)),
10469 NEW_EXPR_USE_GLOBAL (t));
10472 return delete_sanity
10473 (RECUR (TREE_OPERAND (t, 0)),
10474 RECUR (TREE_OPERAND (t, 1)),
10475 DELETE_EXPR_USE_VEC (t),
10476 DELETE_EXPR_USE_GLOBAL (t));
10478 case COMPOUND_EXPR:
10479 return build_x_compound_expr (RECUR (TREE_OPERAND (t, 0)),
10480 RECUR (TREE_OPERAND (t, 1)));
10489 function = CALL_EXPR_FN (t);
10490 /* When we parsed the expression, we determined whether or
10491 not Koenig lookup should be performed. */
10492 koenig_p = KOENIG_LOOKUP_P (t);
10493 if (TREE_CODE (function) == SCOPE_REF)
10495 qualified_p = true;
10496 function = tsubst_qualified_id (function, args, complain, in_decl,
10498 /*address_p=*/false);
10502 if (TREE_CODE (function) == COMPONENT_REF)
10504 tree op = TREE_OPERAND (function, 1);
10506 qualified_p = (TREE_CODE (op) == SCOPE_REF
10507 || (BASELINK_P (op)
10508 && BASELINK_QUALIFIED_P (op)));
10511 qualified_p = false;
10513 function = tsubst_copy_and_build (function, args, complain,
10516 integral_constant_expression_p);
10518 if (BASELINK_P (function))
10519 qualified_p = true;
10522 /* FIXME: Rewrite this so as not to construct an arglist. */
10523 call_args = RECUR (CALL_EXPR_ARGS (t));
10525 /* We do not perform argument-dependent lookup if normal
10526 lookup finds a non-function, in accordance with the
10527 expected resolution of DR 218. */
10529 && ((is_overloaded_fn (function)
10530 /* If lookup found a member function, the Koenig lookup is
10531 not appropriate, even if an unqualified-name was used
10532 to denote the function. */
10533 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function)))
10534 || TREE_CODE (function) == IDENTIFIER_NODE))
10535 function = perform_koenig_lookup (function, call_args);
10537 if (TREE_CODE (function) == IDENTIFIER_NODE)
10539 unqualified_name_lookup_error (function);
10540 return error_mark_node;
10543 /* Remember that there was a reference to this entity. */
10544 if (DECL_P (function))
10545 mark_used (function);
10547 if (TREE_CODE (function) == OFFSET_REF)
10548 return build_offset_ref_call_from_tree (function, call_args);
10549 if (TREE_CODE (function) == COMPONENT_REF)
10551 if (!BASELINK_P (TREE_OPERAND (function, 1)))
10552 return finish_call_expr (function, call_args,
10553 /*disallow_virtual=*/false,
10554 /*koenig_p=*/false);
10556 return (build_new_method_call
10557 (TREE_OPERAND (function, 0),
10558 TREE_OPERAND (function, 1),
10559 call_args, NULL_TREE,
10560 qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL,
10563 return finish_call_expr (function, call_args,
10564 /*disallow_virtual=*/qualified_p,
10569 return build_x_conditional_expr
10570 (RECUR (TREE_OPERAND (t, 0)),
10571 RECUR (TREE_OPERAND (t, 1)),
10572 RECUR (TREE_OPERAND (t, 2)));
10574 case PSEUDO_DTOR_EXPR:
10575 return finish_pseudo_destructor_expr
10576 (RECUR (TREE_OPERAND (t, 0)),
10577 RECUR (TREE_OPERAND (t, 1)),
10578 RECUR (TREE_OPERAND (t, 2)));
10582 tree purpose, value, chain;
10584 if (t == void_list_node)
10587 if ((TREE_PURPOSE (t) && PACK_EXPANSION_P (TREE_PURPOSE (t)))
10588 || (TREE_VALUE (t) && PACK_EXPANSION_P (TREE_VALUE (t))))
10590 /* We have pack expansions, so expand those and
10591 create a new list out of it. */
10592 tree purposevec = NULL_TREE;
10593 tree valuevec = NULL_TREE;
10597 /* Expand the argument expressions. */
10598 if (TREE_PURPOSE (t))
10599 purposevec = tsubst_pack_expansion (TREE_PURPOSE (t), args,
10600 complain, in_decl);
10601 if (TREE_VALUE (t))
10602 valuevec = tsubst_pack_expansion (TREE_VALUE (t), args,
10603 complain, in_decl);
10605 /* Build the rest of the list. */
10606 chain = TREE_CHAIN (t);
10607 if (chain && chain != void_type_node)
10608 chain = RECUR (chain);
10610 /* Determine the number of arguments. */
10611 if (purposevec && TREE_CODE (purposevec) == TREE_VEC)
10613 len = TREE_VEC_LENGTH (purposevec);
10614 gcc_assert (!valuevec || len == TREE_VEC_LENGTH (valuevec));
10616 else if (TREE_CODE (valuevec) == TREE_VEC)
10617 len = TREE_VEC_LENGTH (valuevec);
10620 /* Since we only performed a partial substitution into
10621 the argument pack, we only return a single list
10623 if (purposevec == TREE_PURPOSE (t)
10624 && valuevec == TREE_VALUE (t)
10625 && chain == TREE_CHAIN (t))
10628 return tree_cons (purposevec, valuevec, chain);
10631 /* Convert the argument vectors into a TREE_LIST */
10635 /* Grab the Ith values. */
10637 purpose = purposevec ? TREE_VEC_ELT (purposevec, i)
10640 = valuevec ? convert_from_reference (TREE_VEC_ELT (valuevec, i))
10643 /* Build the list (backwards). */
10644 chain = tree_cons (purpose, value, chain);
10650 purpose = TREE_PURPOSE (t);
10652 purpose = RECUR (purpose);
10653 value = TREE_VALUE (t);
10655 value = RECUR (value);
10656 chain = TREE_CHAIN (t);
10657 if (chain && chain != void_type_node)
10658 chain = RECUR (chain);
10659 if (purpose == TREE_PURPOSE (t)
10660 && value == TREE_VALUE (t)
10661 && chain == TREE_CHAIN (t))
10663 return tree_cons (purpose, value, chain);
10666 case COMPONENT_REF:
10672 object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
10673 args, complain, in_decl);
10674 /* Remember that there was a reference to this entity. */
10675 if (DECL_P (object))
10676 mark_used (object);
10677 object_type = TREE_TYPE (object);
10679 member = TREE_OPERAND (t, 1);
10680 if (BASELINK_P (member))
10681 member = tsubst_baselink (member,
10682 non_reference (TREE_TYPE (object)),
10683 args, complain, in_decl);
10685 member = tsubst_copy (member, args, complain, in_decl);
10686 if (member == error_mark_node)
10687 return error_mark_node;
10689 if (object_type && !CLASS_TYPE_P (object_type))
10691 if (TREE_CODE (member) == BIT_NOT_EXPR)
10692 return finish_pseudo_destructor_expr (object,
10695 else if (TREE_CODE (member) == SCOPE_REF
10696 && (TREE_CODE (TREE_OPERAND (member, 1)) == BIT_NOT_EXPR))
10697 return finish_pseudo_destructor_expr (object,
10701 else if (TREE_CODE (member) == SCOPE_REF
10702 && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
10707 /* Lookup the template functions now that we know what the
10709 tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
10710 args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
10711 member = lookup_qualified_name (TREE_OPERAND (member, 0), tmpl,
10712 /*is_type_p=*/false,
10713 /*complain=*/false);
10714 if (BASELINK_P (member))
10716 BASELINK_FUNCTIONS (member)
10717 = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
10719 member = (adjust_result_of_qualified_name_lookup
10720 (member, BINFO_TYPE (BASELINK_BINFO (member)),
10725 qualified_name_lookup_error (object_type, tmpl, member);
10726 return error_mark_node;
10729 else if (TREE_CODE (member) == SCOPE_REF
10730 && !CLASS_TYPE_P (TREE_OPERAND (member, 0))
10731 && TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL)
10733 if (complain & tf_error)
10735 if (TYPE_P (TREE_OPERAND (member, 0)))
10736 error ("%qT is not a class or namespace",
10737 TREE_OPERAND (member, 0));
10739 error ("%qD is not a class or namespace",
10740 TREE_OPERAND (member, 0));
10742 return error_mark_node;
10744 else if (TREE_CODE (member) == FIELD_DECL)
10745 return finish_non_static_data_member (member, object, NULL_TREE);
10747 return finish_class_member_access_expr (object, member,
10748 /*template_p=*/false);
10753 (RECUR (TREE_OPERAND (t, 0)));
10757 VEC(constructor_elt,gc) *n;
10758 constructor_elt *ce;
10759 unsigned HOST_WIDE_INT idx;
10760 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10761 bool process_index_p;
10763 bool need_copy_p = false;
10765 if (type == error_mark_node)
10766 return error_mark_node;
10768 /* digest_init will do the wrong thing if we let it. */
10769 if (type && TYPE_PTRMEMFUNC_P (type))
10772 /* We do not want to process the index of aggregate
10773 initializers as they are identifier nodes which will be
10774 looked up by digest_init. */
10775 process_index_p = !(type && IS_AGGR_TYPE (type));
10777 n = VEC_copy (constructor_elt, gc, CONSTRUCTOR_ELTS (t));
10778 newlen = VEC_length (constructor_elt, n);
10779 for (idx = 0; VEC_iterate (constructor_elt, n, idx, ce); idx++)
10781 if (ce->index && process_index_p)
10782 ce->index = RECUR (ce->index);
10784 if (PACK_EXPANSION_P (ce->value))
10786 /* Substitute into the pack expansion. */
10787 ce->value = tsubst_pack_expansion (ce->value, args, complain,
10790 if (TREE_VEC_LENGTH (ce->value) == 1)
10791 /* Just move the argument into place. */
10792 ce->value = TREE_VEC_ELT (ce->value, 0);
10795 /* Update the length of the final CONSTRUCTOR
10796 arguments vector, and note that we will need to
10798 newlen = newlen + TREE_VEC_LENGTH (ce->value) - 1;
10799 need_copy_p = true;
10803 ce->value = RECUR (ce->value);
10808 VEC(constructor_elt,gc) *old_n = n;
10810 n = VEC_alloc (constructor_elt, gc, newlen);
10811 for (idx = 0; VEC_iterate (constructor_elt, old_n, idx, ce);
10814 if (TREE_CODE (ce->value) == TREE_VEC)
10816 int i, len = TREE_VEC_LENGTH (ce->value);
10817 for (i = 0; i < len; ++i)
10818 CONSTRUCTOR_APPEND_ELT (n, 0,
10819 TREE_VEC_ELT (ce->value, i));
10822 CONSTRUCTOR_APPEND_ELT (n, 0, ce->value);
10826 if (TREE_HAS_CONSTRUCTOR (t))
10827 return finish_compound_literal (type, n);
10829 return build_constructor (NULL_TREE, n);
10834 tree operand_0 = RECUR (TREE_OPERAND (t, 0));
10835 if (TYPE_P (operand_0))
10836 return get_typeid (operand_0);
10837 return build_typeid (operand_0);
10847 tree r = tsubst_copy (t, args, complain, in_decl);
10849 if (TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
10850 /* If the original type was a reference, we'll be wrapped in
10851 the appropriate INDIRECT_REF. */
10852 r = convert_from_reference (r);
10857 return build_x_va_arg (RECUR (TREE_OPERAND (t, 0)),
10858 tsubst_copy (TREE_TYPE (t), args, complain,
10861 case OFFSETOF_EXPR:
10862 return finish_offsetof (RECUR (TREE_OPERAND (t, 0)));
10866 tree type1 = tsubst_copy (TRAIT_EXPR_TYPE1 (t), args,
10867 complain, in_decl);
10869 tree type2 = TRAIT_EXPR_TYPE2 (t);
10871 type2 = tsubst_copy (type2, args, complain, in_decl);
10873 return finish_trait_expr (TRAIT_EXPR_KIND (t), type1, type2);
10878 tree old_stmt_expr = cur_stmt_expr;
10879 tree stmt_expr = begin_stmt_expr ();
10881 cur_stmt_expr = stmt_expr;
10882 tsubst_expr (STMT_EXPR_STMT (t), args, complain, in_decl,
10883 integral_constant_expression_p);
10884 stmt_expr = finish_stmt_expr (stmt_expr, false);
10885 cur_stmt_expr = old_stmt_expr;
10891 t = tsubst_copy (t, args, complain, in_decl);
10892 /* As in finish_id_expression, we resolve enumeration constants
10893 to their underlying values. */
10894 if (TREE_CODE (t) == CONST_DECL)
10896 used_types_insert (TREE_TYPE (t));
10897 return DECL_INITIAL (t);
10902 /* Handle Objective-C++ constructs, if appropriate. */
10905 = objcp_tsubst_copy_and_build (t, args, complain,
10906 in_decl, /*function_p=*/false);
10910 return tsubst_copy (t, args, complain, in_decl);
10916 /* Verify that the instantiated ARGS are valid. For type arguments,
10917 make sure that the type's linkage is ok. For non-type arguments,
10918 make sure they are constants if they are integral or enumerations.
10919 Emit an error under control of COMPLAIN, and return TRUE on error. */
10922 check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain)
10924 int ix, len = DECL_NTPARMS (tmpl);
10925 bool result = false;
10927 for (ix = 0; ix != len; ix++)
10929 tree t = TREE_VEC_ELT (args, ix);
10933 /* [basic.link]: A name with no linkage (notably, the name
10934 of a class or enumeration declared in a local scope)
10935 shall not be used to declare an entity with linkage.
10936 This implies that names with no linkage cannot be used as
10937 template arguments. */
10938 tree nt = no_linkage_check (t, /*relaxed_p=*/false);
10942 /* DR 488 makes use of a type with no linkage cause
10943 type deduction to fail. */
10944 if (complain & tf_error)
10946 if (TYPE_ANONYMOUS_P (nt))
10947 error ("%qT is/uses anonymous type", t);
10949 error ("template argument for %qD uses local type %qT",
10954 /* In order to avoid all sorts of complications, we do not
10955 allow variably-modified types as template arguments. */
10956 else if (variably_modified_type_p (t, NULL_TREE))
10958 if (complain & tf_error)
10959 error ("%qT is a variably modified type", t);
10963 /* A non-type argument of integral or enumerated type must be a
10965 else if (TREE_TYPE (t)
10966 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t))
10967 && !TREE_CONSTANT (t))
10969 if (complain & tf_error)
10970 error ("integral expression %qE is not constant", t);
10974 if (result && (complain & tf_error))
10975 error (" trying to instantiate %qD", tmpl);
10979 /* Instantiate the indicated variable or function template TMPL with
10980 the template arguments in TARG_PTR. */
10983 instantiate_template (tree tmpl, tree targ_ptr, tsubst_flags_t complain)
10988 HOST_WIDE_INT saved_processing_template_decl;
10990 if (tmpl == error_mark_node)
10991 return error_mark_node;
10993 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
10995 /* If this function is a clone, handle it specially. */
10996 if (DECL_CLONED_FUNCTION_P (tmpl))
11001 spec = instantiate_template (DECL_CLONED_FUNCTION (tmpl), targ_ptr,
11003 if (spec == error_mark_node)
11004 return error_mark_node;
11006 /* Look for the clone. */
11007 FOR_EACH_CLONE (clone, spec)
11008 if (DECL_NAME (clone) == DECL_NAME (tmpl))
11010 /* We should always have found the clone by now. */
11011 gcc_unreachable ();
11015 /* Check to see if we already have this specialization. */
11016 spec = retrieve_specialization (tmpl, targ_ptr,
11017 /*class_specializations_p=*/false);
11018 if (spec != NULL_TREE)
11021 gen_tmpl = most_general_template (tmpl);
11022 if (tmpl != gen_tmpl)
11024 /* The TMPL is a partial instantiation. To get a full set of
11025 arguments we must add the arguments used to perform the
11026 partial instantiation. */
11027 targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl),
11030 /* Check to see if we already have this specialization. */
11031 spec = retrieve_specialization (gen_tmpl, targ_ptr,
11032 /*class_specializations_p=*/false);
11033 if (spec != NULL_TREE)
11037 if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr),
11039 return error_mark_node;
11041 /* We are building a FUNCTION_DECL, during which the access of its
11042 parameters and return types have to be checked. However this
11043 FUNCTION_DECL which is the desired context for access checking
11044 is not built yet. We solve this chicken-and-egg problem by
11045 deferring all checks until we have the FUNCTION_DECL. */
11046 push_deferring_access_checks (dk_deferred);
11048 /* Although PROCESSING_TEMPLATE_DECL may be true at this point
11049 (because, for example, we have encountered a non-dependent
11050 function call in the body of a template function and must now
11051 determine which of several overloaded functions will be called),
11052 within the instantiation itself we are not processing a
11054 saved_processing_template_decl = processing_template_decl;
11055 processing_template_decl = 0;
11056 /* Substitute template parameters to obtain the specialization. */
11057 fndecl = tsubst (DECL_TEMPLATE_RESULT (gen_tmpl),
11058 targ_ptr, complain, gen_tmpl);
11059 processing_template_decl = saved_processing_template_decl;
11060 if (fndecl == error_mark_node)
11061 return error_mark_node;
11063 /* Now we know the specialization, compute access previously
11065 push_access_scope (fndecl);
11066 perform_deferred_access_checks ();
11067 pop_access_scope (fndecl);
11068 pop_deferring_access_checks ();
11070 /* The DECL_TI_TEMPLATE should always be the immediate parent
11071 template, not the most general template. */
11072 DECL_TI_TEMPLATE (fndecl) = tmpl;
11074 /* If we've just instantiated the main entry point for a function,
11075 instantiate all the alternate entry points as well. We do this
11076 by cloning the instantiation of the main entry point, not by
11077 instantiating the template clones. */
11078 if (TREE_CHAIN (gen_tmpl) && DECL_CLONED_FUNCTION_P (TREE_CHAIN (gen_tmpl)))
11079 clone_function_decl (fndecl, /*update_method_vec_p=*/0);
11084 /* The FN is a TEMPLATE_DECL for a function. The ARGS are the
11085 arguments that are being used when calling it. TARGS is a vector
11086 into which the deduced template arguments are placed.
11088 Return zero for success, 2 for an incomplete match that doesn't resolve
11089 all the types, and 1 for complete failure. An error message will be
11090 printed only for an incomplete match.
11092 If FN is a conversion operator, or we are trying to produce a specific
11093 specialization, RETURN_TYPE is the return type desired.
11095 The EXPLICIT_TARGS are explicit template arguments provided via a
11098 The parameter STRICT is one of:
11101 We are deducing arguments for a function call, as in
11102 [temp.deduct.call].
11105 We are deducing arguments for a conversion function, as in
11106 [temp.deduct.conv].
11109 We are deducing arguments when doing an explicit instantiation
11110 as in [temp.explicit], when determining an explicit specialization
11111 as in [temp.expl.spec], or when taking the address of a function
11112 template, as in [temp.deduct.funcaddr]. */
11115 fn_type_unification (tree fn,
11116 tree explicit_targs,
11120 unification_kind_t strict,
11126 bool incomplete_argument_packs_p = false;
11128 gcc_assert (TREE_CODE (fn) == TEMPLATE_DECL);
11130 fntype = TREE_TYPE (fn);
11131 if (explicit_targs)
11135 The specified template arguments must match the template
11136 parameters in kind (i.e., type, nontype, template), and there
11137 must not be more arguments than there are parameters;
11138 otherwise type deduction fails.
11140 Nontype arguments must match the types of the corresponding
11141 nontype template parameters, or must be convertible to the
11142 types of the corresponding nontype parameters as specified in
11143 _temp.arg.nontype_, otherwise type deduction fails.
11145 All references in the function type of the function template
11146 to the corresponding template parameters are replaced by the
11147 specified template argument values. If a substitution in a
11148 template parameter or in the function type of the function
11149 template results in an invalid type, type deduction fails. */
11150 tree tparms = DECL_INNERMOST_TEMPLATE_PARMS (fn);
11151 int i, len = TREE_VEC_LENGTH (tparms);
11152 tree converted_args;
11153 bool incomplete = false;
11155 if (explicit_targs == error_mark_node)
11159 = (coerce_template_parms (tparms, explicit_targs, NULL_TREE, tf_none,
11160 /*require_all_args=*/false,
11161 /*use_default_args=*/false));
11162 if (converted_args == error_mark_node)
11165 /* Substitute the explicit args into the function type. This is
11166 necessary so that, for instance, explicitly declared function
11167 arguments can match null pointed constants. If we were given
11168 an incomplete set of explicit args, we must not do semantic
11169 processing during substitution as we could create partial
11171 for (i = 0; i < len; i++)
11173 tree parm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
11174 bool parameter_pack = false;
11176 /* Dig out the actual parm. */
11177 if (TREE_CODE (parm) == TYPE_DECL
11178 || TREE_CODE (parm) == TEMPLATE_DECL)
11180 parm = TREE_TYPE (parm);
11181 parameter_pack = TEMPLATE_TYPE_PARAMETER_PACK (parm);
11183 else if (TREE_CODE (parm) == PARM_DECL)
11185 parm = DECL_INITIAL (parm);
11186 parameter_pack = TEMPLATE_PARM_PARAMETER_PACK (parm);
11189 if (parameter_pack)
11193 template_parm_level_and_index (parm, &level, &idx);
11195 /* Mark the argument pack as "incomplete". We could
11196 still deduce more arguments during unification. */
11197 targ = TMPL_ARG (converted_args, level, idx);
11200 ARGUMENT_PACK_INCOMPLETE_P(targ) = 1;
11201 ARGUMENT_PACK_EXPLICIT_ARGS (targ)
11202 = ARGUMENT_PACK_ARGS (targ);
11205 /* We have some incomplete argument packs. */
11206 incomplete_argument_packs_p = true;
11210 if (incomplete_argument_packs_p)
11211 /* Any substitution is guaranteed to be incomplete if there
11212 are incomplete argument packs, because we can still deduce
11216 incomplete = NUM_TMPL_ARGS (explicit_targs) != NUM_TMPL_ARGS (targs);
11218 processing_template_decl += incomplete;
11219 fntype = tsubst (fntype, converted_args, tf_none, NULL_TREE);
11220 processing_template_decl -= incomplete;
11222 if (fntype == error_mark_node)
11225 /* Place the explicitly specified arguments in TARGS. */
11226 for (i = NUM_TMPL_ARGS (converted_args); i--;)
11227 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i);
11230 /* Never do unification on the 'this' parameter. */
11231 parms = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (fntype));
11235 parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms);
11236 args = tree_cons (NULL_TREE, return_type, args);
11239 /* We allow incomplete unification without an error message here
11240 because the standard doesn't seem to explicitly prohibit it. Our
11241 callers must be ready to deal with unification failures in any
11243 result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
11244 targs, parms, args, /*subr=*/0,
11247 if (result == 0 && incomplete_argument_packs_p)
11249 int i, len = NUM_TMPL_ARGS (targs);
11251 /* Clear the "incomplete" flags on all argument packs. */
11252 for (i = 0; i < len; i++)
11254 tree arg = TREE_VEC_ELT (targs, i);
11255 if (ARGUMENT_PACK_P (arg))
11257 ARGUMENT_PACK_INCOMPLETE_P (arg) = 0;
11258 ARGUMENT_PACK_EXPLICIT_ARGS (arg) = NULL_TREE;
11264 /* All is well so far. Now, check:
11268 When all template arguments have been deduced, all uses of
11269 template parameters in nondeduced contexts are replaced with
11270 the corresponding deduced argument values. If the
11271 substitution results in an invalid type, as described above,
11272 type deduction fails. */
11273 if (tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE)
11274 == error_mark_node)
11280 /* Adjust types before performing type deduction, as described in
11281 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
11282 sections are symmetric. PARM is the type of a function parameter
11283 or the return type of the conversion function. ARG is the type of
11284 the argument passed to the call, or the type of the value
11285 initialized with the result of the conversion function.
11286 ARG_EXPR is the original argument expression, which may be null. */
11289 maybe_adjust_types_for_deduction (unification_kind_t strict,
11303 /* Swap PARM and ARG throughout the remainder of this
11304 function; the handling is precisely symmetric since PARM
11305 will initialize ARG rather than vice versa. */
11313 /* There is nothing to do in this case. */
11317 gcc_unreachable ();
11320 if (TREE_CODE (*parm) != REFERENCE_TYPE)
11322 /* [temp.deduct.call]
11324 If P is not a reference type:
11326 --If A is an array type, the pointer type produced by the
11327 array-to-pointer standard conversion (_conv.array_) is
11328 used in place of A for type deduction; otherwise,
11330 --If A is a function type, the pointer type produced by
11331 the function-to-pointer standard conversion
11332 (_conv.func_) is used in place of A for type deduction;
11335 --If A is a cv-qualified type, the top level
11336 cv-qualifiers of A's type are ignored for type
11338 if (TREE_CODE (*arg) == ARRAY_TYPE)
11339 *arg = build_pointer_type (TREE_TYPE (*arg));
11340 else if (TREE_CODE (*arg) == FUNCTION_TYPE)
11341 *arg = build_pointer_type (*arg);
11343 *arg = TYPE_MAIN_VARIANT (*arg);
11346 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
11347 of the form T&&, where T is a template parameter, and the argument
11348 is an lvalue, T is deduced as A& */
11349 if (TREE_CODE (*parm) == REFERENCE_TYPE
11350 && TYPE_REF_IS_RVALUE (*parm)
11351 && TREE_CODE (TREE_TYPE (*parm)) == TEMPLATE_TYPE_PARM
11352 && cp_type_quals (TREE_TYPE (*parm)) == TYPE_UNQUALIFIED
11353 && arg_expr && real_lvalue_p (arg_expr))
11354 *arg = build_reference_type (*arg);
11356 /* [temp.deduct.call]
11358 If P is a cv-qualified type, the top level cv-qualifiers
11359 of P's type are ignored for type deduction. If P is a
11360 reference type, the type referred to by P is used for
11362 *parm = TYPE_MAIN_VARIANT (*parm);
11363 if (TREE_CODE (*parm) == REFERENCE_TYPE)
11365 *parm = TREE_TYPE (*parm);
11366 result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
11369 /* DR 322. For conversion deduction, remove a reference type on parm
11370 too (which has been swapped into ARG). */
11371 if (strict == DEDUCE_CONV && TREE_CODE (*arg) == REFERENCE_TYPE)
11372 *arg = TREE_TYPE (*arg);
11377 /* Most parms like fn_type_unification.
11379 If SUBR is 1, we're being called recursively (to unify the
11380 arguments of a function or method parameter of a function
11384 type_unification_real (tree tparms,
11389 unification_kind_t strict,
11392 tree parm, arg, arg_expr;
11394 int ntparms = TREE_VEC_LENGTH (tparms);
11396 int saw_undeduced = 0;
11399 gcc_assert (TREE_CODE (tparms) == TREE_VEC);
11400 gcc_assert (xparms == NULL_TREE || TREE_CODE (xparms) == TREE_LIST);
11401 gcc_assert (!xargs || TREE_CODE (xargs) == TREE_LIST);
11402 gcc_assert (ntparms > 0);
11407 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL | UNIFY_ALLOW_MORE_CV_QUAL
11408 | UNIFY_ALLOW_DERIVED);
11412 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
11416 sub_strict = UNIFY_ALLOW_NONE;
11420 gcc_unreachable ();
11427 while (parms && parms != void_list_node
11428 && args && args != void_list_node)
11430 if (TREE_CODE (TREE_VALUE (parms)) == TYPE_PACK_EXPANSION)
11433 parm = TREE_VALUE (parms);
11434 parms = TREE_CHAIN (parms);
11435 arg = TREE_VALUE (args);
11436 args = TREE_CHAIN (args);
11439 if (arg == error_mark_node)
11441 if (arg == unknown_type_node)
11442 /* We can't deduce anything from this, but we might get all the
11443 template args from other function args. */
11446 /* Conversions will be performed on a function argument that
11447 corresponds with a function parameter that contains only
11448 non-deducible template parameters and explicitly specified
11449 template parameters. */
11450 if (!uses_template_parms (parm))
11455 type = TREE_TYPE (arg);
11459 if (same_type_p (parm, type))
11461 if (strict != DEDUCE_EXACT
11462 && can_convert_arg (parm, type, TYPE_P (arg) ? NULL_TREE : arg,
11471 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
11472 if (type_unknown_p (arg))
11474 /* [temp.deduct.type]
11476 A template-argument can be deduced from a pointer to
11477 function or pointer to member function argument if
11478 the set of overloaded functions does not contain
11479 function templates and at most one of a set of
11480 overloaded functions provides a unique match. */
11481 if (resolve_overloaded_unification
11482 (tparms, targs, parm, arg, strict, sub_strict))
11488 arg = unlowered_expr_type (arg);
11489 if (arg == error_mark_node)
11494 int arg_strict = sub_strict;
11497 arg_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg,
11500 if (unify (tparms, targs, parm, arg, arg_strict))
11507 && parms != void_list_node
11508 && TREE_CODE (TREE_VALUE (parms)) == TYPE_PACK_EXPANSION)
11510 /* Unify the remaining arguments with the pack expansion type. */
11512 tree parmvec = make_tree_vec (1);
11516 /* Count the number of arguments that remain. */
11517 for (t = args; t && t != void_list_node; t = TREE_CHAIN (t))
11520 /* Allocate a TREE_VEC and copy in all of the arguments */
11521 argvec = make_tree_vec (len);
11522 for (i = 0; args && args != void_list_node; args = TREE_CHAIN (args))
11524 TREE_VEC_ELT (argvec, i) = TREE_VALUE (args);
11528 /* Copy the parameter into parmvec. */
11529 TREE_VEC_ELT (parmvec, 0) = TREE_VALUE (parms);
11530 if (unify_pack_expansion (tparms, targs, parmvec, argvec, strict,
11531 /*call_args_p=*/true, /*subr=*/subr))
11534 /* Advance to the end of the list of parameters. */
11535 parms = TREE_CHAIN (parms);
11538 /* Fail if we've reached the end of the parm list, and more args
11539 are present, and the parm list isn't variadic. */
11540 if (args && args != void_list_node && parms == void_list_node)
11542 /* Fail if parms are left and they don't have default values. */
11543 if (parms && parms != void_list_node
11544 && TREE_PURPOSE (parms) == NULL_TREE)
11548 for (i = 0; i < ntparms; i++)
11549 if (!TREE_VEC_ELT (targs, i))
11553 if (TREE_VEC_ELT (tparms, i) == error_mark_node)
11556 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
11558 /* If this is an undeduced nontype parameter that depends on
11559 a type parameter, try another pass; its type may have been
11560 deduced from a later argument than the one from which
11561 this parameter can be deduced. */
11562 if (TREE_CODE (tparm) == PARM_DECL
11563 && uses_template_parms (TREE_TYPE (tparm))
11564 && !saw_undeduced++)
11567 /* Core issue #226 (C++0x) [temp.deduct]:
11569 If a template argument has not been deduced, its
11570 default template argument, if any, is used.
11572 When we are in C++98 mode, TREE_PURPOSE will either
11573 be NULL_TREE or ERROR_MARK_NODE, so we do not need
11574 to explicitly check cxx_dialect here. */
11575 if (TREE_PURPOSE (TREE_VEC_ELT (tparms, i)))
11577 tree arg = tsubst (TREE_PURPOSE (TREE_VEC_ELT (tparms, i)),
11578 targs, tf_none, NULL_TREE);
11579 if (arg == error_mark_node)
11583 TREE_VEC_ELT (targs, i) = arg;
11588 /* If the type parameter is a parameter pack, then it will
11589 be deduced to an empty parameter pack. */
11590 if (template_parameter_pack_p (tparm))
11594 if (TREE_CODE (tparm) == TEMPLATE_PARM_INDEX)
11596 arg = make_node (NONTYPE_ARGUMENT_PACK);
11597 TREE_TYPE (arg) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm));
11598 TREE_CONSTANT (arg) = 1;
11601 arg = make_node (TYPE_ARGUMENT_PACK);
11603 SET_ARGUMENT_PACK_ARGS (arg, make_tree_vec (0));
11605 TREE_VEC_ELT (targs, i) = arg;
11615 /* Subroutine of type_unification_real. Args are like the variables
11616 at the call site. ARG is an overloaded function (or template-id);
11617 we try deducing template args from each of the overloads, and if
11618 only one succeeds, we go with that. Modifies TARGS and returns
11619 true on success. */
11622 resolve_overloaded_unification (tree tparms,
11626 unification_kind_t strict,
11629 tree tempargs = copy_node (targs);
11633 if (TREE_CODE (arg) == ADDR_EXPR)
11635 arg = TREE_OPERAND (arg, 0);
11641 if (TREE_CODE (arg) == COMPONENT_REF)
11642 /* Handle `&x' where `x' is some static or non-static member
11644 arg = TREE_OPERAND (arg, 1);
11646 if (TREE_CODE (arg) == OFFSET_REF)
11647 arg = TREE_OPERAND (arg, 1);
11649 /* Strip baselink information. */
11650 if (BASELINK_P (arg))
11651 arg = BASELINK_FUNCTIONS (arg);
11653 if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
11655 /* If we got some explicit template args, we need to plug them into
11656 the affected templates before we try to unify, in case the
11657 explicit args will completely resolve the templates in question. */
11659 tree expl_subargs = TREE_OPERAND (arg, 1);
11660 arg = TREE_OPERAND (arg, 0);
11662 for (; arg; arg = OVL_NEXT (arg))
11664 tree fn = OVL_CURRENT (arg);
11665 tree subargs, elem;
11667 if (TREE_CODE (fn) != TEMPLATE_DECL)
11670 subargs = get_bindings (fn, DECL_TEMPLATE_RESULT (fn),
11671 expl_subargs, /*check_ret=*/false);
11674 elem = tsubst (TREE_TYPE (fn), subargs, tf_none, NULL_TREE);
11675 good += try_one_overload (tparms, targs, tempargs, parm,
11676 elem, strict, sub_strict, addr_p);
11680 else if (TREE_CODE (arg) != OVERLOAD
11681 && TREE_CODE (arg) != FUNCTION_DECL)
11682 /* If ARG is, for example, "(0, &f)" then its type will be unknown
11683 -- but the deduction does not succeed because the expression is
11684 not just the function on its own. */
11687 for (; arg; arg = OVL_NEXT (arg))
11688 good += try_one_overload (tparms, targs, tempargs, parm,
11689 TREE_TYPE (OVL_CURRENT (arg)),
11690 strict, sub_strict, addr_p);
11692 /* [temp.deduct.type] A template-argument can be deduced from a pointer
11693 to function or pointer to member function argument if the set of
11694 overloaded functions does not contain function templates and at most
11695 one of a set of overloaded functions provides a unique match.
11697 So if we found multiple possibilities, we return success but don't
11698 deduce anything. */
11702 int i = TREE_VEC_LENGTH (targs);
11704 if (TREE_VEC_ELT (tempargs, i))
11705 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i);
11713 /* Subroutine of resolve_overloaded_unification; does deduction for a single
11714 overload. Fills TARGS with any deduced arguments, or error_mark_node if
11715 different overloads deduce different arguments for a given parm.
11716 ADDR_P is true if the expression for which deduction is being
11717 performed was of the form "& fn" rather than simply "fn".
11719 Returns 1 on success. */
11722 try_one_overload (tree tparms,
11727 unification_kind_t strict,
11735 /* [temp.deduct.type] A template-argument can be deduced from a pointer
11736 to function or pointer to member function argument if the set of
11737 overloaded functions does not contain function templates and at most
11738 one of a set of overloaded functions provides a unique match.
11740 So if this is a template, just return success. */
11742 if (uses_template_parms (arg))
11745 if (TREE_CODE (arg) == METHOD_TYPE)
11746 arg = build_ptrmemfunc_type (build_pointer_type (arg));
11748 arg = build_pointer_type (arg);
11750 sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg, NULL);
11752 /* We don't copy orig_targs for this because if we have already deduced
11753 some template args from previous args, unify would complain when we
11754 try to deduce a template parameter for the same argument, even though
11755 there isn't really a conflict. */
11756 nargs = TREE_VEC_LENGTH (targs);
11757 tempargs = make_tree_vec (nargs);
11759 if (unify (tparms, tempargs, parm, arg, sub_strict) != 0)
11762 /* First make sure we didn't deduce anything that conflicts with
11763 explicitly specified args. */
11764 for (i = nargs; i--; )
11766 tree elt = TREE_VEC_ELT (tempargs, i);
11767 tree oldelt = TREE_VEC_ELT (orig_targs, i);
11771 else if (uses_template_parms (elt))
11772 /* Since we're unifying against ourselves, we will fill in
11773 template args used in the function parm list with our own
11774 template parms. Discard them. */
11775 TREE_VEC_ELT (tempargs, i) = NULL_TREE;
11776 else if (oldelt && !template_args_equal (oldelt, elt))
11780 for (i = nargs; i--; )
11782 tree elt = TREE_VEC_ELT (tempargs, i);
11785 TREE_VEC_ELT (targs, i) = elt;
11791 /* PARM is a template class (perhaps with unbound template
11792 parameters). ARG is a fully instantiated type. If ARG can be
11793 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
11794 TARGS are as for unify. */
11797 try_class_unification (tree tparms, tree targs, tree parm, tree arg)
11799 tree copy_of_targs;
11801 if (!CLASSTYPE_TEMPLATE_INFO (arg)
11802 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg))
11803 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm))))
11806 /* We need to make a new template argument vector for the call to
11807 unify. If we used TARGS, we'd clutter it up with the result of
11808 the attempted unification, even if this class didn't work out.
11809 We also don't want to commit ourselves to all the unifications
11810 we've already done, since unification is supposed to be done on
11811 an argument-by-argument basis. In other words, consider the
11812 following pathological case:
11814 template <int I, int J, int K>
11817 template <int I, int J>
11818 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
11820 template <int I, int J, int K>
11821 void f(S<I, J, K>, S<I, I, I>);
11830 Now, by the time we consider the unification involving `s2', we
11831 already know that we must have `f<0, 0, 0>'. But, even though
11832 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
11833 because there are two ways to unify base classes of S<0, 1, 2>
11834 with S<I, I, I>. If we kept the already deduced knowledge, we
11835 would reject the possibility I=1. */
11836 copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs));
11838 /* If unification failed, we're done. */
11839 if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm),
11840 CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE))
11846 /* Given a template type PARM and a class type ARG, find the unique
11847 base type in ARG that is an instance of PARM. We do not examine
11848 ARG itself; only its base-classes. If there is not exactly one
11849 appropriate base class, return NULL_TREE. PARM may be the type of
11850 a partial specialization, as well as a plain template type. Used
11854 get_template_base (tree tparms, tree targs, tree parm, tree arg)
11856 tree rval = NULL_TREE;
11859 gcc_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg)));
11861 binfo = TYPE_BINFO (complete_type (arg));
11863 /* The type could not be completed. */
11866 /* Walk in inheritance graph order. The search order is not
11867 important, and this avoids multiple walks of virtual bases. */
11868 for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo))
11870 tree r = try_class_unification (tparms, targs, parm, BINFO_TYPE (binfo));
11874 /* If there is more than one satisfactory baseclass, then:
11878 If they yield more than one possible deduced A, the type
11882 if (rval && !same_type_p (r, rval))
11892 /* Returns the level of DECL, which declares a template parameter. */
11895 template_decl_level (tree decl)
11897 switch (TREE_CODE (decl))
11900 case TEMPLATE_DECL:
11901 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl));
11904 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
11907 gcc_unreachable ();
11912 /* Decide whether ARG can be unified with PARM, considering only the
11913 cv-qualifiers of each type, given STRICT as documented for unify.
11914 Returns nonzero iff the unification is OK on that basis. */
11917 check_cv_quals_for_unify (int strict, tree arg, tree parm)
11919 int arg_quals = cp_type_quals (arg);
11920 int parm_quals = cp_type_quals (parm);
11922 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
11923 && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
11925 /* Although a CVR qualifier is ignored when being applied to a
11926 substituted template parameter ([8.3.2]/1 for example), that
11927 does not apply during deduction [14.8.2.4]/1, (even though
11928 that is not explicitly mentioned, [14.8.2.4]/9 indicates
11929 this). Except when we're allowing additional CV qualifiers
11930 at the outer level [14.8.2.1]/3,1st bullet. */
11931 if ((TREE_CODE (arg) == REFERENCE_TYPE
11932 || TREE_CODE (arg) == FUNCTION_TYPE
11933 || TREE_CODE (arg) == METHOD_TYPE)
11934 && (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)))
11937 if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
11938 && (parm_quals & TYPE_QUAL_RESTRICT))
11942 if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
11943 && (arg_quals & parm_quals) != parm_quals)
11946 if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL))
11947 && (parm_quals & arg_quals) != arg_quals)
11953 /* Determines the LEVEL and INDEX for the template parameter PARM. */
11955 template_parm_level_and_index (tree parm, int* level, int* index)
11957 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
11958 || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
11959 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
11961 *index = TEMPLATE_TYPE_IDX (parm);
11962 *level = TEMPLATE_TYPE_LEVEL (parm);
11966 *index = TEMPLATE_PARM_IDX (parm);
11967 *level = TEMPLATE_PARM_LEVEL (parm);
11971 /* Unifies the remaining arguments in PACKED_ARGS with the pack
11972 expansion at the end of PACKED_PARMS. Returns 0 if the type
11973 deduction succeeds, 1 otherwise. STRICT is the same as in
11974 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
11975 call argument list. We'll need to adjust the arguments to make them
11976 types. SUBR tells us if this is from a recursive call to
11977 type_unification_real. */
11979 unify_pack_expansion (tree tparms, tree targs, tree packed_parms,
11980 tree packed_args, int strict, bool call_args_p,
11984 = TREE_VEC_ELT (packed_parms, TREE_VEC_LENGTH (packed_parms) - 1);
11985 tree pattern = PACK_EXPANSION_PATTERN (parm);
11986 tree pack, packs = NULL_TREE;
11987 int i, start = TREE_VEC_LENGTH (packed_parms) - 1;
11988 int len = TREE_VEC_LENGTH (packed_args);
11990 /* Determine the parameter packs we will be deducing from the
11991 pattern, and record their current deductions. */
11992 for (pack = PACK_EXPANSION_PARAMETER_PACKS (parm);
11993 pack; pack = TREE_CHAIN (pack))
11995 tree parm_pack = TREE_VALUE (pack);
11998 /* Determine the index and level of this parameter pack. */
11999 template_parm_level_and_index (parm_pack, &level, &idx);
12001 /* Keep track of the parameter packs and their corresponding
12003 packs = tree_cons (parm_pack, TMPL_ARG (targs, level, idx), packs);
12004 TREE_TYPE (packs) = make_tree_vec (len - start);
12007 /* Loop through all of the arguments that have not yet been
12008 unified and unify each with the pattern. */
12009 for (i = start; i < len; i++)
12011 tree parm = pattern;
12013 /* For each parameter pack, clear out the deduced value so that
12014 we can deduce it again. */
12015 for (pack = packs; pack; pack = TREE_CHAIN (pack))
12018 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12020 TMPL_ARG (targs, level, idx) = NULL_TREE;
12023 /* Unify the pattern with the current argument. */
12025 tree arg = TREE_VEC_ELT (packed_args, i);
12026 int arg_strict = strict;
12027 bool skip_arg_p = false;
12033 /* This mirrors what we do in type_unification_real. */
12037 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL
12038 | UNIFY_ALLOW_MORE_CV_QUAL
12039 | UNIFY_ALLOW_DERIVED);
12043 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
12047 sub_strict = UNIFY_ALLOW_NONE;
12051 gcc_unreachable ();
12056 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
12057 if (type_unknown_p (arg))
12059 /* [temp.deduct.type] A template-argument can be
12060 deduced from a pointer to function or pointer
12061 to member function argument if the set of
12062 overloaded functions does not contain function
12063 templates and at most one of a set of
12064 overloaded functions provides a unique
12067 if (resolve_overloaded_unification
12068 (tparms, targs, parm, arg, strict, sub_strict)
12076 arg = TREE_TYPE (arg);
12077 if (arg == error_mark_node)
12082 arg_strict = sub_strict;
12086 maybe_adjust_types_for_deduction (strict, &parm, &arg, NULL);
12091 if (unify (tparms, targs, parm, arg, arg_strict))
12096 /* For each parameter pack, collect the deduced value. */
12097 for (pack = packs; pack; pack = TREE_CHAIN (pack))
12100 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12102 TREE_VEC_ELT (TREE_TYPE (pack), i - start) =
12103 TMPL_ARG (targs, level, idx);
12107 /* Verify that the results of unification with the parameter packs
12108 produce results consistent with what we've seen before, and make
12109 the deduced argument packs available. */
12110 for (pack = packs; pack; pack = TREE_CHAIN (pack))
12112 tree old_pack = TREE_VALUE (pack);
12113 tree new_args = TREE_TYPE (pack);
12115 if (old_pack && ARGUMENT_PACK_INCOMPLETE_P (old_pack))
12117 /* Prepend the explicit arguments onto NEW_ARGS. */
12118 tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
12119 tree old_args = new_args;
12120 int i, explicit_len = TREE_VEC_LENGTH (explicit_args);
12121 int len = explicit_len + TREE_VEC_LENGTH (old_args);
12123 /* Copy the explicit arguments. */
12124 new_args = make_tree_vec (len);
12125 for (i = 0; i < explicit_len; i++)
12126 TREE_VEC_ELT (new_args, i) = TREE_VEC_ELT (explicit_args, i);
12128 /* Copy the deduced arguments. */
12129 for (; i < len; i++)
12130 TREE_VEC_ELT (new_args, i) =
12131 TREE_VEC_ELT (old_args, i - explicit_len);
12139 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12141 /* Build the deduced *_ARGUMENT_PACK. */
12142 if (TREE_CODE (TREE_PURPOSE (pack)) == TEMPLATE_PARM_INDEX)
12144 result = make_node (NONTYPE_ARGUMENT_PACK);
12145 TREE_TYPE (result) =
12146 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack)));
12147 TREE_CONSTANT (result) = 1;
12150 result = make_node (TYPE_ARGUMENT_PACK);
12152 SET_ARGUMENT_PACK_ARGS (result, new_args);
12154 /* Note the deduced argument packs for this parameter
12156 TMPL_ARG (targs, level, idx) = result;
12158 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack)
12159 && (ARGUMENT_PACK_ARGS (old_pack)
12160 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack)))
12162 /* We only had the explicitly-provided arguments before, but
12163 now we have a complete set of arguments. */
12165 tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
12166 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12168 /* Keep the original deduced argument pack. */
12169 TMPL_ARG (targs, level, idx) = old_pack;
12171 SET_ARGUMENT_PACK_ARGS (old_pack, new_args);
12172 ARGUMENT_PACK_INCOMPLETE_P (old_pack) = 1;
12173 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack) = explicit_args;
12175 else if (!comp_template_args (ARGUMENT_PACK_ARGS (old_pack),
12177 /* Inconsistent unification of this parameter pack. */
12183 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12185 /* Keep the original deduced argument pack. */
12186 TMPL_ARG (targs, level, idx) = old_pack;
12193 /* Deduce the value of template parameters. TPARMS is the (innermost)
12194 set of template parameters to a template. TARGS is the bindings
12195 for those template parameters, as determined thus far; TARGS may
12196 include template arguments for outer levels of template parameters
12197 as well. PARM is a parameter to a template function, or a
12198 subcomponent of that parameter; ARG is the corresponding argument.
12199 This function attempts to match PARM with ARG in a manner
12200 consistent with the existing assignments in TARGS. If more values
12201 are deduced, then TARGS is updated.
12203 Returns 0 if the type deduction succeeds, 1 otherwise. The
12204 parameter STRICT is a bitwise or of the following flags:
12207 Require an exact match between PARM and ARG.
12208 UNIFY_ALLOW_MORE_CV_QUAL:
12209 Allow the deduced ARG to be more cv-qualified (by qualification
12210 conversion) than ARG.
12211 UNIFY_ALLOW_LESS_CV_QUAL:
12212 Allow the deduced ARG to be less cv-qualified than ARG.
12213 UNIFY_ALLOW_DERIVED:
12214 Allow the deduced ARG to be a template base class of ARG,
12215 or a pointer to a template base class of the type pointed to by
12217 UNIFY_ALLOW_INTEGER:
12218 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
12219 case for more information.
12220 UNIFY_ALLOW_OUTER_LEVEL:
12221 This is the outermost level of a deduction. Used to determine validity
12222 of qualification conversions. A valid qualification conversion must
12223 have const qualified pointers leading up to the inner type which
12224 requires additional CV quals, except at the outer level, where const
12225 is not required [conv.qual]. It would be normal to set this flag in
12226 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
12227 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
12228 This is the outermost level of a deduction, and PARM can be more CV
12229 qualified at this point.
12230 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
12231 This is the outermost level of a deduction, and PARM can be less CV
12232 qualified at this point. */
12235 unify (tree tparms, tree targs, tree parm, tree arg, int strict)
12240 int strict_in = strict;
12242 /* I don't think this will do the right thing with respect to types.
12243 But the only case I've seen it in so far has been array bounds, where
12244 signedness is the only information lost, and I think that will be
12246 while (TREE_CODE (parm) == NOP_EXPR)
12247 parm = TREE_OPERAND (parm, 0);
12249 if (arg == error_mark_node)
12251 if (arg == unknown_type_node)
12252 /* We can't deduce anything from this, but we might get all the
12253 template args from other function args. */
12256 /* If PARM uses template parameters, then we can't bail out here,
12257 even if ARG == PARM, since we won't record unifications for the
12258 template parameters. We might need them if we're trying to
12259 figure out which of two things is more specialized. */
12260 if (arg == parm && !uses_template_parms (parm))
12263 /* Immediately reject some pairs that won't unify because of
12264 cv-qualification mismatches. */
12265 if (TREE_CODE (arg) == TREE_CODE (parm)
12267 /* It is the elements of the array which hold the cv quals of an array
12268 type, and the elements might be template type parms. We'll check
12269 when we recurse. */
12270 && TREE_CODE (arg) != ARRAY_TYPE
12271 /* We check the cv-qualifiers when unifying with template type
12272 parameters below. We want to allow ARG `const T' to unify with
12273 PARM `T' for example, when computing which of two templates
12274 is more specialized, for example. */
12275 && TREE_CODE (arg) != TEMPLATE_TYPE_PARM
12276 && !check_cv_quals_for_unify (strict_in, arg, parm))
12279 if (!(strict & UNIFY_ALLOW_OUTER_LEVEL)
12280 && TYPE_P (parm) && !CP_TYPE_CONST_P (parm))
12281 strict &= ~UNIFY_ALLOW_MORE_CV_QUAL;
12282 strict &= ~UNIFY_ALLOW_OUTER_LEVEL;
12283 strict &= ~UNIFY_ALLOW_DERIVED;
12284 strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
12285 strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL;
12287 switch (TREE_CODE (parm))
12289 case TYPENAME_TYPE:
12291 case UNBOUND_CLASS_TEMPLATE:
12292 /* In a type which contains a nested-name-specifier, template
12293 argument values cannot be deduced for template parameters used
12294 within the nested-name-specifier. */
12297 case TEMPLATE_TYPE_PARM:
12298 case TEMPLATE_TEMPLATE_PARM:
12299 case BOUND_TEMPLATE_TEMPLATE_PARM:
12300 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
12301 if (tparm == error_mark_node)
12304 if (TEMPLATE_TYPE_LEVEL (parm)
12305 != template_decl_level (tparm))
12306 /* The PARM is not one we're trying to unify. Just check
12307 to see if it matches ARG. */
12308 return (TREE_CODE (arg) == TREE_CODE (parm)
12309 && same_type_p (parm, arg)) ? 0 : 1;
12310 idx = TEMPLATE_TYPE_IDX (parm);
12311 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
12312 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx));
12314 /* Check for mixed types and values. */
12315 if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
12316 && TREE_CODE (tparm) != TYPE_DECL)
12317 || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
12318 && TREE_CODE (tparm) != TEMPLATE_DECL))
12321 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
12323 /* ARG must be constructed from a template class or a template
12324 template parameter. */
12325 if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM
12326 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg))
12330 tree parmvec = TYPE_TI_ARGS (parm);
12331 tree argvec = INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg));
12333 = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_TI_TEMPLATE (arg));
12336 /* The resolution to DR150 makes clear that default
12337 arguments for an N-argument may not be used to bind T
12338 to a template template parameter with fewer than N
12339 parameters. It is not safe to permit the binding of
12340 default arguments as an extension, as that may change
12341 the meaning of a conforming program. Consider:
12343 struct Dense { static const unsigned int dim = 1; };
12345 template <template <typename> class View,
12347 void operator+(float, View<Block> const&);
12349 template <typename Block,
12350 unsigned int Dim = Block::dim>
12351 struct Lvalue_proxy { operator float() const; };
12355 Lvalue_proxy<Dense> p;
12360 Here, if Lvalue_proxy is permitted to bind to View, then
12361 the global operator+ will be used; if they are not, the
12362 Lvalue_proxy will be converted to float. */
12363 if (coerce_template_parms (argtmplvec, parmvec,
12364 TYPE_TI_TEMPLATE (parm),
12366 /*require_all_args=*/true,
12367 /*use_default_args=*/false)
12368 == error_mark_node)
12371 /* Deduce arguments T, i from TT<T> or TT<i>.
12372 We check each element of PARMVEC and ARGVEC individually
12373 rather than the whole TREE_VEC since they can have
12374 different number of elements. */
12376 for (i = 0; i < TREE_VEC_LENGTH (parmvec); ++i)
12378 if (unify (tparms, targs,
12379 TREE_VEC_ELT (parmvec, i),
12380 TREE_VEC_ELT (argvec, i),
12385 arg = TYPE_TI_TEMPLATE (arg);
12387 /* Fall through to deduce template name. */
12390 if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
12391 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
12393 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
12395 /* Simple cases: Value already set, does match or doesn't. */
12396 if (targ != NULL_TREE && template_args_equal (targ, arg))
12403 /* If PARM is `const T' and ARG is only `int', we don't have
12404 a match unless we are allowing additional qualification.
12405 If ARG is `const int' and PARM is just `T' that's OK;
12406 that binds `const int' to `T'. */
12407 if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL,
12411 /* Consider the case where ARG is `const volatile int' and
12412 PARM is `const T'. Then, T should be `volatile int'. */
12413 arg = cp_build_qualified_type_real
12414 (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
12415 if (arg == error_mark_node)
12418 /* Simple cases: Value already set, does match or doesn't. */
12419 if (targ != NULL_TREE && same_type_p (targ, arg))
12424 /* Make sure that ARG is not a variable-sized array. (Note
12425 that were talking about variable-sized arrays (like
12426 `int[n]'), rather than arrays of unknown size (like
12427 `int[]').) We'll get very confused by such a type since
12428 the bound of the array will not be computable in an
12429 instantiation. Besides, such types are not allowed in
12430 ISO C++, so we can do as we please here. */
12431 if (variably_modified_type_p (arg, NULL_TREE))
12435 /* If ARG is a parameter pack or an expansion, we cannot unify
12436 against it unless PARM is also a parameter pack. */
12437 if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
12438 && !template_parameter_pack_p (parm))
12441 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
12444 case TEMPLATE_PARM_INDEX:
12445 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
12446 if (tparm == error_mark_node)
12449 if (TEMPLATE_PARM_LEVEL (parm)
12450 != template_decl_level (tparm))
12451 /* The PARM is not one we're trying to unify. Just check
12452 to see if it matches ARG. */
12453 return !(TREE_CODE (arg) == TREE_CODE (parm)
12454 && cp_tree_equal (parm, arg));
12456 idx = TEMPLATE_PARM_IDX (parm);
12457 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
12460 return !cp_tree_equal (targ, arg);
12462 /* [temp.deduct.type] If, in the declaration of a function template
12463 with a non-type template-parameter, the non-type
12464 template-parameter is used in an expression in the function
12465 parameter-list and, if the corresponding template-argument is
12466 deduced, the template-argument type shall match the type of the
12467 template-parameter exactly, except that a template-argument
12468 deduced from an array bound may be of any integral type.
12469 The non-type parameter might use already deduced type parameters. */
12470 tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE);
12471 if (!TREE_TYPE (arg))
12472 /* Template-parameter dependent expression. Just accept it for now.
12473 It will later be processed in convert_template_argument. */
12475 else if (same_type_p (TREE_TYPE (arg), tparm))
12477 else if ((strict & UNIFY_ALLOW_INTEGER)
12478 && (TREE_CODE (tparm) == INTEGER_TYPE
12479 || TREE_CODE (tparm) == BOOLEAN_TYPE))
12480 /* Convert the ARG to the type of PARM; the deduced non-type
12481 template argument must exactly match the types of the
12482 corresponding parameter. */
12483 arg = fold (build_nop (TREE_TYPE (parm), arg));
12484 else if (uses_template_parms (tparm))
12485 /* We haven't deduced the type of this parameter yet. Try again
12491 /* If ARG is a parameter pack or an expansion, we cannot unify
12492 against it unless PARM is also a parameter pack. */
12493 if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
12494 && !TEMPLATE_PARM_PARAMETER_PACK (parm))
12497 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
12502 /* A pointer-to-member constant can be unified only with
12503 another constant. */
12504 if (TREE_CODE (arg) != PTRMEM_CST)
12507 /* Just unify the class member. It would be useless (and possibly
12508 wrong, depending on the strict flags) to unify also
12509 PTRMEM_CST_CLASS, because we want to be sure that both parm and
12510 arg refer to the same variable, even if through different
12511 classes. For instance:
12513 struct A { int x; };
12516 Unification of &A::x and &B::x must succeed. */
12517 return unify (tparms, targs, PTRMEM_CST_MEMBER (parm),
12518 PTRMEM_CST_MEMBER (arg), strict);
12523 if (TREE_CODE (arg) != POINTER_TYPE)
12526 /* [temp.deduct.call]
12528 A can be another pointer or pointer to member type that can
12529 be converted to the deduced A via a qualification
12530 conversion (_conv.qual_).
12532 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
12533 This will allow for additional cv-qualification of the
12534 pointed-to types if appropriate. */
12536 if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
12537 /* The derived-to-base conversion only persists through one
12538 level of pointers. */
12539 strict |= (strict_in & UNIFY_ALLOW_DERIVED);
12541 return unify (tparms, targs, TREE_TYPE (parm),
12542 TREE_TYPE (arg), strict);
12545 case REFERENCE_TYPE:
12546 if (TREE_CODE (arg) != REFERENCE_TYPE)
12548 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
12549 strict & UNIFY_ALLOW_MORE_CV_QUAL);
12552 if (TREE_CODE (arg) != ARRAY_TYPE)
12554 if ((TYPE_DOMAIN (parm) == NULL_TREE)
12555 != (TYPE_DOMAIN (arg) == NULL_TREE))
12557 if (TYPE_DOMAIN (parm) != NULL_TREE)
12564 /* Our representation of array types uses "N - 1" as the
12565 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
12566 not an integer constant. We cannot unify arbitrarily
12567 complex expressions, so we eliminate the MINUS_EXPRs
12569 parm_max = TYPE_MAX_VALUE (TYPE_DOMAIN (parm));
12570 parm_cst = TREE_CODE (parm_max) == INTEGER_CST;
12573 gcc_assert (TREE_CODE (parm_max) == MINUS_EXPR);
12574 parm_max = TREE_OPERAND (parm_max, 0);
12576 arg_max = TYPE_MAX_VALUE (TYPE_DOMAIN (arg));
12577 arg_cst = TREE_CODE (arg_max) == INTEGER_CST;
12580 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
12581 trying to unify the type of a variable with the type
12582 of a template parameter. For example:
12584 template <unsigned int N>
12585 void f (char (&) [N]);
12592 Here, the type of the ARG will be "int [g(i)]", and
12593 may be a SAVE_EXPR, etc. */
12594 if (TREE_CODE (arg_max) != MINUS_EXPR)
12596 arg_max = TREE_OPERAND (arg_max, 0);
12599 /* If only one of the bounds used a MINUS_EXPR, compensate
12600 by adding one to the other bound. */
12601 if (parm_cst && !arg_cst)
12602 parm_max = fold_build2 (PLUS_EXPR,
12606 else if (arg_cst && !parm_cst)
12607 arg_max = fold_build2 (PLUS_EXPR,
12612 if (unify (tparms, targs, parm_max, arg_max, UNIFY_ALLOW_INTEGER))
12615 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
12616 strict & UNIFY_ALLOW_MORE_CV_QUAL);
12623 case ENUMERAL_TYPE:
12625 if (TREE_CODE (arg) != TREE_CODE (parm))
12628 /* We have already checked cv-qualification at the top of the
12630 if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
12633 /* As far as unification is concerned, this wins. Later checks
12634 will invalidate it if necessary. */
12637 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
12638 /* Type INTEGER_CST can come from ordinary constant template args. */
12640 while (TREE_CODE (arg) == NOP_EXPR)
12641 arg = TREE_OPERAND (arg, 0);
12643 if (TREE_CODE (arg) != INTEGER_CST)
12645 return !tree_int_cst_equal (parm, arg);
12650 if (TREE_CODE (arg) != TREE_VEC)
12652 if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
12654 for (i = 0; i < TREE_VEC_LENGTH (parm); ++i)
12655 if (unify (tparms, targs,
12656 TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
12664 if (TREE_CODE (arg) != TREE_CODE (parm))
12667 if (TYPE_PTRMEMFUNC_P (parm))
12669 if (!TYPE_PTRMEMFUNC_P (arg))
12672 return unify (tparms, targs,
12673 TYPE_PTRMEMFUNC_FN_TYPE (parm),
12674 TYPE_PTRMEMFUNC_FN_TYPE (arg),
12678 if (CLASSTYPE_TEMPLATE_INFO (parm))
12680 tree t = NULL_TREE;
12682 if (strict_in & UNIFY_ALLOW_DERIVED)
12684 /* First, we try to unify the PARM and ARG directly. */
12685 t = try_class_unification (tparms, targs,
12690 /* Fallback to the special case allowed in
12691 [temp.deduct.call]:
12693 If P is a class, and P has the form
12694 template-id, then A can be a derived class of
12695 the deduced A. Likewise, if P is a pointer to
12696 a class of the form template-id, A can be a
12697 pointer to a derived class pointed to by the
12699 t = get_template_base (tparms, targs, parm, arg);
12705 else if (CLASSTYPE_TEMPLATE_INFO (arg)
12706 && (CLASSTYPE_TI_TEMPLATE (parm)
12707 == CLASSTYPE_TI_TEMPLATE (arg)))
12708 /* Perhaps PARM is something like S<U> and ARG is S<int>.
12709 Then, we should unify `int' and `U'. */
12712 /* There's no chance of unification succeeding. */
12715 return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
12716 CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE);
12718 else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
12723 case FUNCTION_TYPE:
12724 if (TREE_CODE (arg) != TREE_CODE (parm))
12727 /* CV qualifications for methods can never be deduced, they must
12728 match exactly. We need to check them explicitly here,
12729 because type_unification_real treats them as any other
12730 cvqualified parameter. */
12731 if (TREE_CODE (parm) == METHOD_TYPE
12732 && (!check_cv_quals_for_unify
12734 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (arg))),
12735 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (parm))))))
12738 if (unify (tparms, targs, TREE_TYPE (parm),
12739 TREE_TYPE (arg), UNIFY_ALLOW_NONE))
12741 return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
12742 TYPE_ARG_TYPES (arg), 1, DEDUCE_EXACT,
12746 /* Unify a pointer to member with a pointer to member function, which
12747 deduces the type of the member as a function type. */
12748 if (TYPE_PTRMEMFUNC_P (arg))
12752 cp_cv_quals cv_quals;
12754 /* Check top-level cv qualifiers */
12755 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE, arg, parm))
12758 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
12759 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg), UNIFY_ALLOW_NONE))
12762 /* Determine the type of the function we are unifying against. */
12763 method_type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (arg));
12765 build_function_type (TREE_TYPE (method_type),
12766 TREE_CHAIN (TYPE_ARG_TYPES (method_type)));
12768 /* Extract the cv-qualifiers of the member function from the
12769 implicit object parameter and place them on the function
12770 type to be restored later. */
12772 cp_type_quals(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (method_type))));
12773 fntype = build_qualified_type (fntype, cv_quals);
12774 return unify (tparms, targs, TREE_TYPE (parm), fntype, strict);
12777 if (TREE_CODE (arg) != OFFSET_TYPE)
12779 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
12780 TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE))
12782 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
12786 if (DECL_TEMPLATE_PARM_P (parm))
12787 return unify (tparms, targs, DECL_INITIAL (parm), arg, strict);
12788 if (arg != integral_constant_value (parm))
12793 case TEMPLATE_DECL:
12794 /* Matched cases are handled by the ARG == PARM test above. */
12797 case TYPE_ARGUMENT_PACK:
12798 case NONTYPE_ARGUMENT_PACK:
12800 tree packed_parms = ARGUMENT_PACK_ARGS (parm);
12801 tree packed_args = ARGUMENT_PACK_ARGS (arg);
12802 int i, len = TREE_VEC_LENGTH (packed_parms);
12803 int argslen = TREE_VEC_LENGTH (packed_args);
12804 int parm_variadic_p = 0;
12806 /* Check if the parameters end in a pack, making them variadic. */
12808 && PACK_EXPANSION_P (TREE_VEC_ELT (packed_parms, len - 1)))
12809 parm_variadic_p = 1;
12811 /* If we don't have enough arguments to satisfy the parameters
12812 (not counting the pack expression at the end), or we have
12813 too many arguments for a parameter list that doesn't end in
12814 a pack expression, we can't unify. */
12815 if (argslen < (len - parm_variadic_p)
12816 || (argslen > len && !parm_variadic_p))
12819 /* Unify all of the parameters that precede the (optional)
12820 pack expression. */
12821 for (i = 0; i < len - parm_variadic_p; ++i)
12823 if (unify (tparms, targs, TREE_VEC_ELT (packed_parms, i),
12824 TREE_VEC_ELT (packed_args, i), strict))
12828 if (parm_variadic_p)
12829 return unify_pack_expansion (tparms, targs,
12830 packed_parms, packed_args,
12831 strict, /*call_args_p=*/false,
12839 gcc_assert (EXPR_P (parm));
12841 /* We must be looking at an expression. This can happen with
12845 void foo(S<I>, S<I + 2>);
12847 This is a "nondeduced context":
12851 The nondeduced contexts are:
12853 --A type that is a template-id in which one or more of
12854 the template-arguments is an expression that references
12855 a template-parameter.
12857 In these cases, we assume deduction succeeded, but don't
12858 actually infer any unifications. */
12860 if (!uses_template_parms (parm)
12861 && !template_args_equal (parm, arg))
12868 /* Note that DECL can be defined in this translation unit, if
12872 mark_definable (tree decl)
12875 DECL_NOT_REALLY_EXTERN (decl) = 1;
12876 FOR_EACH_CLONE (clone, decl)
12877 DECL_NOT_REALLY_EXTERN (clone) = 1;
12880 /* Called if RESULT is explicitly instantiated, or is a member of an
12881 explicitly instantiated class. */
12884 mark_decl_instantiated (tree result, int extern_p)
12886 SET_DECL_EXPLICIT_INSTANTIATION (result);
12888 /* If this entity has already been written out, it's too late to
12889 make any modifications. */
12890 if (TREE_ASM_WRITTEN (result))
12893 if (TREE_CODE (result) != FUNCTION_DECL)
12894 /* The TREE_PUBLIC flag for function declarations will have been
12895 set correctly by tsubst. */
12896 TREE_PUBLIC (result) = 1;
12898 /* This might have been set by an earlier implicit instantiation. */
12899 DECL_COMDAT (result) = 0;
12902 DECL_NOT_REALLY_EXTERN (result) = 0;
12905 mark_definable (result);
12906 /* Always make artificials weak. */
12907 if (DECL_ARTIFICIAL (result) && flag_weak)
12908 comdat_linkage (result);
12909 /* For WIN32 we also want to put explicit instantiations in
12910 linkonce sections. */
12911 else if (TREE_PUBLIC (result))
12912 maybe_make_one_only (result);
12915 /* If EXTERN_P, then this function will not be emitted -- unless
12916 followed by an explicit instantiation, at which point its linkage
12917 will be adjusted. If !EXTERN_P, then this function will be
12918 emitted here. In neither circumstance do we want
12919 import_export_decl to adjust the linkage. */
12920 DECL_INTERFACE_KNOWN (result) = 1;
12923 /* Given two function templates PAT1 and PAT2, return:
12925 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
12926 -1 if PAT2 is more specialized than PAT1.
12927 0 if neither is more specialized.
12929 LEN indicates the number of parameters we should consider
12930 (defaulted parameters should not be considered).
12932 The 1998 std underspecified function template partial ordering, and
12933 DR214 addresses the issue. We take pairs of arguments, one from
12934 each of the templates, and deduce them against each other. One of
12935 the templates will be more specialized if all the *other*
12936 template's arguments deduce against its arguments and at least one
12937 of its arguments *does* *not* deduce against the other template's
12938 corresponding argument. Deduction is done as for class templates.
12939 The arguments used in deduction have reference and top level cv
12940 qualifiers removed. Iff both arguments were originally reference
12941 types *and* deduction succeeds in both directions, the template
12942 with the more cv-qualified argument wins for that pairing (if
12943 neither is more cv-qualified, they both are equal). Unlike regular
12944 deduction, after all the arguments have been deduced in this way,
12945 we do *not* verify the deduced template argument values can be
12946 substituted into non-deduced contexts, nor do we have to verify
12947 that all template arguments have been deduced. */
12950 more_specialized_fn (tree pat1, tree pat2, int len)
12952 tree decl1 = DECL_TEMPLATE_RESULT (pat1);
12953 tree decl2 = DECL_TEMPLATE_RESULT (pat2);
12954 tree targs1 = make_tree_vec (DECL_NTPARMS (pat1));
12955 tree targs2 = make_tree_vec (DECL_NTPARMS (pat2));
12956 tree tparms1 = DECL_INNERMOST_TEMPLATE_PARMS (pat1);
12957 tree tparms2 = DECL_INNERMOST_TEMPLATE_PARMS (pat2);
12958 tree args1 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
12959 tree args2 = TYPE_ARG_TYPES (TREE_TYPE (decl2));
12963 /* Remove the this parameter from non-static member functions. If
12964 one is a non-static member function and the other is not a static
12965 member function, remove the first parameter from that function
12966 also. This situation occurs for operator functions where we
12967 locate both a member function (with this pointer) and non-member
12968 operator (with explicit first operand). */
12969 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1))
12971 len--; /* LEN is the number of significant arguments for DECL1 */
12972 args1 = TREE_CHAIN (args1);
12973 if (!DECL_STATIC_FUNCTION_P (decl2))
12974 args2 = TREE_CHAIN (args2);
12976 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2))
12978 args2 = TREE_CHAIN (args2);
12979 if (!DECL_STATIC_FUNCTION_P (decl1))
12982 args1 = TREE_CHAIN (args1);
12986 /* If only one is a conversion operator, they are unordered. */
12987 if (DECL_CONV_FN_P (decl1) != DECL_CONV_FN_P (decl2))
12990 /* Consider the return type for a conversion function */
12991 if (DECL_CONV_FN_P (decl1))
12993 args1 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl1)), args1);
12994 args2 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl2)), args2);
12998 processing_template_decl++;
13002 tree arg1 = TREE_VALUE (args1);
13003 tree arg2 = TREE_VALUE (args2);
13004 int deduce1, deduce2;
13008 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
13009 && TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
13011 /* When both arguments are pack expansions, we need only
13012 unify the patterns themselves. */
13013 arg1 = PACK_EXPANSION_PATTERN (arg1);
13014 arg2 = PACK_EXPANSION_PATTERN (arg2);
13016 /* This is the last comparison we need to do. */
13020 if (TREE_CODE (arg1) == REFERENCE_TYPE)
13022 arg1 = TREE_TYPE (arg1);
13023 quals1 = cp_type_quals (arg1);
13026 if (TREE_CODE (arg2) == REFERENCE_TYPE)
13028 arg2 = TREE_TYPE (arg2);
13029 quals2 = cp_type_quals (arg2);
13032 if ((quals1 < 0) != (quals2 < 0))
13034 /* Only of the args is a reference, see if we should apply
13035 array/function pointer decay to it. This is not part of
13036 DR214, but is, IMHO, consistent with the deduction rules
13037 for the function call itself, and with our earlier
13038 implementation of the underspecified partial ordering
13039 rules. (nathan). */
13042 switch (TREE_CODE (arg1))
13045 arg1 = TREE_TYPE (arg1);
13047 case FUNCTION_TYPE:
13048 arg1 = build_pointer_type (arg1);
13057 switch (TREE_CODE (arg2))
13060 arg2 = TREE_TYPE (arg2);
13062 case FUNCTION_TYPE:
13063 arg2 = build_pointer_type (arg2);
13072 arg1 = TYPE_MAIN_VARIANT (arg1);
13073 arg2 = TYPE_MAIN_VARIANT (arg2);
13075 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION)
13077 int i, len2 = list_length (args2);
13078 tree parmvec = make_tree_vec (1);
13079 tree argvec = make_tree_vec (len2);
13082 /* Setup the parameter vector, which contains only ARG1. */
13083 TREE_VEC_ELT (parmvec, 0) = arg1;
13085 /* Setup the argument vector, which contains the remaining
13087 for (i = 0; i < len2; i++, ta = TREE_CHAIN (ta))
13088 TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
13090 deduce1 = !unify_pack_expansion (tparms1, targs1, parmvec,
13091 argvec, UNIFY_ALLOW_NONE,
13092 /*call_args_p=*/false,
13095 /* We cannot deduce in the other direction, because ARG1 is
13096 a pack expansion but ARG2 is not. */
13099 else if (TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
13101 int i, len1 = list_length (args1);
13102 tree parmvec = make_tree_vec (1);
13103 tree argvec = make_tree_vec (len1);
13106 /* Setup the parameter vector, which contains only ARG1. */
13107 TREE_VEC_ELT (parmvec, 0) = arg2;
13109 /* Setup the argument vector, which contains the remaining
13111 for (i = 0; i < len1; i++, ta = TREE_CHAIN (ta))
13112 TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
13114 deduce2 = !unify_pack_expansion (tparms2, targs2, parmvec,
13115 argvec, UNIFY_ALLOW_NONE,
13116 /*call_args_p=*/false,
13119 /* We cannot deduce in the other direction, because ARG2 is
13120 a pack expansion but ARG1 is not.*/
13126 /* The normal case, where neither argument is a pack
13128 deduce1 = !unify (tparms1, targs1, arg1, arg2, UNIFY_ALLOW_NONE);
13129 deduce2 = !unify (tparms2, targs2, arg2, arg1, UNIFY_ALLOW_NONE);
13136 if (better1 < 0 && better2 < 0)
13137 /* We've failed to deduce something in either direction.
13138 These must be unordered. */
13141 if (deduce1 && deduce2 && quals1 >= 0 && quals2 >= 0)
13143 /* Deduces in both directions, see if quals can
13144 disambiguate. Pretend the worse one failed to deduce. */
13145 if ((quals1 & quals2) == quals2)
13147 if ((quals1 & quals2) == quals1)
13150 if (deduce1 && !deduce2 && !better2)
13152 if (deduce2 && !deduce1 && !better1)
13155 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
13156 || TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
13157 /* We have already processed all of the arguments in our
13158 handing of the pack expansion type. */
13161 args1 = TREE_CHAIN (args1);
13162 args2 = TREE_CHAIN (args2);
13165 processing_template_decl--;
13167 /* All things being equal, if the next argument is a pack expansion
13168 for one function but not for the other, prefer the
13169 non-variadic function. */
13170 if ((better1 > 0) - (better2 > 0) == 0
13171 && args1 && TREE_VALUE (args1)
13172 && args2 && TREE_VALUE (args2))
13174 if (TREE_CODE (TREE_VALUE (args1)) == TYPE_PACK_EXPANSION)
13175 return TREE_CODE (TREE_VALUE (args2)) == TYPE_PACK_EXPANSION ? 0 : -1;
13176 else if (TREE_CODE (TREE_VALUE (args2)) == TYPE_PACK_EXPANSION)
13180 return (better1 > 0) - (better2 > 0);
13183 /* Determine which of two partial specializations is more specialized.
13185 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
13186 to the first partial specialization. The TREE_VALUE is the
13187 innermost set of template parameters for the partial
13188 specialization. PAT2 is similar, but for the second template.
13190 Return 1 if the first partial specialization is more specialized;
13191 -1 if the second is more specialized; 0 if neither is more
13194 See [temp.class.order] for information about determining which of
13195 two templates is more specialized. */
13198 more_specialized_class (tree pat1, tree pat2)
13203 bool any_deductions = false;
13205 tmpl1 = TREE_TYPE (pat1);
13206 tmpl2 = TREE_TYPE (pat2);
13208 /* Just like what happens for functions, if we are ordering between
13209 different class template specializations, we may encounter dependent
13210 types in the arguments, and we need our dependency check functions
13211 to behave correctly. */
13212 ++processing_template_decl;
13213 targs = get_class_bindings (TREE_VALUE (pat1),
13214 CLASSTYPE_TI_ARGS (tmpl1),
13215 CLASSTYPE_TI_ARGS (tmpl2));
13219 any_deductions = true;
13222 targs = get_class_bindings (TREE_VALUE (pat2),
13223 CLASSTYPE_TI_ARGS (tmpl2),
13224 CLASSTYPE_TI_ARGS (tmpl1));
13228 any_deductions = true;
13230 --processing_template_decl;
13232 /* In the case of a tie where at least one of the class templates
13233 has a parameter pack at the end, the template with the most
13234 non-packed parameters wins. */
13237 && (template_args_variadic_p (TREE_PURPOSE (pat1))
13238 || template_args_variadic_p (TREE_PURPOSE (pat2))))
13240 tree args1 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1));
13241 tree args2 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2));
13242 int len1 = TREE_VEC_LENGTH (args1);
13243 int len2 = TREE_VEC_LENGTH (args2);
13245 /* We don't count the pack expansion at the end. */
13246 if (template_args_variadic_p (TREE_PURPOSE (pat1)))
13248 if (template_args_variadic_p (TREE_PURPOSE (pat2)))
13253 else if (len1 < len2)
13260 /* Return the template arguments that will produce the function signature
13261 DECL from the function template FN, with the explicit template
13262 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
13263 also match. Return NULL_TREE if no satisfactory arguments could be
13267 get_bindings (tree fn, tree decl, tree explicit_args, bool check_rettype)
13269 int ntparms = DECL_NTPARMS (fn);
13270 tree targs = make_tree_vec (ntparms);
13272 tree decl_arg_types;
13274 /* Substitute the explicit template arguments into the type of DECL.
13275 The call to fn_type_unification will handle substitution into the
13277 decl_type = TREE_TYPE (decl);
13278 if (explicit_args && uses_template_parms (decl_type))
13281 tree converted_args;
13283 if (DECL_TEMPLATE_INFO (decl))
13284 tmpl = DECL_TI_TEMPLATE (decl);
13286 /* We can get here for some invalid specializations. */
13290 = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
13291 explicit_args, NULL_TREE,
13293 /*require_all_args=*/false,
13294 /*use_default_args=*/false);
13295 if (converted_args == error_mark_node)
13298 decl_type = tsubst (decl_type, converted_args, tf_none, NULL_TREE);
13299 if (decl_type == error_mark_node)
13303 /* Never do unification on the 'this' parameter. */
13304 decl_arg_types = skip_artificial_parms_for (decl,
13305 TYPE_ARG_TYPES (decl_type));
13307 if (fn_type_unification (fn, explicit_args, targs,
13309 (check_rettype || DECL_CONV_FN_P (fn)
13310 ? TREE_TYPE (decl_type) : NULL_TREE),
13311 DEDUCE_EXACT, LOOKUP_NORMAL))
13317 /* Return the innermost template arguments that, when applied to a
13318 template specialization whose innermost template parameters are
13319 TPARMS, and whose specialization arguments are PARMS, yield the
13322 For example, suppose we have:
13324 template <class T, class U> struct S {};
13325 template <class T> struct S<T*, int> {};
13327 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
13328 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
13329 int}. The resulting vector will be {double}, indicating that `T'
13330 is bound to `double'. */
13333 get_class_bindings (tree tparms, tree spec_args, tree args)
13335 int i, ntparms = TREE_VEC_LENGTH (tparms);
13337 tree innermost_deduced_args;
13339 innermost_deduced_args = make_tree_vec (ntparms);
13340 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
13342 deduced_args = copy_node (args);
13343 SET_TMPL_ARGS_LEVEL (deduced_args,
13344 TMPL_ARGS_DEPTH (deduced_args),
13345 innermost_deduced_args);
13348 deduced_args = innermost_deduced_args;
13350 if (unify (tparms, deduced_args,
13351 INNERMOST_TEMPLATE_ARGS (spec_args),
13352 INNERMOST_TEMPLATE_ARGS (args),
13356 for (i = 0; i < ntparms; ++i)
13357 if (! TREE_VEC_ELT (innermost_deduced_args, i))
13360 /* Verify that nondeduced template arguments agree with the type
13361 obtained from argument deduction.
13365 struct A { typedef int X; };
13366 template <class T, class U> struct C {};
13367 template <class T> struct C<T, typename T::X> {};
13369 Then with the instantiation `C<A, int>', we can deduce that
13370 `T' is `A' but unify () does not check whether `typename T::X'
13372 spec_args = tsubst (spec_args, deduced_args, tf_none, NULL_TREE);
13373 if (spec_args == error_mark_node
13374 /* We only need to check the innermost arguments; the other
13375 arguments will always agree. */
13376 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args),
13377 INNERMOST_TEMPLATE_ARGS (args)))
13380 return deduced_args;
13383 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
13384 Return the TREE_LIST node with the most specialized template, if
13385 any. If there is no most specialized template, the error_mark_node
13388 Note that this function does not look at, or modify, the
13389 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
13390 returned is one of the elements of INSTANTIATIONS, callers may
13391 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
13392 and retrieve it from the value returned. */
13395 most_specialized_instantiation (tree templates)
13399 ++processing_template_decl;
13402 for (fn = TREE_CHAIN (templates); fn; fn = TREE_CHAIN (fn))
13406 if (get_bindings (TREE_VALUE (champ),
13407 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
13408 NULL_TREE, /*check_ret=*/false))
13411 if (get_bindings (TREE_VALUE (fn),
13412 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
13413 NULL_TREE, /*check_ret=*/false))
13420 /* Equally specialized, move to next function. If there
13421 is no next function, nothing's most specialized. */
13422 fn = TREE_CHAIN (fn);
13430 /* Now verify that champ is better than everything earlier in the
13431 instantiation list. */
13432 for (fn = templates; fn != champ; fn = TREE_CHAIN (fn))
13433 if (get_bindings (TREE_VALUE (champ),
13434 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
13435 NULL_TREE, /*check_ret=*/false)
13436 || !get_bindings (TREE_VALUE (fn),
13437 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
13438 NULL_TREE, /*check_ret=*/false))
13444 processing_template_decl--;
13447 return error_mark_node;
13452 /* If DECL is a specialization of some template, return the most
13453 general such template. Otherwise, returns NULL_TREE.
13455 For example, given:
13457 template <class T> struct S { template <class U> void f(U); };
13459 if TMPL is `template <class U> void S<int>::f(U)' this will return
13460 the full template. This function will not trace past partial
13461 specializations, however. For example, given in addition:
13463 template <class T> struct S<T*> { template <class U> void f(U); };
13465 if TMPL is `template <class U> void S<int*>::f(U)' this will return
13466 `template <class T> template <class U> S<T*>::f(U)'. */
13469 most_general_template (tree decl)
13471 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
13472 an immediate specialization. */
13473 if (TREE_CODE (decl) == FUNCTION_DECL)
13475 if (DECL_TEMPLATE_INFO (decl)) {
13476 decl = DECL_TI_TEMPLATE (decl);
13478 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
13479 template friend. */
13480 if (TREE_CODE (decl) != TEMPLATE_DECL)
13486 /* Look for more and more general templates. */
13487 while (DECL_TEMPLATE_INFO (decl))
13489 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
13490 (See cp-tree.h for details.) */
13491 if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
13494 if (CLASS_TYPE_P (TREE_TYPE (decl))
13495 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
13498 /* Stop if we run into an explicitly specialized class template. */
13499 if (!DECL_NAMESPACE_SCOPE_P (decl)
13500 && DECL_CONTEXT (decl)
13501 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl)))
13504 decl = DECL_TI_TEMPLATE (decl);
13510 /* Return the most specialized of the class template partial
13511 specializations of TMPL which can produce TYPE, a specialization of
13512 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
13513 a _TYPE node corresponding to the partial specialization, while the
13514 TREE_PURPOSE is the set of template arguments that must be
13515 substituted into the TREE_TYPE in order to generate TYPE.
13517 If the choice of partial specialization is ambiguous, a diagnostic
13518 is issued, and the error_mark_node is returned. If there are no
13519 partial specializations of TMPL matching TYPE, then NULL_TREE is
13523 most_specialized_class (tree type, tree tmpl)
13525 tree list = NULL_TREE;
13532 tmpl = most_general_template (tmpl);
13533 args = CLASSTYPE_TI_ARGS (type);
13534 for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t))
13536 tree partial_spec_args;
13539 partial_spec_args = CLASSTYPE_TI_ARGS (TREE_TYPE (t));
13540 spec_args = get_class_bindings (TREE_VALUE (t),
13545 list = tree_cons (spec_args, TREE_VALUE (t), list);
13546 TREE_TYPE (list) = TREE_TYPE (t);
13553 ambiguous_p = false;
13556 t = TREE_CHAIN (t);
13557 for (; t; t = TREE_CHAIN (t))
13559 fate = more_specialized_class (champ, t);
13566 t = TREE_CHAIN (t);
13569 ambiguous_p = true;
13578 for (t = list; t && t != champ; t = TREE_CHAIN (t))
13580 fate = more_specialized_class (champ, t);
13583 ambiguous_p = true;
13590 const char *str = "candidates are:";
13591 error ("ambiguous class template instantiation for %q#T", type);
13592 for (t = list; t; t = TREE_CHAIN (t))
13594 error ("%s %+#T", str, TREE_TYPE (t));
13597 return error_mark_node;
13603 /* Explicitly instantiate DECL. */
13606 do_decl_instantiation (tree decl, tree storage)
13608 tree result = NULL_TREE;
13611 if (!decl || decl == error_mark_node)
13612 /* An error occurred, for which grokdeclarator has already issued
13613 an appropriate message. */
13615 else if (! DECL_LANG_SPECIFIC (decl))
13617 error ("explicit instantiation of non-template %q#D", decl);
13620 else if (TREE_CODE (decl) == VAR_DECL)
13622 /* There is an asymmetry here in the way VAR_DECLs and
13623 FUNCTION_DECLs are handled by grokdeclarator. In the case of
13624 the latter, the DECL we get back will be marked as a
13625 template instantiation, and the appropriate
13626 DECL_TEMPLATE_INFO will be set up. This does not happen for
13627 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
13628 should handle VAR_DECLs as it currently handles
13630 result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false);
13631 if (!result || TREE_CODE (result) != VAR_DECL)
13633 error ("no matching template for %qD found", decl);
13636 if (!same_type_p (TREE_TYPE (result), TREE_TYPE (decl)))
13638 error ("type %qT for explicit instantiation %qD does not match "
13639 "declared type %qT", TREE_TYPE (result), decl,
13644 else if (TREE_CODE (decl) != FUNCTION_DECL)
13646 error ("explicit instantiation of %q#D", decl);
13652 /* Check for various error cases. Note that if the explicit
13653 instantiation is valid the RESULT will currently be marked as an
13654 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
13655 until we get here. */
13657 if (DECL_TEMPLATE_SPECIALIZATION (result))
13659 /* DR 259 [temp.spec].
13661 Both an explicit instantiation and a declaration of an explicit
13662 specialization shall not appear in a program unless the explicit
13663 instantiation follows a declaration of the explicit specialization.
13665 For a given set of template parameters, if an explicit
13666 instantiation of a template appears after a declaration of an
13667 explicit specialization for that template, the explicit
13668 instantiation has no effect. */
13671 else if (DECL_EXPLICIT_INSTANTIATION (result))
13675 No program shall explicitly instantiate any template more
13678 We check DECL_NOT_REALLY_EXTERN so as not to complain when
13679 the first instantiation was `extern' and the second is not,
13680 and EXTERN_P for the opposite case. */
13681 if (DECL_NOT_REALLY_EXTERN (result) && !extern_p)
13682 pedwarn ("duplicate explicit instantiation of %q#D", result);
13683 /* If an "extern" explicit instantiation follows an ordinary
13684 explicit instantiation, the template is instantiated. */
13688 else if (!DECL_IMPLICIT_INSTANTIATION (result))
13690 error ("no matching template for %qD found", result);
13693 else if (!DECL_TEMPLATE_INFO (result))
13695 pedwarn ("explicit instantiation of non-template %q#D", result);
13699 if (storage == NULL_TREE)
13701 else if (storage == ridpointers[(int) RID_EXTERN])
13703 if (pedantic && !in_system_header)
13704 pedwarn ("ISO C++ forbids the use of %<extern%> on explicit "
13709 error ("storage class %qD applied to template instantiation", storage);
13711 check_explicit_instantiation_namespace (result);
13712 mark_decl_instantiated (result, extern_p);
13714 instantiate_decl (result, /*defer_ok=*/1,
13715 /*expl_inst_class_mem_p=*/false);
13719 mark_class_instantiated (tree t, int extern_p)
13721 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
13722 SET_CLASSTYPE_INTERFACE_KNOWN (t);
13723 CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
13724 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
13727 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
13728 rest_of_type_compilation (t, 1);
13732 /* Called from do_type_instantiation through binding_table_foreach to
13733 do recursive instantiation for the type bound in ENTRY. */
13735 bt_instantiate_type_proc (binding_entry entry, void *data)
13737 tree storage = *(tree *) data;
13739 if (IS_AGGR_TYPE (entry->type)
13740 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type)))
13741 do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0);
13744 /* Called from do_type_instantiation to instantiate a member
13745 (a member function or a static member variable) of an
13746 explicitly instantiated class template. */
13748 instantiate_class_member (tree decl, int extern_p)
13750 mark_decl_instantiated (decl, extern_p);
13752 instantiate_decl (decl, /*defer_ok=*/1,
13753 /*expl_inst_class_mem_p=*/true);
13756 /* Perform an explicit instantiation of template class T. STORAGE, if
13757 non-null, is the RID for extern, inline or static. COMPLAIN is
13758 nonzero if this is called from the parser, zero if called recursively,
13759 since the standard is unclear (as detailed below). */
13762 do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
13767 int previous_instantiation_extern_p = 0;
13769 if (TREE_CODE (t) == TYPE_DECL)
13772 if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t))
13774 error ("explicit instantiation of non-template type %qT", t);
13780 if (!COMPLETE_TYPE_P (t))
13782 if (complain & tf_error)
13783 error ("explicit instantiation of %q#T before definition of template",
13788 if (storage != NULL_TREE)
13790 if (pedantic && !in_system_header)
13791 pedwarn("ISO C++ forbids the use of %qE on explicit instantiations",
13794 if (storage == ridpointers[(int) RID_INLINE])
13796 else if (storage == ridpointers[(int) RID_EXTERN])
13798 else if (storage == ridpointers[(int) RID_STATIC])
13802 error ("storage class %qD applied to template instantiation",
13808 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
13810 /* DR 259 [temp.spec].
13812 Both an explicit instantiation and a declaration of an explicit
13813 specialization shall not appear in a program unless the explicit
13814 instantiation follows a declaration of the explicit specialization.
13816 For a given set of template parameters, if an explicit
13817 instantiation of a template appears after a declaration of an
13818 explicit specialization for that template, the explicit
13819 instantiation has no effect. */
13822 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t))
13826 No program shall explicitly instantiate any template more
13829 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
13830 instantiation was `extern'. If EXTERN_P then the second is.
13831 These cases are OK. */
13832 previous_instantiation_extern_p = CLASSTYPE_INTERFACE_ONLY (t);
13834 if (!previous_instantiation_extern_p && !extern_p
13835 && (complain & tf_error))
13836 pedwarn ("duplicate explicit instantiation of %q#T", t);
13838 /* If we've already instantiated the template, just return now. */
13839 if (!CLASSTYPE_INTERFACE_ONLY (t))
13843 check_explicit_instantiation_namespace (TYPE_NAME (t));
13844 mark_class_instantiated (t, extern_p);
13852 /* In contrast to implicit instantiation, where only the
13853 declarations, and not the definitions, of members are
13854 instantiated, we have here:
13858 The explicit instantiation of a class template specialization
13859 implies the instantiation of all of its members not
13860 previously explicitly specialized in the translation unit
13861 containing the explicit instantiation.
13863 Of course, we can't instantiate member template classes, since
13864 we don't have any arguments for them. Note that the standard
13865 is unclear on whether the instantiation of the members are
13866 *explicit* instantiations or not. However, the most natural
13867 interpretation is that it should be an explicit instantiation. */
13870 for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp))
13871 if (TREE_CODE (tmp) == FUNCTION_DECL
13872 && DECL_TEMPLATE_INSTANTIATION (tmp))
13873 instantiate_class_member (tmp, extern_p);
13875 for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp))
13876 if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp))
13877 instantiate_class_member (tmp, extern_p);
13879 if (CLASSTYPE_NESTED_UTDS (t))
13880 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t),
13881 bt_instantiate_type_proc, &storage);
13885 /* Given a function DECL, which is a specialization of TMPL, modify
13886 DECL to be a re-instantiation of TMPL with the same template
13887 arguments. TMPL should be the template into which tsubst'ing
13888 should occur for DECL, not the most general template.
13890 One reason for doing this is a scenario like this:
13893 void f(const T&, int i);
13895 void g() { f(3, 7); }
13898 void f(const T& t, const int i) { }
13900 Note that when the template is first instantiated, with
13901 instantiate_template, the resulting DECL will have no name for the
13902 first parameter, and the wrong type for the second. So, when we go
13903 to instantiate the DECL, we regenerate it. */
13906 regenerate_decl_from_template (tree decl, tree tmpl)
13908 /* The arguments used to instantiate DECL, from the most general
13913 args = DECL_TI_ARGS (decl);
13914 code_pattern = DECL_TEMPLATE_RESULT (tmpl);
13916 /* Make sure that we can see identifiers, and compute access
13918 push_access_scope (decl);
13920 if (TREE_CODE (decl) == FUNCTION_DECL)
13928 args_depth = TMPL_ARGS_DEPTH (args);
13929 parms_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
13930 if (args_depth > parms_depth)
13931 args = get_innermost_template_args (args, parms_depth);
13933 specs = tsubst_exception_specification (TREE_TYPE (code_pattern),
13934 args, tf_error, NULL_TREE);
13936 TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl),
13939 /* Merge parameter declarations. */
13940 decl_parm = skip_artificial_parms_for (decl,
13941 DECL_ARGUMENTS (decl));
13943 = skip_artificial_parms_for (code_pattern,
13944 DECL_ARGUMENTS (code_pattern));
13945 while (decl_parm && !FUNCTION_PARAMETER_PACK_P (pattern_parm))
13950 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
13951 DECL_NAME (decl_parm) = DECL_NAME (pattern_parm);
13952 parm_type = tsubst (TREE_TYPE (pattern_parm), args, tf_error,
13954 parm_type = type_decays_to (parm_type);
13955 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
13956 TREE_TYPE (decl_parm) = parm_type;
13957 attributes = DECL_ATTRIBUTES (pattern_parm);
13958 if (DECL_ATTRIBUTES (decl_parm) != attributes)
13960 DECL_ATTRIBUTES (decl_parm) = attributes;
13961 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
13963 decl_parm = TREE_CHAIN (decl_parm);
13964 pattern_parm = TREE_CHAIN (pattern_parm);
13966 /* Merge any parameters that match with the function parameter
13968 if (pattern_parm && FUNCTION_PARAMETER_PACK_P (pattern_parm))
13971 tree expanded_types;
13972 /* Expand the TYPE_PACK_EXPANSION that provides the types for
13973 the parameters in this function parameter pack. */
13974 expanded_types = tsubst_pack_expansion (TREE_TYPE (pattern_parm),
13975 args, tf_error, NULL_TREE);
13976 len = TREE_VEC_LENGTH (expanded_types);
13977 for (i = 0; i < len; i++)
13982 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
13983 /* Rename the parameter to include the index. */
13984 DECL_NAME (decl_parm) =
13985 make_ith_pack_parameter_name (DECL_NAME (pattern_parm), i);
13986 parm_type = TREE_VEC_ELT (expanded_types, i);
13987 parm_type = type_decays_to (parm_type);
13988 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
13989 TREE_TYPE (decl_parm) = parm_type;
13990 attributes = DECL_ATTRIBUTES (pattern_parm);
13991 if (DECL_ATTRIBUTES (decl_parm) != attributes)
13993 DECL_ATTRIBUTES (decl_parm) = attributes;
13994 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
13996 decl_parm = TREE_CHAIN (decl_parm);
13999 /* Merge additional specifiers from the CODE_PATTERN. */
14000 if (DECL_DECLARED_INLINE_P (code_pattern)
14001 && !DECL_DECLARED_INLINE_P (decl))
14002 DECL_DECLARED_INLINE_P (decl) = 1;
14003 if (DECL_INLINE (code_pattern) && !DECL_INLINE (decl))
14004 DECL_INLINE (decl) = 1;
14006 else if (TREE_CODE (decl) == VAR_DECL)
14007 DECL_INITIAL (decl) =
14008 tsubst_expr (DECL_INITIAL (code_pattern), args,
14009 tf_error, DECL_TI_TEMPLATE (decl),
14010 /*integral_constant_expression_p=*/false);
14012 gcc_unreachable ();
14014 pop_access_scope (decl);
14017 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
14018 substituted to get DECL. */
14021 template_for_substitution (tree decl)
14023 tree tmpl = DECL_TI_TEMPLATE (decl);
14025 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
14026 for the instantiation. This is not always the most general
14027 template. Consider, for example:
14030 struct S { template <class U> void f();
14031 template <> void f<int>(); };
14033 and an instantiation of S<double>::f<int>. We want TD to be the
14034 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
14035 while (/* An instantiation cannot have a definition, so we need a
14036 more general template. */
14037 DECL_TEMPLATE_INSTANTIATION (tmpl)
14038 /* We must also deal with friend templates. Given:
14040 template <class T> struct S {
14041 template <class U> friend void f() {};
14044 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
14045 so far as the language is concerned, but that's still
14046 where we get the pattern for the instantiation from. On
14047 other hand, if the definition comes outside the class, say:
14049 template <class T> struct S {
14050 template <class U> friend void f();
14052 template <class U> friend void f() {}
14054 we don't need to look any further. That's what the check for
14055 DECL_INITIAL is for. */
14056 || (TREE_CODE (decl) == FUNCTION_DECL
14057 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl)
14058 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl))))
14060 /* The present template, TD, should not be a definition. If it
14061 were a definition, we should be using it! Note that we
14062 cannot restructure the loop to just keep going until we find
14063 a template with a definition, since that might go too far if
14064 a specialization was declared, but not defined. */
14065 gcc_assert (TREE_CODE (decl) != VAR_DECL
14066 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl)));
14068 /* Fetch the more general template. */
14069 tmpl = DECL_TI_TEMPLATE (tmpl);
14075 /* Produce the definition of D, a _DECL generated from a template. If
14076 DEFER_OK is nonzero, then we don't have to actually do the
14077 instantiation now; we just have to do it sometime. Normally it is
14078 an error if this is an explicit instantiation but D is undefined.
14079 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
14080 explicitly instantiated class template. */
14083 instantiate_decl (tree d, int defer_ok,
14084 bool expl_inst_class_mem_p)
14086 tree tmpl = DECL_TI_TEMPLATE (d);
14093 bool pattern_defined;
14095 location_t saved_loc = input_location;
14096 int saved_in_system_header = in_system_header;
14099 /* This function should only be used to instantiate templates for
14100 functions and static member variables. */
14101 gcc_assert (TREE_CODE (d) == FUNCTION_DECL
14102 || TREE_CODE (d) == VAR_DECL);
14104 /* Variables are never deferred; if instantiation is required, they
14105 are instantiated right away. That allows for better code in the
14106 case that an expression refers to the value of the variable --
14107 if the variable has a constant value the referring expression can
14108 take advantage of that fact. */
14109 if (TREE_CODE (d) == VAR_DECL)
14112 /* Don't instantiate cloned functions. Instead, instantiate the
14113 functions they cloned. */
14114 if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d))
14115 d = DECL_CLONED_FUNCTION (d);
14117 if (DECL_TEMPLATE_INSTANTIATED (d))
14118 /* D has already been instantiated. It might seem reasonable to
14119 check whether or not D is an explicit instantiation, and, if so,
14120 stop here. But when an explicit instantiation is deferred
14121 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
14122 is set, even though we still need to do the instantiation. */
14125 /* If we already have a specialization of this declaration, then
14126 there's no reason to instantiate it. Note that
14127 retrieve_specialization gives us both instantiations and
14128 specializations, so we must explicitly check
14129 DECL_TEMPLATE_SPECIALIZATION. */
14130 gen_tmpl = most_general_template (tmpl);
14131 gen_args = DECL_TI_ARGS (d);
14132 spec = retrieve_specialization (gen_tmpl, gen_args,
14133 /*class_specializations_p=*/false);
14134 if (spec != NULL_TREE && DECL_TEMPLATE_SPECIALIZATION (spec))
14137 /* This needs to happen before any tsubsting. */
14138 if (! push_tinst_level (d))
14141 timevar_push (TV_PARSE);
14143 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
14144 for the instantiation. */
14145 td = template_for_substitution (d);
14146 code_pattern = DECL_TEMPLATE_RESULT (td);
14148 /* We should never be trying to instantiate a member of a class
14149 template or partial specialization. */
14150 gcc_assert (d != code_pattern);
14152 if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d))
14153 || DECL_TEMPLATE_SPECIALIZATION (td))
14154 /* In the case of a friend template whose definition is provided
14155 outside the class, we may have too many arguments. Drop the
14156 ones we don't need. The same is true for specializations. */
14157 args = get_innermost_template_args
14158 (gen_args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td)));
14162 if (TREE_CODE (d) == FUNCTION_DECL)
14163 pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE);
14165 pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
14167 /* We may be in the middle of deferred access check. Disable it now. */
14168 push_deferring_access_checks (dk_no_deferred);
14170 /* Unless an explicit instantiation directive has already determined
14171 the linkage of D, remember that a definition is available for
14173 if (pattern_defined
14174 && !DECL_INTERFACE_KNOWN (d)
14175 && !DECL_NOT_REALLY_EXTERN (d))
14176 mark_definable (d);
14178 input_location = DECL_SOURCE_LOCATION (d);
14179 in_system_header = DECL_IN_SYSTEM_HEADER (d);
14181 /* If D is a member of an explicitly instantiated class template,
14182 and no definition is available, treat it like an implicit
14184 if (!pattern_defined && expl_inst_class_mem_p
14185 && DECL_EXPLICIT_INSTANTIATION (d))
14187 DECL_NOT_REALLY_EXTERN (d) = 0;
14188 DECL_INTERFACE_KNOWN (d) = 0;
14189 SET_DECL_IMPLICIT_INSTANTIATION (d);
14194 /* Recheck the substitutions to obtain any warning messages
14195 about ignoring cv qualifiers. */
14196 tree gen = DECL_TEMPLATE_RESULT (gen_tmpl);
14197 tree type = TREE_TYPE (gen);
14199 /* Make sure that we can see identifiers, and compute access
14200 correctly. D is already the target FUNCTION_DECL with the
14202 push_access_scope (d);
14204 if (TREE_CODE (gen) == FUNCTION_DECL)
14206 tsubst (DECL_ARGUMENTS (gen), gen_args, tf_warning_or_error, d);
14207 tsubst_exception_specification (type, gen_args, tf_warning_or_error,
14209 /* Don't simply tsubst the function type, as that will give
14210 duplicate warnings about poor parameter qualifications.
14211 The function arguments are the same as the decl_arguments
14212 without the top level cv qualifiers. */
14213 type = TREE_TYPE (type);
14215 tsubst (type, gen_args, tf_warning_or_error, d);
14217 pop_access_scope (d);
14220 /* Check to see whether we know that this template will be
14221 instantiated in some other file, as with "extern template"
14223 external_p = (DECL_INTERFACE_KNOWN (d) && DECL_REALLY_EXTERN (d));
14224 /* In general, we do not instantiate such templates... */
14226 /* ... but we instantiate inline functions so that we can inline
14228 && ! (TREE_CODE (d) == FUNCTION_DECL && DECL_INLINE (d))
14229 /* ... we instantiate static data members whose values are
14230 needed in integral constant expressions. */
14231 && ! (TREE_CODE (d) == VAR_DECL
14232 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (d)))
14234 /* Defer all other templates, unless we have been explicitly
14235 forbidden from doing so. */
14236 if (/* If there is no definition, we cannot instantiate the
14239 /* If it's OK to postpone instantiation, do so. */
14241 /* If this is a static data member that will be defined
14242 elsewhere, we don't want to instantiate the entire data
14243 member, but we do want to instantiate the initializer so that
14244 we can substitute that elsewhere. */
14245 || (external_p && TREE_CODE (d) == VAR_DECL))
14247 /* The definition of the static data member is now required so
14248 we must substitute the initializer. */
14249 if (TREE_CODE (d) == VAR_DECL
14250 && !DECL_INITIAL (d)
14251 && DECL_INITIAL (code_pattern))
14256 ns = decl_namespace_context (d);
14257 push_nested_namespace (ns);
14258 push_nested_class (DECL_CONTEXT (d));
14259 init = tsubst_expr (DECL_INITIAL (code_pattern),
14261 tf_warning_or_error, NULL_TREE,
14262 /*integral_constant_expression_p=*/false);
14263 cp_finish_decl (d, init, /*init_const_expr_p=*/false,
14264 /*asmspec_tree=*/NULL_TREE,
14265 LOOKUP_ONLYCONVERTING);
14266 pop_nested_class ();
14267 pop_nested_namespace (ns);
14270 /* We restore the source position here because it's used by
14271 add_pending_template. */
14272 input_location = saved_loc;
14274 if (at_eof && !pattern_defined
14275 && DECL_EXPLICIT_INSTANTIATION (d))
14278 The definition of a non-exported function template, a
14279 non-exported member function template, or a non-exported
14280 member function or static data member of a class template
14281 shall be present in every translation unit in which it is
14282 explicitly instantiated. */
14284 ("explicit instantiation of %qD but no definition available", d);
14286 /* ??? Historically, we have instantiated inline functions, even
14287 when marked as "extern template". */
14288 if (!(external_p && TREE_CODE (d) == VAR_DECL))
14289 add_pending_template (d);
14292 /* Tell the repository that D is available in this translation unit
14293 -- and see if it is supposed to be instantiated here. */
14294 if (TREE_PUBLIC (d) && !DECL_REALLY_EXTERN (d) && !repo_emit_p (d))
14296 /* In a PCH file, despite the fact that the repository hasn't
14297 requested instantiation in the PCH it is still possible that
14298 an instantiation will be required in a file that includes the
14301 add_pending_template (d);
14302 /* Instantiate inline functions so that the inliner can do its
14303 job, even though we'll not be emitting a copy of this
14305 if (!(TREE_CODE (d) == FUNCTION_DECL
14306 && flag_inline_trees
14307 && DECL_DECLARED_INLINE_P (d)))
14311 need_push = !cfun || !global_bindings_p ();
14313 push_to_top_level ();
14315 /* Mark D as instantiated so that recursive calls to
14316 instantiate_decl do not try to instantiate it again. */
14317 DECL_TEMPLATE_INSTANTIATED (d) = 1;
14319 /* Regenerate the declaration in case the template has been modified
14320 by a subsequent redeclaration. */
14321 regenerate_decl_from_template (d, td);
14323 /* We already set the file and line above. Reset them now in case
14324 they changed as a result of calling regenerate_decl_from_template. */
14325 input_location = DECL_SOURCE_LOCATION (d);
14327 if (TREE_CODE (d) == VAR_DECL)
14331 /* Clear out DECL_RTL; whatever was there before may not be right
14332 since we've reset the type of the declaration. */
14333 SET_DECL_RTL (d, NULL_RTX);
14334 DECL_IN_AGGR_P (d) = 0;
14336 /* The initializer is placed in DECL_INITIAL by
14337 regenerate_decl_from_template. Pull it out so that
14338 finish_decl can process it. */
14339 init = DECL_INITIAL (d);
14340 DECL_INITIAL (d) = NULL_TREE;
14341 DECL_INITIALIZED_P (d) = 0;
14343 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
14344 initializer. That function will defer actual emission until
14345 we have a chance to determine linkage. */
14346 DECL_EXTERNAL (d) = 0;
14348 /* Enter the scope of D so that access-checking works correctly. */
14349 push_nested_class (DECL_CONTEXT (d));
14350 finish_decl (d, init, NULL_TREE);
14351 pop_nested_class ();
14353 else if (TREE_CODE (d) == FUNCTION_DECL)
14355 htab_t saved_local_specializations;
14360 /* Save away the current list, in case we are instantiating one
14361 template from within the body of another. */
14362 saved_local_specializations = local_specializations;
14364 /* Set up the list of local specializations. */
14365 local_specializations = htab_create (37,
14366 hash_local_specialization,
14367 eq_local_specializations,
14370 /* Set up context. */
14371 start_preparsed_function (d, NULL_TREE, SF_PRE_PARSED);
14373 /* Create substitution entries for the parameters. */
14374 subst_decl = DECL_TEMPLATE_RESULT (template_for_substitution (d));
14375 tmpl_parm = DECL_ARGUMENTS (subst_decl);
14376 spec_parm = DECL_ARGUMENTS (d);
14377 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d))
14379 register_local_specialization (spec_parm, tmpl_parm);
14380 spec_parm = skip_artificial_parms_for (d, spec_parm);
14381 tmpl_parm = skip_artificial_parms_for (subst_decl, tmpl_parm);
14383 while (tmpl_parm && !FUNCTION_PARAMETER_PACK_P (tmpl_parm))
14385 register_local_specialization (spec_parm, tmpl_parm);
14386 tmpl_parm = TREE_CHAIN (tmpl_parm);
14387 spec_parm = TREE_CHAIN (spec_parm);
14389 if (tmpl_parm && FUNCTION_PARAMETER_PACK_P (tmpl_parm))
14391 /* Collect all of the extra "packed" parameters into an
14395 tree argpack = make_node (NONTYPE_ARGUMENT_PACK);
14396 tree argtypepack = make_node (TYPE_ARGUMENT_PACK);
14400 /* Count how many parameters remain. */
14401 for (t = spec_parm; t; t = TREE_CHAIN (t))
14404 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
14405 parmvec = make_tree_vec (len);
14406 parmtypevec = make_tree_vec (len);
14407 for(i = 0; i < len; i++, spec_parm = TREE_CHAIN (spec_parm))
14409 TREE_VEC_ELT (parmvec, i) = spec_parm;
14410 TREE_VEC_ELT (parmtypevec, i) = TREE_TYPE (spec_parm);
14413 /* Build the argument packs. */
14414 SET_ARGUMENT_PACK_ARGS (argpack, parmvec);
14415 SET_ARGUMENT_PACK_ARGS (argtypepack, parmtypevec);
14416 TREE_TYPE (argpack) = argtypepack;
14418 /* Register the (value) argument pack as a specialization of
14419 TMPL_PARM, then move on. */
14420 register_local_specialization (argpack, tmpl_parm);
14421 tmpl_parm = TREE_CHAIN (tmpl_parm);
14423 gcc_assert (!spec_parm);
14425 /* Substitute into the body of the function. */
14426 tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
14427 tf_warning_or_error, tmpl,
14428 /*integral_constant_expression_p=*/false);
14430 /* We don't need the local specializations any more. */
14431 htab_delete (local_specializations);
14432 local_specializations = saved_local_specializations;
14434 /* Finish the function. */
14435 d = finish_function (0);
14436 expand_or_defer_fn (d);
14439 /* We're not deferring instantiation any more. */
14440 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
14443 pop_from_top_level ();
14446 input_location = saved_loc;
14447 in_system_header = saved_in_system_header;
14448 pop_deferring_access_checks ();
14449 pop_tinst_level ();
14451 timevar_pop (TV_PARSE);
14456 /* Run through the list of templates that we wish we could
14457 instantiate, and instantiate any we can. RETRIES is the
14458 number of times we retry pending template instantiation. */
14461 instantiate_pending_templates (int retries)
14464 tree last = NULL_TREE;
14466 location_t saved_loc = input_location;
14467 int saved_in_system_header = in_system_header;
14469 /* Instantiating templates may trigger vtable generation. This in turn
14470 may require further template instantiations. We place a limit here
14471 to avoid infinite loop. */
14472 if (pending_templates && retries >= max_tinst_depth)
14474 tree decl = TREE_VALUE (pending_templates);
14476 error ("template instantiation depth exceeds maximum of %d"
14477 " instantiating %q+D, possibly from virtual table generation"
14478 " (use -ftemplate-depth-NN to increase the maximum)",
14479 max_tinst_depth, decl);
14480 if (TREE_CODE (decl) == FUNCTION_DECL)
14481 /* Pretend that we defined it. */
14482 DECL_INITIAL (decl) = error_mark_node;
14490 t = &pending_templates;
14493 tree instantiation = TREE_VALUE (*t);
14495 reopen_tinst_level (TREE_PURPOSE (*t));
14497 if (TYPE_P (instantiation))
14501 if (!COMPLETE_TYPE_P (instantiation))
14503 instantiate_class_template (instantiation);
14504 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
14505 for (fn = TYPE_METHODS (instantiation);
14507 fn = TREE_CHAIN (fn))
14508 if (! DECL_ARTIFICIAL (fn))
14509 instantiate_decl (fn,
14511 /*expl_inst_class_mem_p=*/false);
14512 if (COMPLETE_TYPE_P (instantiation))
14516 if (COMPLETE_TYPE_P (instantiation))
14517 /* If INSTANTIATION has been instantiated, then we don't
14518 need to consider it again in the future. */
14519 *t = TREE_CHAIN (*t);
14523 t = &TREE_CHAIN (*t);
14528 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation)
14529 && !DECL_TEMPLATE_INSTANTIATED (instantiation))
14532 = instantiate_decl (instantiation,
14534 /*expl_inst_class_mem_p=*/false);
14535 if (DECL_TEMPLATE_INSTANTIATED (instantiation))
14539 if (DECL_TEMPLATE_SPECIALIZATION (instantiation)
14540 || DECL_TEMPLATE_INSTANTIATED (instantiation))
14541 /* If INSTANTIATION has been instantiated, then we don't
14542 need to consider it again in the future. */
14543 *t = TREE_CHAIN (*t);
14547 t = &TREE_CHAIN (*t);
14551 current_tinst_level = NULL_TREE;
14553 last_pending_template = last;
14555 while (reconsider);
14557 input_location = saved_loc;
14558 in_system_header = saved_in_system_header;
14561 /* Substitute ARGVEC into T, which is a list of initializers for
14562 either base class or a non-static data member. The TREE_PURPOSEs
14563 are DECLs, and the TREE_VALUEs are the initializer values. Used by
14564 instantiate_decl. */
14567 tsubst_initializer_list (tree t, tree argvec)
14569 tree inits = NULL_TREE;
14571 for (; t; t = TREE_CHAIN (t))
14575 tree expanded_bases = NULL_TREE;
14576 tree expanded_arguments = NULL_TREE;
14579 if (TREE_CODE (TREE_PURPOSE (t)) == TYPE_PACK_EXPANSION)
14584 /* Expand the base class expansion type into separate base
14586 expanded_bases = tsubst_pack_expansion (TREE_PURPOSE (t), argvec,
14587 tf_warning_or_error,
14589 if (expanded_bases == error_mark_node)
14592 /* We'll be building separate TREE_LISTs of arguments for
14594 len = TREE_VEC_LENGTH (expanded_bases);
14595 expanded_arguments = make_tree_vec (len);
14596 for (i = 0; i < len; i++)
14597 TREE_VEC_ELT (expanded_arguments, i) = NULL_TREE;
14599 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
14600 expand each argument in the TREE_VALUE of t. */
14601 expr = make_node (EXPR_PACK_EXPANSION);
14602 PACK_EXPANSION_PARAMETER_PACKS (expr) =
14603 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t));
14605 /* Substitute parameter packs into each argument in the
14607 in_base_initializer = 1;
14608 for (arg = TREE_VALUE (t); arg; arg = TREE_CHAIN (arg))
14610 tree expanded_exprs;
14612 /* Expand the argument. */
14613 SET_PACK_EXPANSION_PATTERN (expr, TREE_VALUE (arg));
14614 expanded_exprs = tsubst_pack_expansion (expr, argvec,
14615 tf_warning_or_error,
14618 /* Prepend each of the expanded expressions to the
14619 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
14620 for (i = 0; i < len; i++)
14622 TREE_VEC_ELT (expanded_arguments, i) =
14623 tree_cons (NULL_TREE, TREE_VEC_ELT (expanded_exprs, i),
14624 TREE_VEC_ELT (expanded_arguments, i));
14627 in_base_initializer = 0;
14629 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
14630 since we built them backwards. */
14631 for (i = 0; i < len; i++)
14633 TREE_VEC_ELT (expanded_arguments, i) =
14634 nreverse (TREE_VEC_ELT (expanded_arguments, i));
14638 for (i = 0; i < len; ++i)
14640 if (expanded_bases)
14642 decl = TREE_VEC_ELT (expanded_bases, i);
14643 decl = expand_member_init (decl);
14644 init = TREE_VEC_ELT (expanded_arguments, i);
14648 decl = tsubst_copy (TREE_PURPOSE (t), argvec,
14649 tf_warning_or_error, NULL_TREE);
14651 decl = expand_member_init (decl);
14652 if (decl && !DECL_P (decl))
14653 in_base_initializer = 1;
14655 init = tsubst_expr (TREE_VALUE (t), argvec,
14656 tf_warning_or_error, NULL_TREE,
14657 /*integral_constant_expression_p=*/false);
14658 in_base_initializer = 0;
14663 init = build_tree_list (decl, init);
14664 TREE_CHAIN (init) = inits;
14672 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
14675 set_current_access_from_decl (tree decl)
14677 if (TREE_PRIVATE (decl))
14678 current_access_specifier = access_private_node;
14679 else if (TREE_PROTECTED (decl))
14680 current_access_specifier = access_protected_node;
14682 current_access_specifier = access_public_node;
14685 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
14686 is the instantiation (which should have been created with
14687 start_enum) and ARGS are the template arguments to use. */
14690 tsubst_enum (tree tag, tree newtag, tree args)
14694 for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
14699 decl = TREE_VALUE (e);
14700 /* Note that in a template enum, the TREE_VALUE is the
14701 CONST_DECL, not the corresponding INTEGER_CST. */
14702 value = tsubst_expr (DECL_INITIAL (decl),
14703 args, tf_warning_or_error, NULL_TREE,
14704 /*integral_constant_expression_p=*/true);
14706 /* Give this enumeration constant the correct access. */
14707 set_current_access_from_decl (decl);
14709 /* Actually build the enumerator itself. */
14710 build_enumerator (DECL_NAME (decl), value, newtag);
14713 finish_enum (newtag);
14714 DECL_SOURCE_LOCATION (TYPE_NAME (newtag))
14715 = DECL_SOURCE_LOCATION (TYPE_NAME (tag));
14718 /* DECL is a FUNCTION_DECL that is a template specialization. Return
14719 its type -- but without substituting the innermost set of template
14720 arguments. So, innermost set of template parameters will appear in
14724 get_mostly_instantiated_function_type (tree decl)
14732 tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
14733 targs = DECL_TI_ARGS (decl);
14734 tparms = DECL_TEMPLATE_PARMS (tmpl);
14735 parm_depth = TMPL_PARMS_DEPTH (tparms);
14737 /* There should be as many levels of arguments as there are levels
14739 gcc_assert (parm_depth == TMPL_ARGS_DEPTH (targs));
14741 fn_type = TREE_TYPE (tmpl);
14743 if (parm_depth == 1)
14744 /* No substitution is necessary. */
14748 int i, save_access_control;
14751 /* Replace the innermost level of the TARGS with NULL_TREEs to
14752 let tsubst know not to substitute for those parameters. */
14753 partial_args = make_tree_vec (TREE_VEC_LENGTH (targs));
14754 for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i)
14755 SET_TMPL_ARGS_LEVEL (partial_args, i,
14756 TMPL_ARGS_LEVEL (targs, i));
14757 SET_TMPL_ARGS_LEVEL (partial_args,
14758 TMPL_ARGS_DEPTH (targs),
14759 make_tree_vec (DECL_NTPARMS (tmpl)));
14761 /* Disable access control as this function is used only during
14763 save_access_control = flag_access_control;
14764 flag_access_control = 0;
14766 ++processing_template_decl;
14767 /* Now, do the (partial) substitution to figure out the
14768 appropriate function type. */
14769 fn_type = tsubst (fn_type, partial_args, tf_error, NULL_TREE);
14770 --processing_template_decl;
14772 /* Substitute into the template parameters to obtain the real
14773 innermost set of parameters. This step is important if the
14774 innermost set of template parameters contains value
14775 parameters whose types depend on outer template parameters. */
14776 TREE_VEC_LENGTH (partial_args)--;
14777 tparms = tsubst_template_parms (tparms, partial_args, tf_error);
14779 flag_access_control = save_access_control;
14785 /* Return truthvalue if we're processing a template different from
14786 the last one involved in diagnostics. */
14788 problematic_instantiation_changed (void)
14790 return last_template_error_tick != tinst_level_tick;
14793 /* Remember current template involved in diagnostics. */
14795 record_last_problematic_instantiation (void)
14797 last_template_error_tick = tinst_level_tick;
14801 current_instantiation (void)
14803 return current_tinst_level;
14806 /* [temp.param] Check that template non-type parm TYPE is of an allowable
14807 type. Return zero for ok, nonzero for disallowed. Issue error and
14808 warning messages under control of COMPLAIN. */
14811 invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain)
14813 if (INTEGRAL_TYPE_P (type))
14815 else if (POINTER_TYPE_P (type))
14817 else if (TYPE_PTR_TO_MEMBER_P (type))
14819 else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
14821 else if (TREE_CODE (type) == TYPENAME_TYPE)
14824 if (complain & tf_error)
14825 error ("%q#T is not a valid type for a template constant parameter", type);
14829 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
14830 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
14833 dependent_type_p_r (tree type)
14839 A type is dependent if it is:
14841 -- a template parameter. Template template parameters are types
14842 for us (since TYPE_P holds true for them) so we handle
14844 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
14845 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
14847 /* -- a qualified-id with a nested-name-specifier which contains a
14848 class-name that names a dependent type or whose unqualified-id
14849 names a dependent type. */
14850 if (TREE_CODE (type) == TYPENAME_TYPE)
14852 /* -- a cv-qualified type where the cv-unqualified type is
14854 type = TYPE_MAIN_VARIANT (type);
14855 /* -- a compound type constructed from any dependent type. */
14856 if (TYPE_PTR_TO_MEMBER_P (type))
14857 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type))
14858 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
14860 else if (TREE_CODE (type) == POINTER_TYPE
14861 || TREE_CODE (type) == REFERENCE_TYPE)
14862 return dependent_type_p (TREE_TYPE (type));
14863 else if (TREE_CODE (type) == FUNCTION_TYPE
14864 || TREE_CODE (type) == METHOD_TYPE)
14868 if (dependent_type_p (TREE_TYPE (type)))
14870 for (arg_type = TYPE_ARG_TYPES (type);
14872 arg_type = TREE_CHAIN (arg_type))
14873 if (dependent_type_p (TREE_VALUE (arg_type)))
14877 /* -- an array type constructed from any dependent type or whose
14878 size is specified by a constant expression that is
14879 value-dependent. */
14880 if (TREE_CODE (type) == ARRAY_TYPE)
14882 if (TYPE_DOMAIN (type)
14883 && ((value_dependent_expression_p
14884 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
14885 || (type_dependent_expression_p
14886 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))))
14888 return dependent_type_p (TREE_TYPE (type));
14891 /* -- a template-id in which either the template name is a template
14893 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
14895 /* ... or any of the template arguments is a dependent type or
14896 an expression that is type-dependent or value-dependent. */
14897 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
14898 && (any_dependent_template_arguments_p
14899 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
14902 /* All TYPEOF_TYPEs are dependent; if the argument of the `typeof'
14903 expression is not type-dependent, then it should already been
14905 if (TREE_CODE (type) == TYPEOF_TYPE)
14908 /* A template argument pack is dependent if any of its packed
14910 if (TREE_CODE (type) == TYPE_ARGUMENT_PACK)
14912 tree args = ARGUMENT_PACK_ARGS (type);
14913 int i, len = TREE_VEC_LENGTH (args);
14914 for (i = 0; i < len; ++i)
14915 if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
14919 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
14920 be template parameters. */
14921 if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
14924 /* The standard does not specifically mention types that are local
14925 to template functions or local classes, but they should be
14926 considered dependent too. For example:
14928 template <int I> void f() {
14933 The size of `E' cannot be known until the value of `I' has been
14934 determined. Therefore, `E' must be considered dependent. */
14935 scope = TYPE_CONTEXT (type);
14936 if (scope && TYPE_P (scope))
14937 return dependent_type_p (scope);
14938 else if (scope && TREE_CODE (scope) == FUNCTION_DECL)
14939 return type_dependent_expression_p (scope);
14941 /* Other types are non-dependent. */
14945 /* Returns TRUE if TYPE is dependent, in the sense of
14946 [temp.dep.type]. */
14949 dependent_type_p (tree type)
14951 /* If there are no template parameters in scope, then there can't be
14952 any dependent types. */
14953 if (!processing_template_decl)
14955 /* If we are not processing a template, then nobody should be
14956 providing us with a dependent type. */
14958 gcc_assert (TREE_CODE (type) != TEMPLATE_TYPE_PARM);
14962 /* If the type is NULL, we have not computed a type for the entity
14963 in question; in that case, the type is dependent. */
14967 /* Erroneous types can be considered non-dependent. */
14968 if (type == error_mark_node)
14971 /* If we have not already computed the appropriate value for TYPE,
14973 if (!TYPE_DEPENDENT_P_VALID (type))
14975 TYPE_DEPENDENT_P (type) = dependent_type_p_r (type);
14976 TYPE_DEPENDENT_P_VALID (type) = 1;
14979 return TYPE_DEPENDENT_P (type);
14982 /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
14985 dependent_scope_ref_p (tree expression, bool criterion (tree))
14990 gcc_assert (TREE_CODE (expression) == SCOPE_REF);
14992 if (!TYPE_P (TREE_OPERAND (expression, 0)))
14995 scope = TREE_OPERAND (expression, 0);
14996 name = TREE_OPERAND (expression, 1);
15000 An id-expression is type-dependent if it contains a
15001 nested-name-specifier that contains a class-name that names a
15003 /* The suggested resolution to Core Issue 2 implies that if the
15004 qualifying type is the current class, then we must peek
15007 && currently_open_class (scope)
15008 && !criterion (name))
15010 if (dependent_type_p (scope))
15016 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
15017 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
15021 value_dependent_expression_p (tree expression)
15023 if (!processing_template_decl)
15026 /* A name declared with a dependent type. */
15027 if (DECL_P (expression) && type_dependent_expression_p (expression))
15030 switch (TREE_CODE (expression))
15032 case IDENTIFIER_NODE:
15033 /* A name that has not been looked up -- must be dependent. */
15036 case TEMPLATE_PARM_INDEX:
15037 /* A non-type template parm. */
15041 /* A non-type template parm. */
15042 if (DECL_TEMPLATE_PARM_P (expression))
15047 /* A constant with integral or enumeration type and is initialized
15048 with an expression that is value-dependent. */
15049 if (DECL_INITIAL (expression)
15050 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression))
15051 && value_dependent_expression_p (DECL_INITIAL (expression)))
15055 case DYNAMIC_CAST_EXPR:
15056 case STATIC_CAST_EXPR:
15057 case CONST_CAST_EXPR:
15058 case REINTERPRET_CAST_EXPR:
15060 /* These expressions are value-dependent if the type to which
15061 the cast occurs is dependent or the expression being casted
15062 is value-dependent. */
15064 tree type = TREE_TYPE (expression);
15066 if (dependent_type_p (type))
15069 /* A functional cast has a list of operands. */
15070 expression = TREE_OPERAND (expression, 0);
15073 /* If there are no operands, it must be an expression such
15074 as "int()". This should not happen for aggregate types
15075 because it would form non-constant expressions. */
15076 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
15081 if (TREE_CODE (expression) == TREE_LIST)
15082 return any_value_dependent_elements_p (expression);
15084 return value_dependent_expression_p (expression);
15089 /* A `sizeof' expression is value-dependent if the operand is
15090 type-dependent or is a pack expansion. */
15091 expression = TREE_OPERAND (expression, 0);
15092 if (PACK_EXPANSION_P (expression))
15094 else if (TYPE_P (expression))
15095 return dependent_type_p (expression);
15096 return type_dependent_expression_p (expression);
15099 return dependent_scope_ref_p (expression, value_dependent_expression_p);
15101 case COMPONENT_REF:
15102 return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
15103 || value_dependent_expression_p (TREE_OPERAND (expression, 1)));
15106 /* A CALL_EXPR may appear in a constant expression if it is a
15107 call to a builtin function, e.g., __builtin_constant_p. All
15108 such calls are value-dependent. */
15111 case NONTYPE_ARGUMENT_PACK:
15112 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
15113 is value-dependent. */
15115 tree values = ARGUMENT_PACK_ARGS (expression);
15116 int i, len = TREE_VEC_LENGTH (values);
15118 for (i = 0; i < len; ++i)
15119 if (value_dependent_expression_p (TREE_VEC_ELT (values, i)))
15127 tree type2 = TRAIT_EXPR_TYPE2 (expression);
15128 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression))
15129 || (type2 ? dependent_type_p (type2) : false));
15133 return ((value_dependent_expression_p (TREE_OPERAND (expression, 0)))
15134 || (value_dependent_expression_p (TREE_OPERAND (expression, 2))));
15137 /* A constant expression is value-dependent if any subexpression is
15138 value-dependent. */
15139 switch (TREE_CODE_CLASS (TREE_CODE (expression)))
15141 case tcc_reference:
15143 return (value_dependent_expression_p
15144 (TREE_OPERAND (expression, 0)));
15146 case tcc_comparison:
15148 return ((value_dependent_expression_p
15149 (TREE_OPERAND (expression, 0)))
15150 || (value_dependent_expression_p
15151 (TREE_OPERAND (expression, 1))));
15153 case tcc_expression:
15157 for (i = 0; i < TREE_OPERAND_LENGTH (expression); ++i)
15158 /* In some cases, some of the operands may be missing.
15159 (For example, in the case of PREDECREMENT_EXPR, the
15160 amount to increment by may be missing.) That doesn't
15161 make the expression dependent. */
15162 if (TREE_OPERAND (expression, i)
15163 && (value_dependent_expression_p
15164 (TREE_OPERAND (expression, i))))
15174 /* The expression is not value-dependent. */
15178 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
15179 [temp.dep.expr]. */
15182 type_dependent_expression_p (tree expression)
15184 if (!processing_template_decl)
15187 if (expression == error_mark_node)
15190 /* An unresolved name is always dependent. */
15191 if (TREE_CODE (expression) == IDENTIFIER_NODE
15192 || TREE_CODE (expression) == USING_DECL)
15195 /* Some expression forms are never type-dependent. */
15196 if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR
15197 || TREE_CODE (expression) == SIZEOF_EXPR
15198 || TREE_CODE (expression) == ALIGNOF_EXPR
15199 || TREE_CODE (expression) == TRAIT_EXPR
15200 || TREE_CODE (expression) == TYPEID_EXPR
15201 || TREE_CODE (expression) == DELETE_EXPR
15202 || TREE_CODE (expression) == VEC_DELETE_EXPR
15203 || TREE_CODE (expression) == THROW_EXPR)
15206 /* The types of these expressions depends only on the type to which
15207 the cast occurs. */
15208 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
15209 || TREE_CODE (expression) == STATIC_CAST_EXPR
15210 || TREE_CODE (expression) == CONST_CAST_EXPR
15211 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
15212 || TREE_CODE (expression) == CAST_EXPR)
15213 return dependent_type_p (TREE_TYPE (expression));
15215 /* The types of these expressions depends only on the type created
15216 by the expression. */
15217 if (TREE_CODE (expression) == NEW_EXPR
15218 || TREE_CODE (expression) == VEC_NEW_EXPR)
15220 /* For NEW_EXPR tree nodes created inside a template, either
15221 the object type itself or a TREE_LIST may appear as the
15223 tree type = TREE_OPERAND (expression, 1);
15224 if (TREE_CODE (type) == TREE_LIST)
15225 /* This is an array type. We need to check array dimensions
15227 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type)))
15228 || value_dependent_expression_p
15229 (TREE_OPERAND (TREE_VALUE (type), 1));
15231 return dependent_type_p (type);
15234 if (TREE_CODE (expression) == SCOPE_REF
15235 && dependent_scope_ref_p (expression,
15236 type_dependent_expression_p))
15239 if (TREE_CODE (expression) == FUNCTION_DECL
15240 && DECL_LANG_SPECIFIC (expression)
15241 && DECL_TEMPLATE_INFO (expression)
15242 && (any_dependent_template_arguments_p
15243 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
15246 if (TREE_CODE (expression) == TEMPLATE_DECL
15247 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression))
15250 if (TREE_TYPE (expression) == unknown_type_node)
15252 if (TREE_CODE (expression) == ADDR_EXPR)
15253 return type_dependent_expression_p (TREE_OPERAND (expression, 0));
15254 if (TREE_CODE (expression) == COMPONENT_REF
15255 || TREE_CODE (expression) == OFFSET_REF)
15257 if (type_dependent_expression_p (TREE_OPERAND (expression, 0)))
15259 expression = TREE_OPERAND (expression, 1);
15260 if (TREE_CODE (expression) == IDENTIFIER_NODE)
15263 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
15264 if (TREE_CODE (expression) == SCOPE_REF)
15267 if (TREE_CODE (expression) == BASELINK)
15268 expression = BASELINK_FUNCTIONS (expression);
15270 if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
15272 if (any_dependent_template_arguments_p
15273 (TREE_OPERAND (expression, 1)))
15275 expression = TREE_OPERAND (expression, 0);
15277 gcc_assert (TREE_CODE (expression) == OVERLOAD
15278 || TREE_CODE (expression) == FUNCTION_DECL);
15282 if (type_dependent_expression_p (OVL_CURRENT (expression)))
15284 expression = OVL_NEXT (expression);
15289 gcc_assert (TREE_CODE (expression) != TYPE_DECL);
15291 return (dependent_type_p (TREE_TYPE (expression)));
15294 /* Returns TRUE if ARGS (a TREE_LIST of arguments to a function call)
15295 contains a type-dependent expression. */
15298 any_type_dependent_arguments_p (tree args)
15302 tree arg = TREE_VALUE (args);
15304 if (type_dependent_expression_p (arg))
15306 args = TREE_CHAIN (args);
15311 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
15312 expressions) contains any value-dependent expressions. */
15315 any_value_dependent_elements_p (tree list)
15317 for (; list; list = TREE_CHAIN (list))
15318 if (value_dependent_expression_p (TREE_VALUE (list)))
15324 /* Returns TRUE if the ARG (a template argument) is dependent. */
15327 dependent_template_arg_p (tree arg)
15329 if (!processing_template_decl)
15332 if (TREE_CODE (arg) == TEMPLATE_DECL
15333 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
15334 return dependent_template_p (arg);
15335 else if (ARGUMENT_PACK_P (arg))
15337 tree args = ARGUMENT_PACK_ARGS (arg);
15338 int i, len = TREE_VEC_LENGTH (args);
15339 for (i = 0; i < len; ++i)
15341 if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
15347 else if (TYPE_P (arg))
15348 return dependent_type_p (arg);
15350 return (type_dependent_expression_p (arg)
15351 || value_dependent_expression_p (arg));
15354 /* Returns true if ARGS (a collection of template arguments) contains
15355 any types that require structural equality testing. */
15358 any_template_arguments_need_structural_equality_p (tree args)
15365 if (args == error_mark_node)
15368 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
15370 tree level = TMPL_ARGS_LEVEL (args, i + 1);
15371 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
15373 tree arg = TREE_VEC_ELT (level, j);
15374 tree packed_args = NULL_TREE;
15377 if (ARGUMENT_PACK_P (arg))
15379 /* Look inside the argument pack. */
15380 packed_args = ARGUMENT_PACK_ARGS (arg);
15381 len = TREE_VEC_LENGTH (packed_args);
15384 for (k = 0; k < len; ++k)
15387 arg = TREE_VEC_ELT (packed_args, k);
15389 if (error_operand_p (arg))
15391 else if (TREE_CODE (arg) == TEMPLATE_DECL
15392 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
15394 else if (TYPE_P (arg) && TYPE_STRUCTURAL_EQUALITY_P (arg))
15396 else if (!TYPE_P (arg) && TREE_TYPE (arg)
15397 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg)))
15406 /* Returns true if ARGS (a collection of template arguments) contains
15407 any dependent arguments. */
15410 any_dependent_template_arguments_p (tree args)
15417 if (args == error_mark_node)
15420 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
15422 tree level = TMPL_ARGS_LEVEL (args, i + 1);
15423 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
15424 if (dependent_template_arg_p (TREE_VEC_ELT (level, j)))
15431 /* Returns TRUE if the template TMPL is dependent. */
15434 dependent_template_p (tree tmpl)
15436 if (TREE_CODE (tmpl) == OVERLOAD)
15440 if (dependent_template_p (OVL_FUNCTION (tmpl)))
15442 tmpl = OVL_CHAIN (tmpl);
15447 /* Template template parameters are dependent. */
15448 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
15449 || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
15451 /* So are names that have not been looked up. */
15452 if (TREE_CODE (tmpl) == SCOPE_REF
15453 || TREE_CODE (tmpl) == IDENTIFIER_NODE)
15455 /* So are member templates of dependent classes. */
15456 if (TYPE_P (CP_DECL_CONTEXT (tmpl)))
15457 return dependent_type_p (DECL_CONTEXT (tmpl));
15461 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
15464 dependent_template_id_p (tree tmpl, tree args)
15466 return (dependent_template_p (tmpl)
15467 || any_dependent_template_arguments_p (args));
15470 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
15471 TYPENAME_TYPE corresponds. Returns ERROR_MARK_NODE if no such TYPE
15472 can be found. Note that this function peers inside uninstantiated
15473 templates and therefore should be used only in extremely limited
15474 situations. ONLY_CURRENT_P restricts this peering to the currently
15475 open classes hierarchy (which is required when comparing types). */
15478 resolve_typename_type (tree type, bool only_current_p)
15486 gcc_assert (TREE_CODE (type) == TYPENAME_TYPE);
15488 scope = TYPE_CONTEXT (type);
15489 name = TYPE_IDENTIFIER (type);
15491 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
15492 it first before we can figure out what NAME refers to. */
15493 if (TREE_CODE (scope) == TYPENAME_TYPE)
15494 scope = resolve_typename_type (scope, only_current_p);
15495 /* If we don't know what SCOPE refers to, then we cannot resolve the
15497 if (scope == error_mark_node || TREE_CODE (scope) == TYPENAME_TYPE)
15498 return error_mark_node;
15499 /* If the SCOPE is a template type parameter, we have no way of
15500 resolving the name. */
15501 if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
15503 /* If the SCOPE is not the current instantiation, there's no reason
15504 to look inside it. */
15505 if (only_current_p && !currently_open_class (scope))
15506 return error_mark_node;
15507 /* If SCOPE is a partial instantiation, it will not have a valid
15508 TYPE_FIELDS list, so use the original template. */
15509 scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope);
15510 /* Enter the SCOPE so that name lookup will be resolved as if we
15511 were in the class definition. In particular, SCOPE will no
15512 longer be considered a dependent type. */
15513 pushed_scope = push_scope (scope);
15514 /* Look up the declaration. */
15515 decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true);
15516 /* Obtain the set of qualifiers applied to the TYPE. */
15517 quals = cp_type_quals (type);
15518 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
15519 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
15521 type = error_mark_node;
15522 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE
15523 && TREE_CODE (decl) == TYPE_DECL)
15524 type = TREE_TYPE (decl);
15525 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR
15526 && DECL_CLASS_TEMPLATE_P (decl))
15530 /* Obtain the template and the arguments. */
15531 tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0);
15532 args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1);
15533 /* Instantiate the template. */
15534 type = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE,
15535 /*entering_scope=*/0, tf_error | tf_user);
15538 type = error_mark_node;
15539 /* Qualify the resulting type. */
15540 if (type != error_mark_node && quals)
15541 type = cp_build_qualified_type (type, quals);
15542 /* Leave the SCOPE. */
15544 pop_scope (pushed_scope);
15549 /* EXPR is an expression which is not type-dependent. Return a proxy
15550 for EXPR that can be used to compute the types of larger
15551 expressions containing EXPR. */
15554 build_non_dependent_expr (tree expr)
15558 /* Preserve null pointer constants so that the type of things like
15559 "p == 0" where "p" is a pointer can be determined. */
15560 if (null_ptr_cst_p (expr))
15562 /* Preserve OVERLOADs; the functions must be available to resolve
15565 if (TREE_CODE (inner_expr) == ADDR_EXPR)
15566 inner_expr = TREE_OPERAND (inner_expr, 0);
15567 if (TREE_CODE (inner_expr) == COMPONENT_REF)
15568 inner_expr = TREE_OPERAND (inner_expr, 1);
15569 if (is_overloaded_fn (inner_expr)
15570 || TREE_CODE (inner_expr) == OFFSET_REF)
15572 /* There is no need to return a proxy for a variable. */
15573 if (TREE_CODE (expr) == VAR_DECL)
15575 /* Preserve string constants; conversions from string constants to
15576 "char *" are allowed, even though normally a "const char *"
15577 cannot be used to initialize a "char *". */
15578 if (TREE_CODE (expr) == STRING_CST)
15580 /* Preserve arithmetic constants, as an optimization -- there is no
15581 reason to create a new node. */
15582 if (TREE_CODE (expr) == INTEGER_CST || TREE_CODE (expr) == REAL_CST)
15584 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
15585 There is at least one place where we want to know that a
15586 particular expression is a throw-expression: when checking a ?:
15587 expression, there are special rules if the second or third
15588 argument is a throw-expression. */
15589 if (TREE_CODE (expr) == THROW_EXPR)
15592 if (TREE_CODE (expr) == COND_EXPR)
15593 return build3 (COND_EXPR,
15595 TREE_OPERAND (expr, 0),
15596 (TREE_OPERAND (expr, 1)
15597 ? build_non_dependent_expr (TREE_OPERAND (expr, 1))
15598 : build_non_dependent_expr (TREE_OPERAND (expr, 0))),
15599 build_non_dependent_expr (TREE_OPERAND (expr, 2)));
15600 if (TREE_CODE (expr) == COMPOUND_EXPR
15601 && !COMPOUND_EXPR_OVERLOADED (expr))
15602 return build2 (COMPOUND_EXPR,
15604 TREE_OPERAND (expr, 0),
15605 build_non_dependent_expr (TREE_OPERAND (expr, 1)));
15607 /* If the type is unknown, it can't really be non-dependent */
15608 gcc_assert (TREE_TYPE (expr) != unknown_type_node);
15610 /* Otherwise, build a NON_DEPENDENT_EXPR.
15612 REFERENCE_TYPEs are not stripped for expressions in templates
15613 because doing so would play havoc with mangling. Consider, for
15616 template <typename T> void f<T& g>() { g(); }
15618 In the body of "f", the expression for "g" will have
15619 REFERENCE_TYPE, even though the standard says that it should
15620 not. The reason is that we must preserve the syntactic form of
15621 the expression so that mangling (say) "f<g>" inside the body of
15622 "f" works out correctly. Therefore, the REFERENCE_TYPE is
15624 return build1 (NON_DEPENDENT_EXPR, non_reference (TREE_TYPE (expr)), expr);
15627 /* ARGS is a TREE_LIST of expressions as arguments to a function call.
15628 Return a new TREE_LIST with the various arguments replaced with
15629 equivalent non-dependent expressions. */
15632 build_non_dependent_args (tree args)
15637 new_args = NULL_TREE;
15638 for (a = args; a; a = TREE_CHAIN (a))
15639 new_args = tree_cons (NULL_TREE,
15640 build_non_dependent_expr (TREE_VALUE (a)),
15642 return nreverse (new_args);
15645 #include "gt-cp-pt.h"