1 /* Handle parameterized types (templates) for GNU C++.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
4 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
5 Rewritten by Jason Merrill (jason@cygnus.com).
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 /* Known bugs or deficiencies include:
25 all methods must be provided in header files; can't use a source
26 file that contains only the method templates and "just win". */
30 #include "coretypes.h"
34 #include "pointer-set.h"
38 #include "cp-objcp-common.h"
39 #include "tree-inline.h"
46 #include "tree-iterator.h"
49 /* The type of functions taking a tree, and some additional data, and
51 typedef int (*tree_fn_t) (tree, void*);
53 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
54 instantiations have been deferred, either because their definitions
55 were not yet available, or because we were putting off doing the work. */
56 struct pending_template GTY (()) {
57 struct pending_template *next;
58 struct tinst_level *tinst;
61 static GTY(()) struct pending_template *pending_templates;
62 static GTY(()) struct pending_template *last_pending_template;
64 int processing_template_parmlist;
65 static int template_header_count;
67 static GTY(()) tree saved_trees;
68 static VEC(int,heap) *inline_parm_levels;
70 static GTY(()) struct tinst_level *current_tinst_level;
72 static GTY(()) tree saved_access_scope;
74 /* Live only within one (recursive) call to tsubst_expr. We use
75 this to pass the statement expression node from the STMT_EXPR
76 to the EXPR_STMT that is its result. */
77 static tree cur_stmt_expr;
79 /* A map from local variable declarations in the body of the template
80 presently being instantiated to the corresponding instantiated
82 static htab_t local_specializations;
84 /* Contains canonical template parameter types. The vector is indexed by
85 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
86 TREE_LIST, whose TREE_VALUEs contain the canonical template
87 parameters of various types and levels. */
88 static GTY(()) VEC(tree,gc) *canonical_template_parms;
90 #define UNIFY_ALLOW_NONE 0
91 #define UNIFY_ALLOW_MORE_CV_QUAL 1
92 #define UNIFY_ALLOW_LESS_CV_QUAL 2
93 #define UNIFY_ALLOW_DERIVED 4
94 #define UNIFY_ALLOW_INTEGER 8
95 #define UNIFY_ALLOW_OUTER_LEVEL 16
96 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
97 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
99 static void push_access_scope (tree);
100 static void pop_access_scope (tree);
101 static bool resolve_overloaded_unification (tree, tree, tree, tree,
102 unification_kind_t, int);
103 static int try_one_overload (tree, tree, tree, tree, tree,
104 unification_kind_t, int, bool);
105 static int unify (tree, tree, tree, tree, int);
106 static void add_pending_template (tree);
107 static int push_tinst_level (tree);
108 static void pop_tinst_level (void);
109 static tree reopen_tinst_level (struct tinst_level *);
110 static tree tsubst_initializer_list (tree, tree);
111 static tree get_class_bindings (tree, tree, tree);
112 static tree coerce_template_parms (tree, tree, tree, tsubst_flags_t,
114 static void tsubst_enum (tree, tree, tree);
115 static tree add_to_template_args (tree, tree);
116 static tree add_outermost_template_args (tree, tree);
117 static bool check_instantiated_args (tree, tree, tsubst_flags_t);
118 static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*,
120 static int type_unification_real (tree, tree, tree, tree,
121 int, unification_kind_t, int);
122 static void note_template_header (int);
123 static tree convert_nontype_argument_function (tree, tree);
124 static tree convert_nontype_argument (tree, tree);
125 static tree convert_template_argument (tree, tree, tree,
126 tsubst_flags_t, int, tree);
127 static int for_each_template_parm (tree, tree_fn_t, void*,
128 struct pointer_set_t*, bool);
129 static tree expand_template_argument_pack (tree);
130 static tree build_template_parm_index (int, int, int, tree, tree);
131 static bool inline_needs_template_parms (tree);
132 static void push_inline_template_parms_recursive (tree, int);
133 static tree retrieve_local_specialization (tree);
134 static void register_local_specialization (tree, tree);
135 static tree reduce_template_parm_level (tree, tree, int, tree, tsubst_flags_t);
136 static int mark_template_parm (tree, void *);
137 static int template_parm_this_level_p (tree, void *);
138 static tree tsubst_friend_function (tree, tree);
139 static tree tsubst_friend_class (tree, tree);
140 static int can_complete_type_without_circularity (tree);
141 static tree get_bindings (tree, tree, tree, bool);
142 static int template_decl_level (tree);
143 static int check_cv_quals_for_unify (int, tree, tree);
144 static void template_parm_level_and_index (tree, int*, int*);
145 static int unify_pack_expansion (tree, tree, tree, tree, int, bool, bool);
146 static tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree);
147 static tree tsubst_template_args (tree, tree, tsubst_flags_t, tree);
148 static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
149 static void regenerate_decl_from_template (tree, tree);
150 static tree most_specialized_class (tree, tree);
151 static tree tsubst_aggr_type (tree, tree, tsubst_flags_t, tree, int);
152 static tree tsubst_arg_types (tree, tree, tsubst_flags_t, tree);
153 static tree tsubst_function_type (tree, tree, tsubst_flags_t, tree);
154 static bool check_specialization_scope (void);
155 static tree process_partial_specialization (tree);
156 static void set_current_access_from_decl (tree);
157 static tree get_template_base (tree, tree, tree, tree);
158 static tree try_class_unification (tree, tree, tree, tree);
159 static int coerce_template_template_parms (tree, tree, tsubst_flags_t,
161 static bool template_template_parm_bindings_ok_p (tree, tree);
162 static int template_args_equal (tree, tree);
163 static void tsubst_default_arguments (tree);
164 static tree for_each_template_parm_r (tree *, int *, void *);
165 static tree copy_default_args_to_explicit_spec_1 (tree, tree);
166 static void copy_default_args_to_explicit_spec (tree);
167 static int invalid_nontype_parm_type_p (tree, tsubst_flags_t);
168 static int eq_local_specializations (const void *, const void *);
169 static bool dependent_template_arg_p (tree);
170 static bool any_template_arguments_need_structural_equality_p (tree);
171 static bool dependent_type_p_r (tree);
172 static tree tsubst (tree, tree, tsubst_flags_t, tree);
173 static tree tsubst_expr (tree, tree, tsubst_flags_t, tree, bool);
174 static tree tsubst_copy (tree, tree, tsubst_flags_t, tree);
175 static tree tsubst_pack_expansion (tree, tree, tsubst_flags_t, tree);
177 /* Make the current scope suitable for access checking when we are
178 processing T. T can be FUNCTION_DECL for instantiated function
179 template, or VAR_DECL for static member variable (need by
180 instantiate_decl). */
183 push_access_scope (tree t)
185 gcc_assert (TREE_CODE (t) == FUNCTION_DECL
186 || TREE_CODE (t) == VAR_DECL);
188 if (DECL_FRIEND_CONTEXT (t))
189 push_nested_class (DECL_FRIEND_CONTEXT (t));
190 else if (DECL_CLASS_SCOPE_P (t))
191 push_nested_class (DECL_CONTEXT (t));
193 push_to_top_level ();
195 if (TREE_CODE (t) == FUNCTION_DECL)
197 saved_access_scope = tree_cons
198 (NULL_TREE, current_function_decl, saved_access_scope);
199 current_function_decl = t;
203 /* Restore the scope set up by push_access_scope. T is the node we
207 pop_access_scope (tree t)
209 if (TREE_CODE (t) == FUNCTION_DECL)
211 current_function_decl = TREE_VALUE (saved_access_scope);
212 saved_access_scope = TREE_CHAIN (saved_access_scope);
215 if (DECL_FRIEND_CONTEXT (t) || DECL_CLASS_SCOPE_P (t))
218 pop_from_top_level ();
221 /* Do any processing required when DECL (a member template
222 declaration) is finished. Returns the TEMPLATE_DECL corresponding
223 to DECL, unless it is a specialization, in which case the DECL
224 itself is returned. */
227 finish_member_template_decl (tree decl)
229 if (decl == error_mark_node)
230 return error_mark_node;
232 gcc_assert (DECL_P (decl));
234 if (TREE_CODE (decl) == TYPE_DECL)
238 type = TREE_TYPE (decl);
239 if (type == error_mark_node)
240 return error_mark_node;
241 if (MAYBE_CLASS_TYPE_P (type)
242 && CLASSTYPE_TEMPLATE_INFO (type)
243 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
245 tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
246 check_member_template (tmpl);
251 else if (TREE_CODE (decl) == FIELD_DECL)
252 error ("data member %qD cannot be a member template", decl);
253 else if (DECL_TEMPLATE_INFO (decl))
255 if (!DECL_TEMPLATE_SPECIALIZATION (decl))
257 check_member_template (DECL_TI_TEMPLATE (decl));
258 return DECL_TI_TEMPLATE (decl);
264 error ("invalid member template declaration %qD", decl);
266 return error_mark_node;
269 /* Return the template info node corresponding to T, whatever T is. */
272 get_template_info (tree t)
274 tree tinfo = NULL_TREE;
276 if (DECL_P (t) && DECL_LANG_SPECIFIC (t))
277 tinfo = DECL_TEMPLATE_INFO (t);
279 if (!tinfo && TREE_CODE (t) == TYPE_DECL)
282 if (TAGGED_TYPE_P (t))
283 tinfo = TYPE_TEMPLATE_INFO (t);
288 /* Returns the template nesting level of the indicated class TYPE.
298 A<T>::B<U> has depth two, while A<T> has depth one.
299 Both A<T>::B<int> and A<int>::B<U> have depth one, if
300 they are instantiations, not specializations.
302 This function is guaranteed to return 0 if passed NULL_TREE so
303 that, for example, `template_class_depth (current_class_type)' is
307 template_class_depth (tree type)
312 type && TREE_CODE (type) != NAMESPACE_DECL;
313 type = (TREE_CODE (type) == FUNCTION_DECL)
314 ? CP_DECL_CONTEXT (type) : TYPE_CONTEXT (type))
316 tree tinfo = get_template_info (type);
318 if (tinfo && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo))
319 && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo))))
326 /* Subroutine of maybe_begin_member_template_processing.
327 Returns true if processing DECL needs us to push template parms. */
330 inline_needs_template_parms (tree decl)
332 if (! DECL_TEMPLATE_INFO (decl))
335 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl)))
336 > (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl)));
339 /* Subroutine of maybe_begin_member_template_processing.
340 Push the template parms in PARMS, starting from LEVELS steps into the
341 chain, and ending at the beginning, since template parms are listed
345 push_inline_template_parms_recursive (tree parmlist, int levels)
347 tree parms = TREE_VALUE (parmlist);
351 push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1);
353 ++processing_template_decl;
354 current_template_parms
355 = tree_cons (size_int (processing_template_decl),
356 parms, current_template_parms);
357 TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1;
359 begin_scope (TREE_VEC_LENGTH (parms) ? sk_template_parms : sk_template_spec,
361 for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
363 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
365 if (parm == error_mark_node)
368 gcc_assert (DECL_P (parm));
370 switch (TREE_CODE (parm))
379 /* Make a CONST_DECL as is done in process_template_parm.
380 It is ugly that we recreate this here; the original
381 version built in process_template_parm is no longer
383 tree decl = build_decl (CONST_DECL, DECL_NAME (parm),
385 DECL_ARTIFICIAL (decl) = 1;
386 TREE_CONSTANT (decl) = 1;
387 TREE_READONLY (decl) = 1;
388 DECL_INITIAL (decl) = DECL_INITIAL (parm);
389 SET_DECL_TEMPLATE_PARM_P (decl);
400 /* Restore the template parameter context for a member template or
401 a friend template defined in a class definition. */
404 maybe_begin_member_template_processing (tree decl)
409 if (inline_needs_template_parms (decl))
411 parms = DECL_TEMPLATE_PARMS (most_general_template (decl));
412 levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl;
414 if (DECL_TEMPLATE_SPECIALIZATION (decl))
417 parms = TREE_CHAIN (parms);
420 push_inline_template_parms_recursive (parms, levels);
423 /* Remember how many levels of template parameters we pushed so that
424 we can pop them later. */
425 VEC_safe_push (int, heap, inline_parm_levels, levels);
428 /* Undo the effects of maybe_begin_member_template_processing. */
431 maybe_end_member_template_processing (void)
436 if (VEC_length (int, inline_parm_levels) == 0)
439 last = VEC_pop (int, inline_parm_levels);
440 for (i = 0; i < last; ++i)
442 --processing_template_decl;
443 current_template_parms = TREE_CHAIN (current_template_parms);
448 /* Return a new template argument vector which contains all of ARGS,
449 but has as its innermost set of arguments the EXTRA_ARGS. */
452 add_to_template_args (tree args, tree extra_args)
459 extra_depth = TMPL_ARGS_DEPTH (extra_args);
460 new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth);
462 for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i)
463 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));
465 for (j = 1; j <= extra_depth; ++j, ++i)
466 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));
471 /* Like add_to_template_args, but only the outermost ARGS are added to
472 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
473 (EXTRA_ARGS) levels are added. This function is used to combine
474 the template arguments from a partial instantiation with the
475 template arguments used to attain the full instantiation from the
476 partial instantiation. */
479 add_outermost_template_args (tree args, tree extra_args)
483 /* If there are more levels of EXTRA_ARGS than there are ARGS,
484 something very fishy is going on. */
485 gcc_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args));
487 /* If *all* the new arguments will be the EXTRA_ARGS, just return
489 if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
492 /* For the moment, we make ARGS look like it contains fewer levels. */
493 TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);
495 new_args = add_to_template_args (args, extra_args);
497 /* Now, we restore ARGS to its full dimensions. */
498 TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);
503 /* Return the N levels of innermost template arguments from the ARGS. */
506 get_innermost_template_args (tree args, int n)
514 /* If N is 1, just return the innermost set of template arguments. */
516 return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args));
518 /* If we're not removing anything, just return the arguments we were
520 extra_levels = TMPL_ARGS_DEPTH (args) - n;
521 gcc_assert (extra_levels >= 0);
522 if (extra_levels == 0)
525 /* Make a new set of arguments, not containing the outer arguments. */
526 new_args = make_tree_vec (n);
527 for (i = 1; i <= n; ++i)
528 SET_TMPL_ARGS_LEVEL (new_args, i,
529 TMPL_ARGS_LEVEL (args, i + extra_levels));
534 /* The inverse of get_innermost_template_args: Return all but the innermost
535 EXTRA_LEVELS levels of template arguments from the ARGS. */
538 strip_innermost_template_args (tree args, int extra_levels)
541 int n = TMPL_ARGS_DEPTH (args) - extra_levels;
546 /* If N is 1, just return the outermost set of template arguments. */
548 return TMPL_ARGS_LEVEL (args, 1);
550 /* If we're not removing anything, just return the arguments we were
552 gcc_assert (extra_levels >= 0);
553 if (extra_levels == 0)
556 /* Make a new set of arguments, not containing the inner arguments. */
557 new_args = make_tree_vec (n);
558 for (i = 1; i <= n; ++i)
559 SET_TMPL_ARGS_LEVEL (new_args, i,
560 TMPL_ARGS_LEVEL (args, i));
565 /* We've got a template header coming up; push to a new level for storing
569 begin_template_parm_list (void)
571 /* We use a non-tag-transparent scope here, which causes pushtag to
572 put tags in this scope, rather than in the enclosing class or
573 namespace scope. This is the right thing, since we want
574 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
575 global template class, push_template_decl handles putting the
576 TEMPLATE_DECL into top-level scope. For a nested template class,
579 template <class T> struct S1 {
580 template <class T> struct S2 {};
583 pushtag contains special code to call pushdecl_with_scope on the
584 TEMPLATE_DECL for S2. */
585 begin_scope (sk_template_parms, NULL);
586 ++processing_template_decl;
587 ++processing_template_parmlist;
588 note_template_header (0);
591 /* This routine is called when a specialization is declared. If it is
592 invalid to declare a specialization here, an error is reported and
593 false is returned, otherwise this routine will return true. */
596 check_specialization_scope (void)
598 tree scope = current_scope ();
602 An explicit specialization shall be declared in the namespace of
603 which the template is a member, or, for member templates, in the
604 namespace of which the enclosing class or enclosing class
605 template is a member. An explicit specialization of a member
606 function, member class or static data member of a class template
607 shall be declared in the namespace of which the class template
609 if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
611 error ("explicit specialization in non-namespace scope %qD", scope);
617 In an explicit specialization declaration for a member of a class
618 template or a member template that appears in namespace scope,
619 the member template and some of its enclosing class templates may
620 remain unspecialized, except that the declaration shall not
621 explicitly specialize a class member template if its enclosing
622 class templates are not explicitly specialized as well. */
623 if (current_template_parms)
625 error ("enclosing class templates are not explicitly specialized");
632 /* We've just seen template <>. */
635 begin_specialization (void)
637 begin_scope (sk_template_spec, NULL);
638 note_template_header (1);
639 return check_specialization_scope ();
642 /* Called at then end of processing a declaration preceded by
646 end_specialization (void)
649 reset_specialization ();
652 /* Any template <>'s that we have seen thus far are not referring to a
653 function specialization. */
656 reset_specialization (void)
658 processing_specialization = 0;
659 template_header_count = 0;
662 /* We've just seen a template header. If SPECIALIZATION is nonzero,
663 it was of the form template <>. */
666 note_template_header (int specialization)
668 processing_specialization = specialization;
669 template_header_count++;
672 /* We're beginning an explicit instantiation. */
675 begin_explicit_instantiation (void)
677 gcc_assert (!processing_explicit_instantiation);
678 processing_explicit_instantiation = true;
683 end_explicit_instantiation (void)
685 gcc_assert (processing_explicit_instantiation);
686 processing_explicit_instantiation = false;
689 /* An explicit specialization or partial specialization TMPL is being
690 declared. Check that the namespace in which the specialization is
691 occurring is permissible. Returns false iff it is invalid to
692 specialize TMPL in the current namespace. */
695 check_specialization_namespace (tree tmpl)
697 tree tpl_ns = decl_namespace_context (tmpl);
701 An explicit specialization shall be declared in the namespace of
702 which the template is a member, or, for member templates, in the
703 namespace of which the enclosing class or enclosing class
704 template is a member. An explicit specialization of a member
705 function, member class or static data member of a class template
706 shall be declared in the namespace of which the class template is
708 if (is_associated_namespace (current_namespace, tpl_ns))
709 /* Same or super-using namespace. */
713 permerror ("specialization of %qD in different namespace", tmpl);
714 permerror (" from definition of %q+#D", tmpl);
719 /* SPEC is an explicit instantiation. Check that it is valid to
720 perform this explicit instantiation in the current namespace. */
723 check_explicit_instantiation_namespace (tree spec)
727 /* DR 275: An explicit instantiation shall appear in an enclosing
728 namespace of its template. */
729 ns = decl_namespace_context (spec);
730 if (!is_ancestor (current_namespace, ns))
731 permerror ("explicit instantiation of %qD in namespace %qD "
732 "(which does not enclose namespace %qD)",
733 spec, current_namespace, ns);
736 /* The TYPE is being declared. If it is a template type, that means it
737 is a partial specialization. Do appropriate error-checking. */
740 maybe_process_partial_specialization (tree type)
744 if (type == error_mark_node)
745 return error_mark_node;
747 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
749 error ("name of class shadows template template parameter %qD",
751 return error_mark_node;
754 context = TYPE_CONTEXT (type);
756 if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type))
758 /* This is for ordinary explicit specialization and partial
759 specialization of a template class such as:
761 template <> class C<int>;
765 template <class T> class C<T*>;
767 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
769 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
770 && !COMPLETE_TYPE_P (type))
772 check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type));
773 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
774 if (processing_template_decl)
776 if (push_template_decl (TYPE_MAIN_DECL (type))
778 return error_mark_node;
781 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
782 error ("specialization of %qT after instantiation", type);
784 else if (CLASS_TYPE_P (type)
785 && !CLASSTYPE_USE_TEMPLATE (type)
786 && CLASSTYPE_TEMPLATE_INFO (type)
787 && context && CLASS_TYPE_P (context)
788 && CLASSTYPE_TEMPLATE_INFO (context))
790 /* This is for an explicit specialization of member class
791 template according to [temp.expl.spec/18]:
793 template <> template <class U> class C<int>::D;
795 The context `C<int>' must be an implicit instantiation.
796 Otherwise this is just a member class template declared
799 template <> class C<int> { template <class U> class D; };
800 template <> template <class U> class C<int>::D;
802 In the first case, `C<int>::D' is a specialization of `C<T>::D'
803 while in the second case, `C<int>::D' is a primary template
804 and `C<T>::D' may not exist. */
806 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context)
807 && !COMPLETE_TYPE_P (type))
811 if (current_namespace
812 != decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type)))
814 permerror ("specializing %q#T in different namespace", type);
815 permerror (" from definition of %q+#D",
816 CLASSTYPE_TI_TEMPLATE (type));
819 /* Check for invalid specialization after instantiation:
821 template <> template <> class C<int>::D<int>;
822 template <> template <class U> class C<int>::D; */
824 for (t = DECL_TEMPLATE_INSTANTIATIONS
825 (most_general_template (CLASSTYPE_TI_TEMPLATE (type)));
826 t; t = TREE_CHAIN (t))
827 if (TREE_VALUE (t) != type
828 && TYPE_CONTEXT (TREE_VALUE (t)) == context)
829 error ("specialization %qT after instantiation %qT",
830 type, TREE_VALUE (t));
832 /* Mark TYPE as a specialization. And as a result, we only
833 have one level of template argument for the innermost
835 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
836 CLASSTYPE_TI_ARGS (type)
837 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
840 else if (processing_specialization)
842 error ("explicit specialization of non-template %qT", type);
843 return error_mark_node;
849 /* Returns nonzero if we can optimize the retrieval of specializations
850 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
851 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
854 optimize_specialization_lookup_p (tree tmpl)
856 return (DECL_FUNCTION_TEMPLATE_P (tmpl)
857 && DECL_CLASS_SCOPE_P (tmpl)
858 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
860 && CLASS_TYPE_P (DECL_CONTEXT (tmpl))
861 /* The optimized lookup depends on the fact that the
862 template arguments for the member function template apply
863 purely to the containing class, which is not true if the
864 containing class is an explicit or partial
866 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl))
867 && !DECL_MEMBER_TEMPLATE_P (tmpl)
868 && !DECL_CONV_FN_P (tmpl)
869 /* It is possible to have a template that is not a member
870 template and is not a member of a template class:
872 template <typename T>
873 struct S { friend A::f(); };
875 Here, the friend function is a template, but the context does
876 not have template information. The optimized lookup relies
877 on having ARGS be the template arguments for both the class
878 and the function template. */
879 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl)));
882 /* Retrieve the specialization (in the sense of [temp.spec] - a
883 specialization is either an instantiation or an explicit
884 specialization) of TMPL for the given template ARGS. If there is
885 no such specialization, return NULL_TREE. The ARGS are a vector of
886 arguments, or a vector of vectors of arguments, in the case of
887 templates with more than one level of parameters.
889 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
890 then we search for a partial specialization matching ARGS. This
891 parameter is ignored if TMPL is not a class template. */
894 retrieve_specialization (tree tmpl, tree args,
895 bool class_specializations_p)
897 if (args == error_mark_node)
900 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
902 /* There should be as many levels of arguments as there are
903 levels of parameters. */
904 gcc_assert (TMPL_ARGS_DEPTH (args)
905 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)));
907 if (optimize_specialization_lookup_p (tmpl))
910 tree class_specialization;
911 VEC(tree,gc) *methods;
915 /* The template arguments actually apply to the containing
916 class. Find the class specialization with those
918 class_template = CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl));
920 = retrieve_specialization (class_template, args,
921 /*class_specializations_p=*/false);
922 if (!class_specialization)
924 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
925 for the specialization. */
926 idx = class_method_index_for_fn (class_specialization, tmpl);
929 /* Iterate through the methods with the indicated name, looking
930 for the one that has an instance of TMPL. */
931 methods = CLASSTYPE_METHOD_VEC (class_specialization);
932 for (fns = VEC_index (tree, methods, idx); fns; fns = OVL_NEXT (fns))
934 tree fn = OVL_CURRENT (fns);
935 if (DECL_TEMPLATE_INFO (fn) && DECL_TI_TEMPLATE (fn) == tmpl)
945 /* Class templates store their instantiations on the
946 DECL_TEMPLATE_INSTANTIATIONS list; other templates use the
947 DECL_TEMPLATE_SPECIALIZATIONS list. */
948 if (!class_specializations_p
949 && TREE_CODE (DECL_TEMPLATE_RESULT (tmpl)) == TYPE_DECL
950 && TAGGED_TYPE_P (TREE_TYPE (tmpl)))
951 sp = &DECL_TEMPLATE_INSTANTIATIONS (tmpl);
953 sp = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
955 /* Iterate through the list until we find a matching template. */
956 while (*sp != NULL_TREE)
960 if (comp_template_args (TREE_PURPOSE (spec), args))
962 /* Use the move-to-front heuristic to speed up future
966 *sp = TREE_CHAIN (*sp);
967 TREE_CHAIN (spec) = *head;
970 return TREE_VALUE (spec);
972 sp = &TREE_CHAIN (spec);
979 /* Like retrieve_specialization, but for local declarations. */
982 retrieve_local_specialization (tree tmpl)
986 if (local_specializations == NULL)
989 spec = (tree) htab_find_with_hash (local_specializations, tmpl,
990 htab_hash_pointer (tmpl));
991 return spec ? TREE_PURPOSE (spec) : NULL_TREE;
994 /* Returns nonzero iff DECL is a specialization of TMPL. */
997 is_specialization_of (tree decl, tree tmpl)
1001 if (TREE_CODE (decl) == FUNCTION_DECL)
1005 t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
1011 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
1013 for (t = TREE_TYPE (decl);
1015 t = CLASSTYPE_USE_TEMPLATE (t)
1016 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
1017 if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl)))
1024 /* Returns nonzero iff DECL is a specialization of friend declaration
1025 FRIEND_DECL according to [temp.friend]. */
1028 is_specialization_of_friend (tree decl, tree friend_decl)
1030 bool need_template = true;
1033 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
1034 || TREE_CODE (decl) == TYPE_DECL);
1036 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1037 of a template class, we want to check if DECL is a specialization
1039 if (TREE_CODE (friend_decl) == FUNCTION_DECL
1040 && DECL_TEMPLATE_INFO (friend_decl)
1041 && !DECL_USE_TEMPLATE (friend_decl))
1043 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1044 friend_decl = DECL_TI_TEMPLATE (friend_decl);
1045 need_template = false;
1047 else if (TREE_CODE (friend_decl) == TEMPLATE_DECL
1048 && !PRIMARY_TEMPLATE_P (friend_decl))
1049 need_template = false;
1051 /* There is nothing to do if this is not a template friend. */
1052 if (TREE_CODE (friend_decl) != TEMPLATE_DECL)
1055 if (is_specialization_of (decl, friend_decl))
1059 A member of a class template may be declared to be a friend of a
1060 non-template class. In this case, the corresponding member of
1061 every specialization of the class template is a friend of the
1062 class granting friendship.
1064 For example, given a template friend declaration
1066 template <class T> friend void A<T>::f();
1068 the member function below is considered a friend
1070 template <> struct A<int> {
1074 For this type of template friend, TEMPLATE_DEPTH below will be
1075 nonzero. To determine if DECL is a friend of FRIEND, we first
1076 check if the enclosing class is a specialization of another. */
1078 template_depth = template_class_depth (DECL_CONTEXT (friend_decl));
1080 && DECL_CLASS_SCOPE_P (decl)
1081 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)),
1082 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl))))
1084 /* Next, we check the members themselves. In order to handle
1085 a few tricky cases, such as when FRIEND_DECL's are
1087 template <class T> friend void A<T>::g(T t);
1088 template <class T> template <T t> friend void A<T>::h();
1092 void A<int>::g(int);
1093 template <int> void A<int>::h();
1095 we need to figure out ARGS, the template arguments from
1096 the context of DECL. This is required for template substitution
1097 of `T' in the function parameter of `g' and template parameter
1098 of `h' in the above examples. Here ARGS corresponds to `int'. */
1100 tree context = DECL_CONTEXT (decl);
1101 tree args = NULL_TREE;
1102 int current_depth = 0;
1104 while (current_depth < template_depth)
1106 if (CLASSTYPE_TEMPLATE_INFO (context))
1108 if (current_depth == 0)
1109 args = TYPE_TI_ARGS (context);
1111 args = add_to_template_args (TYPE_TI_ARGS (context), args);
1114 context = TYPE_CONTEXT (context);
1117 if (TREE_CODE (decl) == FUNCTION_DECL)
1122 tree friend_args_type;
1123 tree decl_args_type;
1125 /* Make sure that both DECL and FRIEND_DECL are templates or
1127 is_template = DECL_TEMPLATE_INFO (decl)
1128 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl));
1129 if (need_template ^ is_template)
1131 else if (is_template)
1133 /* If both are templates, check template parameter list. */
1135 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl),
1137 if (!comp_template_parms
1138 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)),
1142 decl_type = TREE_TYPE (DECL_TI_TEMPLATE (decl));
1145 decl_type = TREE_TYPE (decl);
1147 friend_type = tsubst_function_type (TREE_TYPE (friend_decl), args,
1148 tf_none, NULL_TREE);
1149 if (friend_type == error_mark_node)
1152 /* Check if return types match. */
1153 if (!same_type_p (TREE_TYPE (decl_type), TREE_TYPE (friend_type)))
1156 /* Check if function parameter types match, ignoring the
1157 `this' parameter. */
1158 friend_args_type = TYPE_ARG_TYPES (friend_type);
1159 decl_args_type = TYPE_ARG_TYPES (decl_type);
1160 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl))
1161 friend_args_type = TREE_CHAIN (friend_args_type);
1162 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1163 decl_args_type = TREE_CHAIN (decl_args_type);
1165 return compparms (decl_args_type, friend_args_type);
1169 /* DECL is a TYPE_DECL */
1171 tree decl_type = TREE_TYPE (decl);
1173 /* Make sure that both DECL and FRIEND_DECL are templates or
1176 = CLASSTYPE_TEMPLATE_INFO (decl_type)
1177 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type));
1179 if (need_template ^ is_template)
1181 else if (is_template)
1184 /* If both are templates, check the name of the two
1185 TEMPLATE_DECL's first because is_friend didn't. */
1186 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type))
1187 != DECL_NAME (friend_decl))
1190 /* Now check template parameter list. */
1192 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl),
1194 return comp_template_parms
1195 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type)),
1199 return (DECL_NAME (decl)
1200 == DECL_NAME (friend_decl));
1206 /* Register the specialization SPEC as a specialization of TMPL with
1207 the indicated ARGS. IS_FRIEND indicates whether the specialization
1208 is actually just a friend declaration. Returns SPEC, or an
1209 equivalent prior declaration, if available. */
1212 register_specialization (tree spec, tree tmpl, tree args, bool is_friend)
1216 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
1218 if (TREE_CODE (spec) == FUNCTION_DECL
1219 && uses_template_parms (DECL_TI_ARGS (spec)))
1220 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1221 register it; we want the corresponding TEMPLATE_DECL instead.
1222 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1223 the more obvious `uses_template_parms (spec)' to avoid problems
1224 with default function arguments. In particular, given
1225 something like this:
1227 template <class T> void f(T t1, T t = T())
1229 the default argument expression is not substituted for in an
1230 instantiation unless and until it is actually needed. */
1233 fn = retrieve_specialization (tmpl, args,
1234 /*class_specializations_p=*/false);
1235 /* We can sometimes try to re-register a specialization that we've
1236 already got. In particular, regenerate_decl_from_template calls
1237 duplicate_decls which will update the specialization list. But,
1238 we'll still get called again here anyhow. It's more convenient
1239 to simply allow this than to try to prevent it. */
1242 else if (fn && DECL_TEMPLATE_SPECIALIZATION (spec))
1244 if (DECL_TEMPLATE_INSTANTIATION (fn))
1247 || DECL_EXPLICIT_INSTANTIATION (fn))
1249 error ("specialization of %qD after instantiation",
1251 return error_mark_node;
1256 /* This situation should occur only if the first
1257 specialization is an implicit instantiation, the
1258 second is an explicit specialization, and the
1259 implicit instantiation has not yet been used. That
1260 situation can occur if we have implicitly
1261 instantiated a member function and then specialized
1264 We can also wind up here if a friend declaration that
1265 looked like an instantiation turns out to be a
1268 template <class T> void foo(T);
1269 class S { friend void foo<>(int) };
1270 template <> void foo(int);
1272 We transform the existing DECL in place so that any
1273 pointers to it become pointers to the updated
1276 If there was a definition for the template, but not
1277 for the specialization, we want this to look as if
1278 there were no definition, and vice versa. */
1279 DECL_INITIAL (fn) = NULL_TREE;
1280 duplicate_decls (spec, fn, is_friend);
1281 /* The call to duplicate_decls will have applied
1284 An explicit specialization of a function template
1285 is inline only if it is explicitly declared to be,
1286 and independently of whether its function template
1289 to the primary function; now copy the inline bits to
1290 the various clones. */
1291 FOR_EACH_CLONE (clone, fn)
1292 DECL_DECLARED_INLINE_P (clone)
1293 = DECL_DECLARED_INLINE_P (fn);
1294 check_specialization_namespace (fn);
1299 else if (DECL_TEMPLATE_SPECIALIZATION (fn))
1301 if (!duplicate_decls (spec, fn, is_friend) && DECL_INITIAL (spec))
1302 /* Dup decl failed, but this is a new definition. Set the
1303 line number so any errors match this new
1305 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec);
1311 /* A specialization must be declared in the same namespace as the
1312 template it is specializing. */
1313 if (DECL_TEMPLATE_SPECIALIZATION (spec)
1314 && !check_specialization_namespace (tmpl))
1315 DECL_CONTEXT (spec) = FROB_CONTEXT (decl_namespace_context (tmpl));
1317 if (!optimize_specialization_lookup_p (tmpl))
1318 DECL_TEMPLATE_SPECIALIZATIONS (tmpl)
1319 = tree_cons (args, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl));
1324 /* Unregister the specialization SPEC as a specialization of TMPL.
1325 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1326 if the SPEC was listed as a specialization of TMPL. */
1329 reregister_specialization (tree spec, tree tmpl, tree new_spec)
1333 for (s = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
1335 s = &TREE_CHAIN (*s))
1336 if (TREE_VALUE (*s) == spec)
1339 *s = TREE_CHAIN (*s);
1341 TREE_VALUE (*s) = new_spec;
1348 /* Compare an entry in the local specializations hash table P1 (which
1349 is really a pointer to a TREE_LIST) with P2 (which is really a
1353 eq_local_specializations (const void *p1, const void *p2)
1355 return TREE_VALUE ((const_tree) p1) == (const_tree) p2;
1358 /* Hash P1, an entry in the local specializations table. */
1361 hash_local_specialization (const void* p1)
1363 return htab_hash_pointer (TREE_VALUE ((const_tree) p1));
1366 /* Like register_specialization, but for local declarations. We are
1367 registering SPEC, an instantiation of TMPL. */
1370 register_local_specialization (tree spec, tree tmpl)
1374 slot = htab_find_slot_with_hash (local_specializations, tmpl,
1375 htab_hash_pointer (tmpl), INSERT);
1376 *slot = build_tree_list (spec, tmpl);
1379 /* TYPE is a class type. Returns true if TYPE is an explicitly
1380 specialized class. */
1383 explicit_class_specialization_p (tree type)
1385 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
1387 return !uses_template_parms (CLASSTYPE_TI_ARGS (type));
1390 /* Print the list of candidate FNS in an error message. */
1393 print_candidates (tree fns)
1397 const char *str = "candidates are:";
1399 for (fn = fns; fn != NULL_TREE; fn = TREE_CHAIN (fn))
1403 for (f = TREE_VALUE (fn); f; f = OVL_NEXT (f))
1404 error ("%s %+#D", str, OVL_CURRENT (f));
1409 /* Returns the template (one of the functions given by TEMPLATE_ID)
1410 which can be specialized to match the indicated DECL with the
1411 explicit template args given in TEMPLATE_ID. The DECL may be
1412 NULL_TREE if none is available. In that case, the functions in
1413 TEMPLATE_ID are non-members.
1415 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1416 specialization of a member template.
1418 The TEMPLATE_COUNT is the number of references to qualifying
1419 template classes that appeared in the name of the function. See
1420 check_explicit_specialization for a more accurate description.
1422 TSK indicates what kind of template declaration (if any) is being
1423 declared. TSK_TEMPLATE indicates that the declaration given by
1424 DECL, though a FUNCTION_DECL, has template parameters, and is
1425 therefore a template function.
1427 The template args (those explicitly specified and those deduced)
1428 are output in a newly created vector *TARGS_OUT.
1430 If it is impossible to determine the result, an error message is
1431 issued. The error_mark_node is returned to indicate failure. */
1434 determine_specialization (tree template_id,
1437 int need_member_template,
1443 tree explicit_targs;
1444 tree candidates = NULL_TREE;
1445 /* A TREE_LIST of templates of which DECL may be a specialization.
1446 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1447 corresponding TREE_PURPOSE is the set of template arguments that,
1448 when used to instantiate the template, would produce a function
1449 with the signature of DECL. */
1450 tree templates = NULL_TREE;
1452 struct cp_binding_level *b;
1454 *targs_out = NULL_TREE;
1456 if (template_id == error_mark_node || decl == error_mark_node)
1457 return error_mark_node;
1459 fns = TREE_OPERAND (template_id, 0);
1460 explicit_targs = TREE_OPERAND (template_id, 1);
1462 if (fns == error_mark_node)
1463 return error_mark_node;
1465 /* Check for baselinks. */
1466 if (BASELINK_P (fns))
1467 fns = BASELINK_FUNCTIONS (fns);
1469 if (!is_overloaded_fn (fns))
1471 error ("%qD is not a function template", fns);
1472 return error_mark_node;
1475 /* Count the number of template headers specified for this
1478 for (b = current_binding_level;
1479 b->kind == sk_template_parms;
1483 for (; fns; fns = OVL_NEXT (fns))
1485 tree fn = OVL_CURRENT (fns);
1487 if (TREE_CODE (fn) == TEMPLATE_DECL)
1489 tree decl_arg_types;
1492 /* In case of explicit specialization, we need to check if
1493 the number of template headers appearing in the specialization
1494 is correct. This is usually done in check_explicit_specialization,
1495 but the check done there cannot be exhaustive when specializing
1496 member functions. Consider the following code:
1498 template <> void A<int>::f(int);
1499 template <> template <> void A<int>::f(int);
1501 Assuming that A<int> is not itself an explicit specialization
1502 already, the first line specializes "f" which is a non-template
1503 member function, whilst the second line specializes "f" which
1504 is a template member function. So both lines are syntactically
1505 correct, and check_explicit_specialization does not reject
1508 Here, we can do better, as we are matching the specialization
1509 against the declarations. We count the number of template
1510 headers, and we check if they match TEMPLATE_COUNT + 1
1511 (TEMPLATE_COUNT is the number of qualifying template classes,
1512 plus there must be another header for the member template
1515 Notice that if header_count is zero, this is not a
1516 specialization but rather a template instantiation, so there
1517 is no check we can perform here. */
1518 if (header_count && header_count != template_count + 1)
1521 /* Check that the number of template arguments at the
1522 innermost level for DECL is the same as for FN. */
1523 if (current_binding_level->kind == sk_template_parms
1524 && !current_binding_level->explicit_spec_p
1525 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn))
1526 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
1527 (current_template_parms))))
1530 /* DECL might be a specialization of FN. */
1531 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1532 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
1534 /* For a non-static member function, we need to make sure
1535 that the const qualification is the same. Since
1536 get_bindings does not try to merge the "this" parameter,
1537 we must do the comparison explicitly. */
1538 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1539 && !same_type_p (TREE_VALUE (fn_arg_types),
1540 TREE_VALUE (decl_arg_types)))
1543 /* Skip the "this" parameter and, for constructors of
1544 classes with virtual bases, the VTT parameter. A
1545 full specialization of a constructor will have a VTT
1546 parameter, but a template never will. */
1548 = skip_artificial_parms_for (decl, decl_arg_types);
1550 = skip_artificial_parms_for (fn, fn_arg_types);
1552 /* Check that the number of function parameters matches.
1554 template <class T> void f(int i = 0);
1555 template <> void f<int>();
1556 The specialization f<int> is invalid but is not caught
1557 by get_bindings below. */
1558 if (list_length (fn_arg_types) != list_length (decl_arg_types))
1561 /* Function templates cannot be specializations; there are
1562 no partial specializations of functions. Therefore, if
1563 the type of DECL does not match FN, there is no
1565 if (tsk == tsk_template)
1567 if (compparms (fn_arg_types, decl_arg_types))
1568 candidates = tree_cons (NULL_TREE, fn, candidates);
1572 /* See whether this function might be a specialization of this
1574 targs = get_bindings (fn, decl, explicit_targs, /*check_ret=*/true);
1577 /* We cannot deduce template arguments that when used to
1578 specialize TMPL will produce DECL. */
1581 /* Save this template, and the arguments deduced. */
1582 templates = tree_cons (targs, fn, templates);
1584 else if (need_member_template)
1585 /* FN is an ordinary member function, and we need a
1586 specialization of a member template. */
1588 else if (TREE_CODE (fn) != FUNCTION_DECL)
1589 /* We can get IDENTIFIER_NODEs here in certain erroneous
1592 else if (!DECL_FUNCTION_MEMBER_P (fn))
1593 /* This is just an ordinary non-member function. Nothing can
1594 be a specialization of that. */
1596 else if (DECL_ARTIFICIAL (fn))
1597 /* Cannot specialize functions that are created implicitly. */
1601 tree decl_arg_types;
1603 /* This is an ordinary member function. However, since
1604 we're here, we can assume it's enclosing class is a
1605 template class. For example,
1607 template <typename T> struct S { void f(); };
1608 template <> void S<int>::f() {}
1610 Here, S<int>::f is a non-template, but S<int> is a
1611 template class. If FN has the same type as DECL, we
1612 might be in business. */
1614 if (!DECL_TEMPLATE_INFO (fn))
1615 /* Its enclosing class is an explicit specialization
1616 of a template class. This is not a candidate. */
1619 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
1620 TREE_TYPE (TREE_TYPE (fn))))
1621 /* The return types differ. */
1624 /* Adjust the type of DECL in case FN is a static member. */
1625 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1626 if (DECL_STATIC_FUNCTION_P (fn)
1627 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1628 decl_arg_types = TREE_CHAIN (decl_arg_types);
1630 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1633 candidates = tree_cons (NULL_TREE, fn, candidates);
1637 if (templates && TREE_CHAIN (templates))
1643 It is possible for a specialization with a given function
1644 signature to be instantiated from more than one function
1645 template. In such cases, explicit specification of the
1646 template arguments must be used to uniquely identify the
1647 function template specialization being specialized.
1649 Note that here, there's no suggestion that we're supposed to
1650 determine which of the candidate templates is most
1651 specialized. However, we, also have:
1655 Partial ordering of overloaded function template
1656 declarations is used in the following contexts to select
1657 the function template to which a function template
1658 specialization refers:
1660 -- when an explicit specialization refers to a function
1663 So, we do use the partial ordering rules, at least for now.
1664 This extension can only serve to make invalid programs valid,
1665 so it's safe. And, there is strong anecdotal evidence that
1666 the committee intended the partial ordering rules to apply;
1667 the EDG front end has that behavior, and John Spicer claims
1668 that the committee simply forgot to delete the wording in
1669 [temp.expl.spec]. */
1670 tree tmpl = most_specialized_instantiation (templates);
1671 if (tmpl != error_mark_node)
1674 TREE_CHAIN (templates) = NULL_TREE;
1678 if (templates == NULL_TREE && candidates == NULL_TREE)
1680 error ("template-id %qD for %q+D does not match any template "
1681 "declaration", template_id, decl);
1682 return error_mark_node;
1684 else if ((templates && TREE_CHAIN (templates))
1685 || (candidates && TREE_CHAIN (candidates))
1686 || (templates && candidates))
1688 error ("ambiguous template specialization %qD for %q+D",
1690 chainon (candidates, templates);
1691 print_candidates (candidates);
1692 return error_mark_node;
1695 /* We have one, and exactly one, match. */
1698 tree fn = TREE_VALUE (candidates);
1699 /* DECL is a re-declaration of a template function. */
1700 if (TREE_CODE (fn) == TEMPLATE_DECL)
1702 /* It was a specialization of an ordinary member function in a
1704 *targs_out = copy_node (DECL_TI_ARGS (fn));
1705 return DECL_TI_TEMPLATE (fn);
1708 /* It was a specialization of a template. */
1709 targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates)));
1710 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs))
1712 *targs_out = copy_node (targs);
1713 SET_TMPL_ARGS_LEVEL (*targs_out,
1714 TMPL_ARGS_DEPTH (*targs_out),
1715 TREE_PURPOSE (templates));
1718 *targs_out = TREE_PURPOSE (templates);
1719 return TREE_VALUE (templates);
1722 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
1723 but with the default argument values filled in from those in the
1727 copy_default_args_to_explicit_spec_1 (tree spec_types,
1730 tree new_spec_types;
1735 if (spec_types == void_list_node)
1736 return void_list_node;
1738 /* Substitute into the rest of the list. */
1740 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
1741 TREE_CHAIN (tmpl_types));
1743 /* Add the default argument for this parameter. */
1744 return hash_tree_cons (TREE_PURPOSE (tmpl_types),
1745 TREE_VALUE (spec_types),
1749 /* DECL is an explicit specialization. Replicate default arguments
1750 from the template it specializes. (That way, code like:
1752 template <class T> void f(T = 3);
1753 template <> void f(double);
1756 works, as required.) An alternative approach would be to look up
1757 the correct default arguments at the call-site, but this approach
1758 is consistent with how implicit instantiations are handled. */
1761 copy_default_args_to_explicit_spec (tree decl)
1766 tree new_spec_types;
1770 tree object_type = NULL_TREE;
1771 tree in_charge = NULL_TREE;
1772 tree vtt = NULL_TREE;
1774 /* See if there's anything we need to do. */
1775 tmpl = DECL_TI_TEMPLATE (decl);
1776 tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
1777 for (t = tmpl_types; t; t = TREE_CHAIN (t))
1778 if (TREE_PURPOSE (t))
1783 old_type = TREE_TYPE (decl);
1784 spec_types = TYPE_ARG_TYPES (old_type);
1786 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1788 /* Remove the this pointer, but remember the object's type for
1790 object_type = TREE_TYPE (TREE_VALUE (spec_types));
1791 spec_types = TREE_CHAIN (spec_types);
1792 tmpl_types = TREE_CHAIN (tmpl_types);
1794 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
1796 /* DECL may contain more parameters than TMPL due to the extra
1797 in-charge parameter in constructors and destructors. */
1798 in_charge = spec_types;
1799 spec_types = TREE_CHAIN (spec_types);
1801 if (DECL_HAS_VTT_PARM_P (decl))
1804 spec_types = TREE_CHAIN (spec_types);
1808 /* Compute the merged default arguments. */
1810 copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);
1812 /* Compute the new FUNCTION_TYPE. */
1816 new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt),
1821 /* Put the in-charge parameter back. */
1822 new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
1823 TREE_VALUE (in_charge),
1826 new_type = build_method_type_directly (object_type,
1827 TREE_TYPE (old_type),
1831 new_type = build_function_type (TREE_TYPE (old_type),
1833 new_type = cp_build_type_attribute_variant (new_type,
1834 TYPE_ATTRIBUTES (old_type));
1835 new_type = build_exception_variant (new_type,
1836 TYPE_RAISES_EXCEPTIONS (old_type));
1837 TREE_TYPE (decl) = new_type;
1840 /* Check to see if the function just declared, as indicated in
1841 DECLARATOR, and in DECL, is a specialization of a function
1842 template. We may also discover that the declaration is an explicit
1843 instantiation at this point.
1845 Returns DECL, or an equivalent declaration that should be used
1846 instead if all goes well. Issues an error message if something is
1847 amiss. Returns error_mark_node if the error is not easily
1850 FLAGS is a bitmask consisting of the following flags:
1852 2: The function has a definition.
1853 4: The function is a friend.
1855 The TEMPLATE_COUNT is the number of references to qualifying
1856 template classes that appeared in the name of the function. For
1859 template <class T> struct S { void f(); };
1862 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1863 classes are not counted in the TEMPLATE_COUNT, so that in
1865 template <class T> struct S {};
1866 template <> struct S<int> { void f(); }
1867 template <> void S<int>::f();
1869 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1870 invalid; there should be no template <>.)
1872 If the function is a specialization, it is marked as such via
1873 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1874 is set up correctly, and it is added to the list of specializations
1875 for that template. */
1878 check_explicit_specialization (tree declarator,
1883 int have_def = flags & 2;
1884 int is_friend = flags & 4;
1885 int specialization = 0;
1886 int explicit_instantiation = 0;
1887 int member_specialization = 0;
1888 tree ctype = DECL_CLASS_CONTEXT (decl);
1889 tree dname = DECL_NAME (decl);
1894 if (!processing_specialization)
1897 tsk = tsk_excessive_parms;
1900 tsk = current_tmpl_spec_kind (template_count);
1905 if (processing_specialization)
1908 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1910 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1913 /* This could be something like:
1915 template <class T> void f(T);
1916 class S { friend void f<>(int); } */
1920 /* This case handles bogus declarations like template <>
1921 template <class T> void f<int>(); */
1923 error ("template-id %qD in declaration of primary template",
1930 case tsk_invalid_member_spec:
1931 /* The error has already been reported in
1932 check_specialization_scope. */
1933 return error_mark_node;
1935 case tsk_invalid_expl_inst:
1936 error ("template parameter list used in explicit instantiation");
1942 error ("definition provided for explicit instantiation");
1944 explicit_instantiation = 1;
1947 case tsk_excessive_parms:
1948 case tsk_insufficient_parms:
1949 if (tsk == tsk_excessive_parms)
1950 error ("too many template parameter lists in declaration of %qD",
1952 else if (template_header_count)
1953 error("too few template parameter lists in declaration of %qD", decl);
1955 error("explicit specialization of %qD must be introduced by "
1956 "%<template <>%>", decl);
1960 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1962 member_specialization = 1;
1968 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1970 /* This case handles bogus declarations like template <>
1971 template <class T> void f<int>(); */
1973 if (uses_template_parms (declarator))
1974 error ("function template partial specialization %qD "
1975 "is not allowed", declarator);
1977 error ("template-id %qD in declaration of primary template",
1982 if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
1983 /* This is a specialization of a member template, without
1984 specialization the containing class. Something like:
1986 template <class T> struct S {
1987 template <class U> void f (U);
1989 template <> template <class U> void S<int>::f(U) {}
1991 That's a specialization -- but of the entire template. */
1999 if (specialization || member_specialization)
2001 tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
2002 for (; t; t = TREE_CHAIN (t))
2003 if (TREE_PURPOSE (t))
2006 ("default argument specified in explicit specialization");
2011 if (specialization || member_specialization || explicit_instantiation)
2013 tree tmpl = NULL_TREE;
2014 tree targs = NULL_TREE;
2016 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2017 if (TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
2021 gcc_assert (TREE_CODE (declarator) == IDENTIFIER_NODE);
2026 /* If there is no class context, the explicit instantiation
2027 must be at namespace scope. */
2028 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl));
2030 /* Find the namespace binding, using the declaration
2032 fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
2034 if (fns == error_mark_node || !is_overloaded_fn (fns))
2036 error ("%qD is not a template function", dname);
2037 fns = error_mark_node;
2041 tree fn = OVL_CURRENT (fns);
2042 if (!is_associated_namespace (CP_DECL_CONTEXT (decl),
2043 CP_DECL_CONTEXT (fn)))
2044 error ("%qD is not declared in %qD",
2045 decl, current_namespace);
2049 declarator = lookup_template_function (fns, NULL_TREE);
2052 if (declarator == error_mark_node)
2053 return error_mark_node;
2055 if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
2057 if (!explicit_instantiation)
2058 /* A specialization in class scope. This is invalid,
2059 but the error will already have been flagged by
2060 check_specialization_scope. */
2061 return error_mark_node;
2064 /* It's not valid to write an explicit instantiation in
2067 class C { template void f(); }
2069 This case is caught by the parser. However, on
2072 template class C { void f(); };
2074 (which is invalid) we can get here. The error will be
2081 else if (ctype != NULL_TREE
2082 && (TREE_CODE (TREE_OPERAND (declarator, 0)) ==
2085 /* Find the list of functions in ctype that have the same
2086 name as the declared function. */
2087 tree name = TREE_OPERAND (declarator, 0);
2088 tree fns = NULL_TREE;
2091 if (constructor_name_p (name, ctype))
2093 int is_constructor = DECL_CONSTRUCTOR_P (decl);
2095 if (is_constructor ? !TYPE_HAS_USER_CONSTRUCTOR (ctype)
2096 : !CLASSTYPE_DESTRUCTORS (ctype))
2098 /* From [temp.expl.spec]:
2100 If such an explicit specialization for the member
2101 of a class template names an implicitly-declared
2102 special member function (clause _special_), the
2103 program is ill-formed.
2105 Similar language is found in [temp.explicit]. */
2106 error ("specialization of implicitly-declared special member function");
2107 return error_mark_node;
2110 name = is_constructor ? ctor_identifier : dtor_identifier;
2113 if (!DECL_CONV_FN_P (decl))
2115 idx = lookup_fnfields_1 (ctype, name);
2117 fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (ctype), idx);
2121 VEC(tree,gc) *methods;
2124 /* For a type-conversion operator, we cannot do a
2125 name-based lookup. We might be looking for `operator
2126 int' which will be a specialization of `operator T'.
2127 So, we find *all* the conversion operators, and then
2128 select from them. */
2131 methods = CLASSTYPE_METHOD_VEC (ctype);
2133 for (idx = CLASSTYPE_FIRST_CONVERSION_SLOT;
2134 VEC_iterate (tree, methods, idx, ovl);
2137 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl)))
2138 /* There are no more conversion functions. */
2141 /* Glue all these conversion functions together
2142 with those we already have. */
2143 for (; ovl; ovl = OVL_NEXT (ovl))
2144 fns = ovl_cons (OVL_CURRENT (ovl), fns);
2148 if (fns == NULL_TREE)
2150 error ("no member function %qD declared in %qT", name, ctype);
2151 return error_mark_node;
2154 TREE_OPERAND (declarator, 0) = fns;
2157 /* Figure out what exactly is being specialized at this point.
2158 Note that for an explicit instantiation, even one for a
2159 member function, we cannot tell apriori whether the
2160 instantiation is for a member template, or just a member
2161 function of a template class. Even if a member template is
2162 being instantiated, the member template arguments may be
2163 elided if they can be deduced from the rest of the
2165 tmpl = determine_specialization (declarator, decl,
2167 member_specialization,
2171 if (!tmpl || tmpl == error_mark_node)
2172 /* We couldn't figure out what this declaration was
2174 return error_mark_node;
2177 tree gen_tmpl = most_general_template (tmpl);
2179 if (explicit_instantiation)
2181 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2182 is done by do_decl_instantiation later. */
2184 int arg_depth = TMPL_ARGS_DEPTH (targs);
2185 int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
2187 if (arg_depth > parm_depth)
2189 /* If TMPL is not the most general template (for
2190 example, if TMPL is a friend template that is
2191 injected into namespace scope), then there will
2192 be too many levels of TARGS. Remove some of them
2197 new_targs = make_tree_vec (parm_depth);
2198 for (i = arg_depth - parm_depth; i < arg_depth; ++i)
2199 TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
2200 = TREE_VEC_ELT (targs, i);
2204 return instantiate_template (tmpl, targs, tf_error);
2207 /* If we thought that the DECL was a member function, but it
2208 turns out to be specializing a static member function,
2209 make DECL a static member function as well. */
2210 if (DECL_STATIC_FUNCTION_P (tmpl)
2211 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2212 revert_static_member_fn (decl);
2214 /* If this is a specialization of a member template of a
2215 template class, we want to return the TEMPLATE_DECL, not
2216 the specialization of it. */
2217 if (tsk == tsk_template)
2219 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
2220 DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl)) = NULL_TREE;
2223 DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
2224 DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (tmpl))
2225 = DECL_SOURCE_LOCATION (decl);
2226 /* We want to use the argument list specified in the
2227 definition, not in the original declaration. */
2228 DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (tmpl))
2229 = DECL_ARGUMENTS (decl);
2234 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2235 DECL_TEMPLATE_INFO (decl) = tree_cons (tmpl, targs, NULL_TREE);
2237 /* Inherit default function arguments from the template
2238 DECL is specializing. */
2239 copy_default_args_to_explicit_spec (decl);
2241 /* This specialization has the same protection as the
2242 template it specializes. */
2243 TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
2244 TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
2246 /* 7.1.1-1 [dcl.stc]
2248 A storage-class-specifier shall not be specified in an
2249 explicit specialization...
2251 The parser rejects these, so unless action is taken here,
2252 explicit function specializations will always appear with
2255 The action recommended by the C++ CWG in response to C++
2256 defect report 605 is to make the storage class and linkage
2257 of the explicit specialization match the templated function:
2259 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2261 if (tsk == tsk_expl_spec && DECL_FUNCTION_TEMPLATE_P (gen_tmpl))
2263 tree tmpl_func = DECL_TEMPLATE_RESULT (gen_tmpl);
2264 gcc_assert (TREE_CODE (tmpl_func) == FUNCTION_DECL);
2266 /* This specialization has the same linkage and visibility as
2267 the function template it specializes. */
2268 TREE_PUBLIC (decl) = TREE_PUBLIC (tmpl_func);
2269 if (! TREE_PUBLIC (decl))
2271 DECL_INTERFACE_KNOWN (decl) = 1;
2272 DECL_NOT_REALLY_EXTERN (decl) = 1;
2274 DECL_THIS_STATIC (decl) = DECL_THIS_STATIC (tmpl_func);
2275 if (DECL_VISIBILITY_SPECIFIED (tmpl_func))
2277 DECL_VISIBILITY_SPECIFIED (decl) = 1;
2278 DECL_VISIBILITY (decl) = DECL_VISIBILITY (tmpl_func);
2282 /* If DECL is a friend declaration, declared using an
2283 unqualified name, the namespace associated with DECL may
2284 have been set incorrectly. For example, in:
2286 template <typename T> void f(T);
2288 struct S { friend void f<int>(int); }
2291 we will have set the DECL_CONTEXT for the friend
2292 declaration to N, rather than to the global namespace. */
2293 if (DECL_NAMESPACE_SCOPE_P (decl))
2294 DECL_CONTEXT (decl) = DECL_CONTEXT (tmpl);
2296 if (is_friend && !have_def)
2297 /* This is not really a declaration of a specialization.
2298 It's just the name of an instantiation. But, it's not
2299 a request for an instantiation, either. */
2300 SET_DECL_IMPLICIT_INSTANTIATION (decl);
2301 else if (DECL_CONSTRUCTOR_P (decl) || DECL_DESTRUCTOR_P (decl))
2302 /* This is indeed a specialization. In case of constructors
2303 and destructors, we need in-charge and not-in-charge
2304 versions in V3 ABI. */
2305 clone_function_decl (decl, /*update_method_vec_p=*/0);
2307 /* Register this specialization so that we can find it
2309 decl = register_specialization (decl, gen_tmpl, targs, is_friend);
2316 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2317 parameters. These are represented in the same format used for
2318 DECL_TEMPLATE_PARMS. */
2321 comp_template_parms (const_tree parms1, const_tree parms2)
2326 if (parms1 == parms2)
2329 for (p1 = parms1, p2 = parms2;
2330 p1 != NULL_TREE && p2 != NULL_TREE;
2331 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2))
2333 tree t1 = TREE_VALUE (p1);
2334 tree t2 = TREE_VALUE (p2);
2337 gcc_assert (TREE_CODE (t1) == TREE_VEC);
2338 gcc_assert (TREE_CODE (t2) == TREE_VEC);
2340 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
2343 for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
2345 tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
2346 tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
2348 /* If either of the template parameters are invalid, assume
2349 they match for the sake of error recovery. */
2350 if (parm1 == error_mark_node || parm2 == error_mark_node)
2353 if (TREE_CODE (parm1) != TREE_CODE (parm2))
2356 if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM
2357 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1)
2358 == TEMPLATE_TYPE_PARAMETER_PACK (parm2)))
2360 else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
2365 if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
2366 /* One set of parameters has more parameters lists than the
2373 /* Determine whether PARM is a parameter pack. */
2375 template_parameter_pack_p (const_tree parm)
2377 /* Determine if we have a non-type template parameter pack. */
2378 if (TREE_CODE (parm) == PARM_DECL)
2379 return (DECL_TEMPLATE_PARM_P (parm)
2380 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)));
2382 /* If this is a list of template parameters, we could get a
2383 TYPE_DECL or a TEMPLATE_DECL. */
2384 if (TREE_CODE (parm) == TYPE_DECL || TREE_CODE (parm) == TEMPLATE_DECL)
2385 parm = TREE_TYPE (parm);
2387 return ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
2388 || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM)
2389 && TEMPLATE_TYPE_PARAMETER_PACK (parm));
2392 /* Determine whether ARGS describes a variadic template args list,
2393 i.e., one that is terminated by a template argument pack. */
2395 template_args_variadic_p (tree args)
2400 if (args == NULL_TREE)
2403 args = INNERMOST_TEMPLATE_ARGS (args);
2404 nargs = TREE_VEC_LENGTH (args);
2409 last_parm = TREE_VEC_ELT (args, nargs - 1);
2411 return ARGUMENT_PACK_P (last_parm);
2414 /* Generate a new name for the parameter pack name NAME (an
2415 IDENTIFIER_NODE) that incorporates its */
2417 make_ith_pack_parameter_name (tree name, int i)
2419 /* Munge the name to include the parameter index. */
2423 sprintf(numbuf, "%i", i);
2424 newname = (char*)alloca (IDENTIFIER_LENGTH (name) + strlen(numbuf) + 2);
2425 sprintf(newname, "%s#%i", IDENTIFIER_POINTER (name), i);
2426 return get_identifier (newname);
2429 /* Structure used to track the progress of find_parameter_packs_r. */
2430 struct find_parameter_pack_data
2432 /* TREE_LIST that will contain all of the parameter packs found by
2434 tree* parameter_packs;
2436 /* Set of AST nodes that have been visited by the traversal. */
2437 struct pointer_set_t *visited;
2440 /* Identifies all of the argument packs that occur in a template
2441 argument and appends them to the TREE_LIST inside DATA, which is a
2442 find_parameter_pack_data structure. This is a subroutine of
2443 make_pack_expansion and uses_parameter_packs. */
2445 find_parameter_packs_r (tree *tp, int *walk_subtrees, void* data)
2448 struct find_parameter_pack_data* ppd =
2449 (struct find_parameter_pack_data*)data;
2450 bool parameter_pack_p = false;
2452 /* Identify whether this is a parameter pack or not. */
2453 switch (TREE_CODE (t))
2455 case TEMPLATE_PARM_INDEX:
2456 if (TEMPLATE_PARM_PARAMETER_PACK (t))
2457 parameter_pack_p = true;
2460 case TEMPLATE_TYPE_PARM:
2461 case TEMPLATE_TEMPLATE_PARM:
2462 if (TEMPLATE_TYPE_PARAMETER_PACK (t))
2463 parameter_pack_p = true;
2467 if (FUNCTION_PARAMETER_PACK_P (t))
2469 /* We don't want to walk into the type of a PARM_DECL,
2470 because we don't want to see the type parameter pack. */
2472 parameter_pack_p = true;
2477 /* Not a parameter pack. */
2481 if (parameter_pack_p)
2483 /* Add this parameter pack to the list. */
2484 *ppd->parameter_packs = tree_cons (NULL_TREE, t, *ppd->parameter_packs);
2488 cp_walk_tree (&TYPE_CONTEXT (t),
2489 &find_parameter_packs_r, ppd, ppd->visited);
2491 /* This switch statement will return immediately if we don't find a
2493 switch (TREE_CODE (t))
2495 case TEMPLATE_PARM_INDEX:
2498 case BOUND_TEMPLATE_TEMPLATE_PARM:
2499 /* Check the template itself. */
2500 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t)),
2501 &find_parameter_packs_r, ppd, ppd->visited);
2502 /* Check the template arguments. */
2503 cp_walk_tree (&TYPE_TI_ARGS (t), &find_parameter_packs_r, ppd,
2508 case TEMPLATE_TYPE_PARM:
2509 case TEMPLATE_TEMPLATE_PARM:
2516 if (TYPE_PTRMEMFUNC_P (t))
2522 if (TYPE_TEMPLATE_INFO (t))
2523 cp_walk_tree (&TREE_VALUE (TYPE_TEMPLATE_INFO (t)),
2524 &find_parameter_packs_r, ppd, ppd->visited);
2530 cp_walk_tree (&TREE_TYPE (t),
2531 &find_parameter_packs_r, ppd, ppd->visited);
2535 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t), &find_parameter_packs_r,
2540 case TYPE_PACK_EXPANSION:
2541 case EXPR_PACK_EXPANSION:
2546 cp_walk_tree (&TYPE_MAX_VALUE (t), &find_parameter_packs_r,
2551 case IDENTIFIER_NODE:
2552 cp_walk_tree (&TREE_TYPE (t), &find_parameter_packs_r, ppd,
2564 /* Determines if the expression or type T uses any parameter packs. */
2566 uses_parameter_packs (tree t)
2568 tree parameter_packs = NULL_TREE;
2569 struct find_parameter_pack_data ppd;
2570 ppd.parameter_packs = ¶meter_packs;
2571 ppd.visited = pointer_set_create ();
2572 cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
2573 pointer_set_destroy (ppd.visited);
2574 return parameter_packs != NULL_TREE;
2577 /* Turn ARG, which may be an expression, type, or a TREE_LIST
2578 representation a base-class initializer into a parameter pack
2579 expansion. If all goes well, the resulting node will be an
2580 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
2583 make_pack_expansion (tree arg)
2586 tree parameter_packs = NULL_TREE;
2587 bool for_types = false;
2588 struct find_parameter_pack_data ppd;
2590 if (!arg || arg == error_mark_node)
2593 if (TREE_CODE (arg) == TREE_LIST)
2595 /* The only time we will see a TREE_LIST here is for a base
2596 class initializer. In this case, the TREE_PURPOSE will be a
2597 _TYPE node (representing the base class expansion we're
2598 initializing) and the TREE_VALUE will be a TREE_LIST
2599 containing the initialization arguments.
2601 The resulting expansion looks somewhat different from most
2602 expansions. Rather than returning just one _EXPANSION, we
2603 return a TREE_LIST whose TREE_PURPOSE is a
2604 TYPE_PACK_EXPANSION containing the bases that will be
2605 initialized. The TREE_VALUE will be identical to the
2606 original TREE_VALUE, which is a list of arguments that will
2607 be passed to each base. We do not introduce any new pack
2608 expansion nodes into the TREE_VALUE (although it is possible
2609 that some already exist), because the TREE_PURPOSE and
2610 TREE_VALUE all need to be expanded together with the same
2611 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
2612 resulting TREE_PURPOSE will mention the parameter packs in
2613 both the bases and the arguments to the bases. */
2616 tree parameter_packs = NULL_TREE;
2618 /* Determine which parameter packs will be used by the base
2620 ppd.visited = pointer_set_create ();
2621 ppd.parameter_packs = ¶meter_packs;
2622 cp_walk_tree (&TREE_PURPOSE (arg), &find_parameter_packs_r,
2625 if (parameter_packs == NULL_TREE)
2627 error ("base initializer expansion %<%T%> contains no parameter packs", arg);
2628 pointer_set_destroy (ppd.visited);
2629 return error_mark_node;
2632 if (TREE_VALUE (arg) != void_type_node)
2634 /* Collect the sets of parameter packs used in each of the
2635 initialization arguments. */
2636 for (value = TREE_VALUE (arg); value; value = TREE_CHAIN (value))
2638 /* Determine which parameter packs will be expanded in this
2640 cp_walk_tree (&TREE_VALUE (value), &find_parameter_packs_r,
2645 pointer_set_destroy (ppd.visited);
2647 /* Create the pack expansion type for the base type. */
2648 purpose = make_node (TYPE_PACK_EXPANSION);
2649 SET_PACK_EXPANSION_PATTERN (purpose, TREE_PURPOSE (arg));
2650 PACK_EXPANSION_PARAMETER_PACKS (purpose) = parameter_packs;
2652 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
2653 they will rarely be compared to anything. */
2654 SET_TYPE_STRUCTURAL_EQUALITY (purpose);
2656 return tree_cons (purpose, TREE_VALUE (arg), NULL_TREE);
2659 if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
2662 /* Build the PACK_EXPANSION_* node. */
2663 result = make_node (for_types ? TYPE_PACK_EXPANSION : EXPR_PACK_EXPANSION);
2664 SET_PACK_EXPANSION_PATTERN (result, arg);
2665 if (TREE_CODE (result) == EXPR_PACK_EXPANSION)
2667 /* Propagate type and const-expression information. */
2668 TREE_TYPE (result) = TREE_TYPE (arg);
2669 TREE_CONSTANT (result) = TREE_CONSTANT (arg);
2672 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
2673 they will rarely be compared to anything. */
2674 SET_TYPE_STRUCTURAL_EQUALITY (result);
2676 /* Determine which parameter packs will be expanded. */
2677 ppd.parameter_packs = ¶meter_packs;
2678 ppd.visited = pointer_set_create ();
2679 cp_walk_tree (&arg, &find_parameter_packs_r, &ppd, ppd.visited);
2680 pointer_set_destroy (ppd.visited);
2682 /* Make sure we found some parameter packs. */
2683 if (parameter_packs == NULL_TREE)
2686 error ("expansion pattern %<%T%> contains no argument packs", arg);
2688 error ("expansion pattern %<%E%> contains no argument packs", arg);
2689 return error_mark_node;
2691 PACK_EXPANSION_PARAMETER_PACKS (result) = parameter_packs;
2696 /* Checks T for any "bare" parameter packs, which have not yet been
2697 expanded, and issues an error if any are found. This operation can
2698 only be done on full expressions or types (e.g., an expression
2699 statement, "if" condition, etc.), because we could have expressions like:
2701 foo(f(g(h(args)))...)
2703 where "args" is a parameter pack. check_for_bare_parameter_packs
2704 should not be called for the subexpressions args, h(args),
2705 g(h(args)), or f(g(h(args))), because we would produce erroneous
2708 Returns TRUE and emits an error if there were bare parameter packs,
2709 returns FALSE otherwise. */
2711 check_for_bare_parameter_packs (tree t)
2713 tree parameter_packs = NULL_TREE;
2714 struct find_parameter_pack_data ppd;
2716 if (!processing_template_decl || !t || t == error_mark_node)
2719 if (TREE_CODE (t) == TYPE_DECL)
2722 ppd.parameter_packs = ¶meter_packs;
2723 ppd.visited = pointer_set_create ();
2724 cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
2725 pointer_set_destroy (ppd.visited);
2727 if (parameter_packs)
2729 error ("parameter packs not expanded with %<...%>:");
2730 while (parameter_packs)
2732 tree pack = TREE_VALUE (parameter_packs);
2733 tree name = NULL_TREE;
2735 if (TREE_CODE (pack) == TEMPLATE_TYPE_PARM
2736 || TREE_CODE (pack) == TEMPLATE_TEMPLATE_PARM)
2737 name = TYPE_NAME (pack);
2738 else if (TREE_CODE (pack) == TEMPLATE_PARM_INDEX)
2739 name = DECL_NAME (TEMPLATE_PARM_DECL (pack));
2741 name = DECL_NAME (pack);
2744 inform (" %qD", name);
2746 inform (" <anonymous>");
2748 parameter_packs = TREE_CHAIN (parameter_packs);
2757 /* Expand any parameter packs that occur in the template arguments in
2760 expand_template_argument_pack (tree args)
2762 tree result_args = NULL_TREE;
2763 int in_arg, out_arg = 0, nargs = args ? TREE_VEC_LENGTH (args) : 0;
2764 int num_result_args = -1;
2766 /* First, determine if we need to expand anything, and the number of
2767 slots we'll need. */
2768 for (in_arg = 0; in_arg < nargs; ++in_arg)
2770 tree arg = TREE_VEC_ELT (args, in_arg);
2771 if (ARGUMENT_PACK_P (arg))
2773 int num_packed = TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg));
2774 if (num_result_args < 0)
2775 num_result_args = in_arg + num_packed;
2777 num_result_args += num_packed;
2781 if (num_result_args >= 0)
2786 /* If no expansion is necessary, we're done. */
2787 if (num_result_args < 0)
2790 /* Expand arguments. */
2791 result_args = make_tree_vec (num_result_args);
2792 for (in_arg = 0; in_arg < nargs; ++in_arg)
2794 tree arg = TREE_VEC_ELT (args, in_arg);
2795 if (ARGUMENT_PACK_P (arg))
2797 tree packed = ARGUMENT_PACK_ARGS (arg);
2798 int i, num_packed = TREE_VEC_LENGTH (packed);
2799 for (i = 0; i < num_packed; ++i, ++out_arg)
2800 TREE_VEC_ELT (result_args, out_arg) = TREE_VEC_ELT(packed, i);
2804 TREE_VEC_ELT (result_args, out_arg) = arg;
2812 /* Complain if DECL shadows a template parameter.
2814 [temp.local]: A template-parameter shall not be redeclared within its
2815 scope (including nested scopes). */
2818 check_template_shadow (tree decl)
2822 /* If we're not in a template, we can't possibly shadow a template
2824 if (!current_template_parms)
2827 /* Figure out what we're shadowing. */
2828 if (TREE_CODE (decl) == OVERLOAD)
2829 decl = OVL_CURRENT (decl);
2830 olddecl = innermost_non_namespace_value (DECL_NAME (decl));
2832 /* If there's no previous binding for this name, we're not shadowing
2833 anything, let alone a template parameter. */
2837 /* If we're not shadowing a template parameter, we're done. Note
2838 that OLDDECL might be an OVERLOAD (or perhaps even an
2839 ERROR_MARK), so we can't just blithely assume it to be a _DECL
2841 if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
2844 /* We check for decl != olddecl to avoid bogus errors for using a
2845 name inside a class. We check TPFI to avoid duplicate errors for
2846 inline member templates. */
2848 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms))
2851 error ("declaration of %q+#D", decl);
2852 error (" shadows template parm %q+#D", olddecl);
2855 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
2856 ORIG_LEVEL, DECL, and TYPE. */
2859 build_template_parm_index (int index,
2865 tree t = make_node (TEMPLATE_PARM_INDEX);
2866 TEMPLATE_PARM_IDX (t) = index;
2867 TEMPLATE_PARM_LEVEL (t) = level;
2868 TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
2869 TEMPLATE_PARM_DECL (t) = decl;
2870 TREE_TYPE (t) = type;
2871 TREE_CONSTANT (t) = TREE_CONSTANT (decl);
2872 TREE_READONLY (t) = TREE_READONLY (decl);
2877 /* Find the canonical type parameter for the given template type
2878 parameter. Returns the canonical type parameter, which may be TYPE
2879 if no such parameter existed. */
2881 canonical_type_parameter (tree type)
2884 int idx = TEMPLATE_TYPE_IDX (type);
2885 if (!canonical_template_parms)
2886 canonical_template_parms = VEC_alloc (tree, gc, idx+1);
2888 while (VEC_length (tree, canonical_template_parms) <= (unsigned)idx)
2889 VEC_safe_push (tree, gc, canonical_template_parms, NULL_TREE);
2891 list = VEC_index (tree, canonical_template_parms, idx);
2892 while (list && !comptypes (type, TREE_VALUE (list), COMPARE_STRUCTURAL))
2893 list = TREE_CHAIN (list);
2896 return TREE_VALUE (list);
2899 VEC_replace(tree, canonical_template_parms, idx,
2900 tree_cons (NULL_TREE, type,
2901 VEC_index (tree, canonical_template_parms, idx)));
2906 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
2907 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
2908 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
2909 new one is created. */
2912 reduce_template_parm_level (tree index, tree type, int levels, tree args,
2913 tsubst_flags_t complain)
2915 if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
2916 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
2917 != TEMPLATE_PARM_LEVEL (index) - levels))
2919 tree orig_decl = TEMPLATE_PARM_DECL (index);
2922 decl = build_decl (TREE_CODE (orig_decl), DECL_NAME (orig_decl), type);
2923 TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl);
2924 TREE_READONLY (decl) = TREE_READONLY (orig_decl);
2925 DECL_ARTIFICIAL (decl) = 1;
2926 SET_DECL_TEMPLATE_PARM_P (decl);
2928 t = build_template_parm_index (TEMPLATE_PARM_IDX (index),
2929 TEMPLATE_PARM_LEVEL (index) - levels,
2930 TEMPLATE_PARM_ORIG_LEVEL (index),
2932 TEMPLATE_PARM_DESCENDANTS (index) = t;
2933 TEMPLATE_PARM_PARAMETER_PACK (t)
2934 = TEMPLATE_PARM_PARAMETER_PACK (index);
2936 /* Template template parameters need this. */
2937 if (TREE_CODE (decl) == TEMPLATE_DECL)
2938 DECL_TEMPLATE_PARMS (decl) = tsubst_template_parms
2939 (DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index)),
2943 return TEMPLATE_PARM_DESCENDANTS (index);
2946 /* Process information from new template parameter PARM and append it to the
2947 LIST being built. This new parameter is a non-type parameter iff
2948 IS_NON_TYPE is true. This new parameter is a parameter
2949 pack iff IS_PARAMETER_PACK is true. */
2952 process_template_parm (tree list, tree parm, bool is_non_type,
2953 bool is_parameter_pack)
2960 gcc_assert (TREE_CODE (parm) == TREE_LIST);
2961 defval = TREE_PURPOSE (parm);
2965 tree p = tree_last (list);
2967 if (p && TREE_VALUE (p) != error_mark_node)
2970 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
2971 idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
2973 idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
2983 parm = TREE_VALUE (parm);
2985 SET_DECL_TEMPLATE_PARM_P (parm);
2987 if (TREE_TYPE (parm) == error_mark_node)
2989 err_parm_list = build_tree_list (defval, parm);
2990 TREE_VALUE (err_parm_list) = error_mark_node;
2991 return chainon (list, err_parm_list);
2997 The top-level cv-qualifiers on the template-parameter are
2998 ignored when determining its type. */
2999 TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
3000 if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
3002 err_parm_list = build_tree_list (defval, parm);
3003 TREE_VALUE (err_parm_list) = error_mark_node;
3004 return chainon (list, err_parm_list);
3007 if (uses_parameter_packs (TREE_TYPE (parm)) && !is_parameter_pack)
3009 /* This template parameter is not a parameter pack, but it
3010 should be. Complain about "bare" parameter packs. */
3011 check_for_bare_parameter_packs (TREE_TYPE (parm));
3013 /* Recover by calling this a parameter pack. */
3014 is_parameter_pack = true;
3018 /* A template parameter is not modifiable. */
3019 TREE_CONSTANT (parm) = 1;
3020 TREE_READONLY (parm) = 1;
3021 decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
3022 TREE_CONSTANT (decl) = 1;
3023 TREE_READONLY (decl) = 1;
3024 DECL_INITIAL (parm) = DECL_INITIAL (decl)
3025 = build_template_parm_index (idx, processing_template_decl,
3026 processing_template_decl,
3027 decl, TREE_TYPE (parm));
3029 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm))
3030 = is_parameter_pack;
3035 parm = TREE_VALUE (TREE_VALUE (parm));
3037 if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
3039 t = cxx_make_type (TEMPLATE_TEMPLATE_PARM);
3040 /* This is for distinguishing between real templates and template
3041 template parameters */
3042 TREE_TYPE (parm) = t;
3043 TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t;
3048 t = cxx_make_type (TEMPLATE_TYPE_PARM);
3049 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3050 decl = build_decl (TYPE_DECL, parm, t);
3053 TYPE_NAME (t) = decl;
3054 TYPE_STUB_DECL (t) = decl;
3056 TEMPLATE_TYPE_PARM_INDEX (t)
3057 = build_template_parm_index (idx, processing_template_decl,
3058 processing_template_decl,
3059 decl, TREE_TYPE (parm));
3060 TEMPLATE_TYPE_PARAMETER_PACK (t) = is_parameter_pack;
3061 TYPE_CANONICAL (t) = canonical_type_parameter (t);
3063 DECL_ARTIFICIAL (decl) = 1;
3064 SET_DECL_TEMPLATE_PARM_P (decl);
3066 parm = build_tree_list (defval, parm);
3067 return chainon (list, parm);
3070 /* The end of a template parameter list has been reached. Process the
3071 tree list into a parameter vector, converting each parameter into a more
3072 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3076 end_template_parm_list (tree parms)
3080 tree saved_parmlist = make_tree_vec (list_length (parms));
3082 current_template_parms
3083 = tree_cons (size_int (processing_template_decl),
3084 saved_parmlist, current_template_parms);
3086 for (parm = parms, nparms = 0; parm; parm = next, nparms++)
3088 next = TREE_CHAIN (parm);
3089 TREE_VEC_ELT (saved_parmlist, nparms) = parm;
3090 TREE_CHAIN (parm) = NULL_TREE;
3093 --processing_template_parmlist;
3095 return saved_parmlist;
3098 /* end_template_decl is called after a template declaration is seen. */
3101 end_template_decl (void)
3103 reset_specialization ();
3105 if (! processing_template_decl)
3108 /* This matches the pushlevel in begin_template_parm_list. */
3111 --processing_template_decl;
3112 current_template_parms = TREE_CHAIN (current_template_parms);
3115 /* Within the declaration of a template, return all levels of template
3116 parameters that apply. The template parameters are represented as
3117 a TREE_VEC, in the form documented in cp-tree.h for template
3121 current_template_args (void)
3124 tree args = NULL_TREE;
3125 int length = TMPL_PARMS_DEPTH (current_template_parms);
3128 /* If there is only one level of template parameters, we do not
3129 create a TREE_VEC of TREE_VECs. Instead, we return a single
3130 TREE_VEC containing the arguments. */
3132 args = make_tree_vec (length);
3134 for (header = current_template_parms; header; header = TREE_CHAIN (header))
3136 tree a = copy_node (TREE_VALUE (header));
3139 TREE_TYPE (a) = NULL_TREE;
3140 for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
3142 tree t = TREE_VEC_ELT (a, i);
3144 /* T will be a list if we are called from within a
3145 begin/end_template_parm_list pair, but a vector directly
3146 if within a begin/end_member_template_processing pair. */
3147 if (TREE_CODE (t) == TREE_LIST)
3151 if (!error_operand_p (t))
3153 if (TREE_CODE (t) == TYPE_DECL
3154 || TREE_CODE (t) == TEMPLATE_DECL)
3158 if (TEMPLATE_TYPE_PARAMETER_PACK (t))
3160 /* Turn this argument into a TYPE_ARGUMENT_PACK
3161 with a single element, which expands T. */
3162 tree vec = make_tree_vec (1);
3163 TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
3165 t = make_node (TYPE_ARGUMENT_PACK);
3166 SET_ARGUMENT_PACK_ARGS (t, vec);
3171 t = DECL_INITIAL (t);
3173 if (TEMPLATE_PARM_PARAMETER_PACK (t))
3175 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3176 with a single element, which expands T. */
3177 tree vec = make_tree_vec (1);
3178 tree type = TREE_TYPE (TEMPLATE_PARM_DECL (t));
3179 TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
3181 t = make_node (NONTYPE_ARGUMENT_PACK);
3182 SET_ARGUMENT_PACK_ARGS (t, vec);
3183 TREE_TYPE (t) = type;
3186 TREE_VEC_ELT (a, i) = t;
3192 TREE_VEC_ELT (args, --l) = a;
3200 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
3201 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
3202 a member template. Used by push_template_decl below. */
3205 build_template_decl (tree decl, tree parms, bool member_template_p)
3207 tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
3208 DECL_TEMPLATE_PARMS (tmpl) = parms;
3209 DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
3210 DECL_MEMBER_TEMPLATE_P (tmpl) = member_template_p;
3211 if (DECL_LANG_SPECIFIC (decl))
3213 DECL_STATIC_FUNCTION_P (tmpl) = DECL_STATIC_FUNCTION_P (decl);
3214 DECL_CONSTRUCTOR_P (tmpl) = DECL_CONSTRUCTOR_P (decl);
3215 DECL_DESTRUCTOR_P (tmpl) = DECL_DESTRUCTOR_P (decl);
3216 DECL_NONCONVERTING_P (tmpl) = DECL_NONCONVERTING_P (decl);
3217 DECL_ASSIGNMENT_OPERATOR_P (tmpl) = DECL_ASSIGNMENT_OPERATOR_P (decl);
3218 if (DECL_OVERLOADED_OPERATOR_P (decl))
3219 SET_OVERLOADED_OPERATOR_CODE (tmpl,
3220 DECL_OVERLOADED_OPERATOR_P (decl));
3226 struct template_parm_data
3228 /* The level of the template parameters we are currently
3232 /* The index of the specialization argument we are currently
3236 /* An array whose size is the number of template parameters. The
3237 elements are nonzero if the parameter has been used in any one
3238 of the arguments processed so far. */
3241 /* An array whose size is the number of template arguments. The
3242 elements are nonzero if the argument makes use of template
3243 parameters of this level. */
3244 int* arg_uses_template_parms;
3247 /* Subroutine of push_template_decl used to see if each template
3248 parameter in a partial specialization is used in the explicit
3249 argument list. If T is of the LEVEL given in DATA (which is
3250 treated as a template_parm_data*), then DATA->PARMS is marked
3254 mark_template_parm (tree t, void* data)
3258 struct template_parm_data* tpd = (struct template_parm_data*) data;
3260 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
3262 level = TEMPLATE_PARM_LEVEL (t);
3263 idx = TEMPLATE_PARM_IDX (t);
3267 level = TEMPLATE_TYPE_LEVEL (t);
3268 idx = TEMPLATE_TYPE_IDX (t);
3271 if (level == tpd->level)
3273 tpd->parms[idx] = 1;
3274 tpd->arg_uses_template_parms[tpd->current_arg] = 1;
3277 /* Return zero so that for_each_template_parm will continue the
3278 traversal of the tree; we want to mark *every* template parm. */
3282 /* Process the partial specialization DECL. */
3285 process_partial_specialization (tree decl)
3287 tree type = TREE_TYPE (decl);
3288 tree maintmpl = CLASSTYPE_TI_TEMPLATE (type);
3289 tree specargs = CLASSTYPE_TI_ARGS (type);
3290 tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
3291 tree inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
3292 tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
3293 int nargs = TREE_VEC_LENGTH (inner_args);
3294 int ntparms = TREE_VEC_LENGTH (inner_parms);
3296 int did_error_intro = 0;
3297 struct template_parm_data tpd;
3298 struct template_parm_data tpd2;
3300 /* We check that each of the template parameters given in the
3301 partial specialization is used in the argument list to the
3302 specialization. For example:
3304 template <class T> struct S;
3305 template <class T> struct S<T*>;
3307 The second declaration is OK because `T*' uses the template
3308 parameter T, whereas
3310 template <class T> struct S<int>;
3312 is no good. Even trickier is:
3323 The S2<T> declaration is actually invalid; it is a
3324 full-specialization. Of course,
3327 struct S2<T (*)(U)>;
3329 or some such would have been OK. */
3330 tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
3331 tpd.parms = (int *) alloca (sizeof (int) * ntparms);
3332 memset (tpd.parms, 0, sizeof (int) * ntparms);
3334 tpd.arg_uses_template_parms = (int *) alloca (sizeof (int) * nargs);
3335 memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
3336 for (i = 0; i < nargs; ++i)
3338 tpd.current_arg = i;
3339 for_each_template_parm (TREE_VEC_ELT (inner_args, i),
3340 &mark_template_parm,
3343 /*include_nondeduced_p=*/false);
3345 for (i = 0; i < ntparms; ++i)
3346 if (tpd.parms[i] == 0)
3348 /* One of the template parms was not used in the
3350 if (!did_error_intro)
3352 error ("template parameters not used in partial specialization:");
3353 did_error_intro = 1;
3356 error (" %qD", TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
3359 /* [temp.class.spec]
3361 The argument list of the specialization shall not be identical to
3362 the implicit argument list of the primary template. */
3363 if (comp_template_args
3365 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
3367 error ("partial specialization %qT does not specialize any template arguments", type);
3369 /* [temp.class.spec]
3371 A partially specialized non-type argument expression shall not
3372 involve template parameters of the partial specialization except
3373 when the argument expression is a simple identifier.
3375 The type of a template parameter corresponding to a specialized
3376 non-type argument shall not be dependent on a parameter of the
3379 Also, we verify that pack expansions only occur at the
3380 end of the argument list. */
3381 gcc_assert (nargs == DECL_NTPARMS (maintmpl));
3383 for (i = 0; i < nargs; ++i)
3385 tree parm = TREE_VALUE (TREE_VEC_ELT (main_inner_parms, i));
3386 tree arg = TREE_VEC_ELT (inner_args, i);
3387 tree packed_args = NULL_TREE;
3390 if (ARGUMENT_PACK_P (arg))
3392 /* Extract the arguments from the argument pack. We'll be
3393 iterating over these in the following loop. */
3394 packed_args = ARGUMENT_PACK_ARGS (arg);
3395 len = TREE_VEC_LENGTH (packed_args);
3398 for (j = 0; j < len; j++)
3401 /* Get the Jth argument in the parameter pack. */
3402 arg = TREE_VEC_ELT (packed_args, j);
3404 if (PACK_EXPANSION_P (arg))
3406 /* Pack expansions must come at the end of the
3408 if ((packed_args && j < len - 1)
3409 || (!packed_args && i < nargs - 1))
3411 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
3412 error ("parameter pack argument %qE must be at the end of the template argument list", arg);
3414 error ("parameter pack argument %qT must be at the end of the template argument list", arg);
3417 TREE_VEC_ELT (packed_args, j) = error_mark_node;
3421 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
3422 /* We only care about the pattern. */
3423 arg = PACK_EXPANSION_PATTERN (arg);
3425 if (/* These first two lines are the `non-type' bit. */
3427 && TREE_CODE (arg) != TEMPLATE_DECL
3428 /* This next line is the `argument expression is not just a
3429 simple identifier' condition and also the `specialized
3430 non-type argument' bit. */
3431 && TREE_CODE (arg) != TEMPLATE_PARM_INDEX)
3433 if ((!packed_args && tpd.arg_uses_template_parms[i])
3434 || (packed_args && uses_template_parms (arg)))
3435 error ("template argument %qE involves template parameter(s)",
3439 /* Look at the corresponding template parameter,
3440 marking which template parameters its type depends
3442 tree type = TREE_TYPE (parm);
3446 /* We haven't yet initialized TPD2. Do so now. */
3447 tpd2.arg_uses_template_parms
3448 = (int *) alloca (sizeof (int) * nargs);
3449 /* The number of parameters here is the number in the
3450 main template, which, as checked in the assertion
3452 tpd2.parms = (int *) alloca (sizeof (int) * nargs);
3454 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
3457 /* Mark the template parameters. But this time, we're
3458 looking for the template parameters of the main
3459 template, not in the specialization. */
3460 tpd2.current_arg = i;
3461 tpd2.arg_uses_template_parms[i] = 0;
3462 memset (tpd2.parms, 0, sizeof (int) * nargs);
3463 for_each_template_parm (type,
3464 &mark_template_parm,
3467 /*include_nondeduced_p=*/false);
3469 if (tpd2.arg_uses_template_parms [i])
3471 /* The type depended on some template parameters.
3472 If they are fully specialized in the
3473 specialization, that's OK. */
3475 for (j = 0; j < nargs; ++j)
3476 if (tpd2.parms[j] != 0
3477 && tpd.arg_uses_template_parms [j])
3479 error ("type %qT of template argument %qE depends "
3480 "on template parameter(s)",
3491 if (retrieve_specialization (maintmpl, specargs,
3492 /*class_specializations_p=*/true))
3493 /* We've already got this specialization. */
3496 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
3497 = tree_cons (specargs, inner_parms,
3498 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
3499 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
3503 /* Check that a template declaration's use of default arguments and
3504 parameter packs is not invalid. Here, PARMS are the template
3505 parameters. IS_PRIMARY is nonzero if DECL is the thing declared by
3506 a primary template. IS_PARTIAL is nonzero if DECL is a partial
3510 IS_FRIEND_DECL is nonzero if DECL is a friend function template
3511 declaration (but not a definition); 1 indicates a declaration, 2
3512 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
3513 emitted for extraneous default arguments.
3515 Returns TRUE if there were no errors found, FALSE otherwise. */
3518 check_default_tmpl_args (tree decl, tree parms, int is_primary,
3519 int is_partial, int is_friend_decl)
3522 int last_level_to_check;
3524 bool no_errors = true;
3528 A default template-argument shall not be specified in a
3529 function template declaration or a function template definition, nor
3530 in the template-parameter-list of the definition of a member of a
3533 if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
3534 /* You can't have a function template declaration in a local
3535 scope, nor you can you define a member of a class template in a
3539 if (current_class_type
3540 && !TYPE_BEING_DEFINED (current_class_type)
3541 && DECL_LANG_SPECIFIC (decl)
3542 /* If this is either a friend defined in the scope of the class
3543 or a member function. */
3544 && (DECL_FUNCTION_MEMBER_P (decl)
3545 ? same_type_p (DECL_CONTEXT (decl), current_class_type)
3546 : DECL_FRIEND_CONTEXT (decl)
3547 ? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type)
3549 /* And, if it was a member function, it really was defined in
3550 the scope of the class. */
3551 && (!DECL_FUNCTION_MEMBER_P (decl)
3552 || DECL_INITIALIZED_IN_CLASS_P (decl)))
3553 /* We already checked these parameters when the template was
3554 declared, so there's no need to do it again now. This function
3555 was defined in class scope, but we're processing it's body now
3556 that the class is complete. */
3559 /* Core issue 226 (C++0x only): the following only applies to class
3561 if ((cxx_dialect == cxx98) || TREE_CODE (decl) != FUNCTION_DECL)
3565 If a template-parameter has a default template-argument, all
3566 subsequent template-parameters shall have a default
3567 template-argument supplied. */
3568 for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
3570 tree inner_parms = TREE_VALUE (parm_level);
3571 int ntparms = TREE_VEC_LENGTH (inner_parms);
3572 int seen_def_arg_p = 0;
3575 for (i = 0; i < ntparms; ++i)
3577 tree parm = TREE_VEC_ELT (inner_parms, i);
3579 if (parm == error_mark_node)
3582 if (TREE_PURPOSE (parm))
3584 else if (seen_def_arg_p)
3586 error ("no default argument for %qD", TREE_VALUE (parm));
3587 /* For better subsequent error-recovery, we indicate that
3588 there should have been a default argument. */
3589 TREE_PURPOSE (parm) = error_mark_node;
3595 && TREE_CODE (decl) == TYPE_DECL
3597 && template_parameter_pack_p (TREE_VALUE (parm)))
3599 /* A primary class template can only have one
3600 parameter pack, at the end of the template
3603 if (TREE_CODE (TREE_VALUE (parm)) == PARM_DECL)
3604 error ("parameter pack %qE must be at the end of the"
3605 " template parameter list", TREE_VALUE (parm));
3607 error ("parameter pack %qT must be at the end of the"
3608 " template parameter list",
3609 TREE_TYPE (TREE_VALUE (parm)));
3611 TREE_VALUE (TREE_VEC_ELT (inner_parms, i))
3619 if (((cxx_dialect == cxx98) && TREE_CODE (decl) != TYPE_DECL)
3623 /* For an ordinary class template, default template arguments are
3624 allowed at the innermost level, e.g.:
3625 template <class T = int>
3627 but, in a partial specialization, they're not allowed even
3628 there, as we have in [temp.class.spec]:
3630 The template parameter list of a specialization shall not
3631 contain default template argument values.
3633 So, for a partial specialization, or for a function template
3634 (in C++98/C++03), we look at all of them. */
3637 /* But, for a primary class template that is not a partial
3638 specialization we look at all template parameters except the
3640 parms = TREE_CHAIN (parms);
3642 /* Figure out what error message to issue. */
3643 if (is_friend_decl == 2)
3644 msg = "default template arguments may not be used in function template friend re-declaration";
3645 else if (is_friend_decl)
3646 msg = "default template arguments may not be used in function template friend declarations";
3647 else if (TREE_CODE (decl) == FUNCTION_DECL && (cxx_dialect == cxx98))
3648 msg = "default template arguments may not be used in function templates";
3649 else if (is_partial)
3650 msg = "default template arguments may not be used in partial specializations";
3652 msg = "default argument for template parameter for class enclosing %qD";
3654 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
3655 /* If we're inside a class definition, there's no need to
3656 examine the parameters to the class itself. On the one
3657 hand, they will be checked when the class is defined, and,
3658 on the other, default arguments are valid in things like:
3659 template <class T = double>
3660 struct S { template <class U> void f(U); };
3661 Here the default argument for `S' has no bearing on the
3662 declaration of `f'. */
3663 last_level_to_check = template_class_depth (current_class_type) + 1;
3665 /* Check everything. */
3666 last_level_to_check = 0;
3668 for (parm_level = parms;
3669 parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
3670 parm_level = TREE_CHAIN (parm_level))
3672 tree inner_parms = TREE_VALUE (parm_level);
3676 ntparms = TREE_VEC_LENGTH (inner_parms);
3677 for (i = 0; i < ntparms; ++i)
3679 if (TREE_VEC_ELT (inner_parms, i) == error_mark_node)
3682 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
3687 if (is_friend_decl == 2)
3694 /* Clear out the default argument so that we are not
3696 TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
3700 /* At this point, if we're still interested in issuing messages,
3701 they must apply to classes surrounding the object declared. */
3703 msg = "default argument for template parameter for class enclosing %qD";
3709 /* Worker for push_template_decl_real, called via
3710 for_each_template_parm. DATA is really an int, indicating the
3711 level of the parameters we are interested in. If T is a template
3712 parameter of that level, return nonzero. */
3715 template_parm_this_level_p (tree t, void* data)
3717 int this_level = *(int *)data;
3720 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
3721 level = TEMPLATE_PARM_LEVEL (t);
3723 level = TEMPLATE_TYPE_LEVEL (t);
3724 return level == this_level;
3727 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
3728 parameters given by current_template_args, or reuses a
3729 previously existing one, if appropriate. Returns the DECL, or an
3730 equivalent one, if it is replaced via a call to duplicate_decls.
3732 If IS_FRIEND is true, DECL is a friend declaration. */
3735 push_template_decl_real (tree decl, bool is_friend)
3743 int new_template_p = 0;
3744 /* True if the template is a member template, in the sense of
3746 bool member_template_p = false;
3748 if (decl == error_mark_node)
3751 /* See if this is a partial specialization. */
3752 is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl)
3753 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
3754 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)));
3756 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl))
3760 /* For a friend, we want the context of the friend function, not
3761 the type of which it is a friend. */
3762 ctx = DECL_CONTEXT (decl);
3763 else if (CP_DECL_CONTEXT (decl)
3764 && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
3765 /* In the case of a virtual function, we want the class in which
3767 ctx = CP_DECL_CONTEXT (decl);
3769 /* Otherwise, if we're currently defining some class, the DECL
3770 is assumed to be a member of the class. */
3771 ctx = current_scope ();
3773 if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
3776 if (!DECL_CONTEXT (decl))
3777 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
3779 /* See if this is a primary template. */
3780 if (is_friend && ctx)
3781 /* A friend template that specifies a class context, i.e.
3782 template <typename T> friend void A<T>::f();
3786 primary = template_parm_scope_p ();
3790 if (DECL_CLASS_SCOPE_P (decl))
3791 member_template_p = true;
3792 if (TREE_CODE (decl) == TYPE_DECL
3793 && ANON_AGGRNAME_P (DECL_NAME (decl)))
3795 error ("template class without a name");
3796 return error_mark_node;
3798 else if (TREE_CODE (decl) == FUNCTION_DECL)
3800 if (DECL_DESTRUCTOR_P (decl))
3804 A destructor shall not be a member template. */
3805 error ("destructor %qD declared as member template", decl);
3806 return error_mark_node;
3808 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl))
3809 && (!TYPE_ARG_TYPES (TREE_TYPE (decl))
3810 || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
3811 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
3812 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl))))
3813 == void_list_node)))
3815 /* [basic.stc.dynamic.allocation]
3817 An allocation function can be a function
3818 template. ... Template allocation functions shall
3819 have two or more parameters. */
3820 error ("invalid template declaration of %qD", decl);
3821 return error_mark_node;
3824 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
3825 && CLASS_TYPE_P (TREE_TYPE (decl)))
3829 error ("template declaration of %q#D", decl);
3830 return error_mark_node;
3834 /* Check to see that the rules regarding the use of default
3835 arguments are not being violated. */
3836 check_default_tmpl_args (decl, current_template_parms,
3837 primary, is_partial, /*is_friend_decl=*/0);
3839 /* Ensure that there are no parameter packs in the type of this
3840 declaration that have not been expanded. */
3841 if (TREE_CODE (decl) == FUNCTION_DECL)
3843 /* Check each of the arguments individually to see if there are
3844 any bare parameter packs. */
3845 tree type = TREE_TYPE (decl);
3846 tree arg = DECL_ARGUMENTS (decl);
3847 tree argtype = TYPE_ARG_TYPES (type);
3849 while (arg && argtype)
3851 if (!FUNCTION_PARAMETER_PACK_P (arg)
3852 && check_for_bare_parameter_packs (TREE_TYPE (arg)))
3854 /* This is a PARM_DECL that contains unexpanded parameter
3855 packs. We have already complained about this in the
3856 check_for_bare_parameter_packs call, so just replace
3857 these types with ERROR_MARK_NODE. */
3858 TREE_TYPE (arg) = error_mark_node;
3859 TREE_VALUE (argtype) = error_mark_node;
3862 arg = TREE_CHAIN (arg);
3863 argtype = TREE_CHAIN (argtype);
3866 /* Check for bare parameter packs in the return type and the
3867 exception specifiers. */
3868 if (check_for_bare_parameter_packs (TREE_TYPE (type)))
3869 /* Errors were already issued, set return type to int
3870 as the frontend doesn't expect error_mark_node as
3872 TREE_TYPE (type) = integer_type_node;
3873 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type)))
3874 TYPE_RAISES_EXCEPTIONS (type) = NULL_TREE;
3876 else if (check_for_bare_parameter_packs (TREE_TYPE (decl)))
3878 TREE_TYPE (decl) = error_mark_node;
3879 return error_mark_node;
3883 return process_partial_specialization (decl);
3885 args = current_template_args ();
3888 || TREE_CODE (ctx) == FUNCTION_DECL
3889 || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
3890 || (is_friend && !DECL_TEMPLATE_INFO (decl)))
3892 if (DECL_LANG_SPECIFIC (decl)
3893 && DECL_TEMPLATE_INFO (decl)
3894 && DECL_TI_TEMPLATE (decl))
3895 tmpl = DECL_TI_TEMPLATE (decl);
3896 /* If DECL is a TYPE_DECL for a class-template, then there won't
3897 be DECL_LANG_SPECIFIC. The information equivalent to
3898 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
3899 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
3900 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
3901 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
3903 /* Since a template declaration already existed for this
3904 class-type, we must be redeclaring it here. Make sure
3905 that the redeclaration is valid. */
3906 redeclare_class_template (TREE_TYPE (decl),
3907 current_template_parms);
3908 /* We don't need to create a new TEMPLATE_DECL; just use the
3909 one we already had. */
3910 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
3914 tmpl = build_template_decl (decl, current_template_parms,
3918 if (DECL_LANG_SPECIFIC (decl)
3919 && DECL_TEMPLATE_SPECIALIZATION (decl))
3921 /* A specialization of a member template of a template
3923 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
3924 DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
3925 DECL_TEMPLATE_INFO (decl) = NULL_TREE;
3931 tree a, t, current, parms;
3933 tree tinfo = get_template_info (decl);
3937 error ("template definition of non-template %q#D", decl);
3938 return error_mark_node;
3941 tmpl = TI_TEMPLATE (tinfo);
3943 if (DECL_FUNCTION_TEMPLATE_P (tmpl)
3944 && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
3945 && DECL_TEMPLATE_SPECIALIZATION (decl)
3946 && DECL_MEMBER_TEMPLATE_P (tmpl))
3950 /* The declaration is a specialization of a member
3951 template, declared outside the class. Therefore, the
3952 innermost template arguments will be NULL, so we
3953 replace them with the arguments determined by the
3954 earlier call to check_explicit_specialization. */
3955 args = DECL_TI_ARGS (decl);
3958 = build_template_decl (decl, current_template_parms,
3960 DECL_TEMPLATE_RESULT (new_tmpl) = decl;
3961 TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
3962 DECL_TI_TEMPLATE (decl) = new_tmpl;
3963 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
3964 DECL_TEMPLATE_INFO (new_tmpl)
3965 = tree_cons (tmpl, args, NULL_TREE);
3967 register_specialization (new_tmpl,
3968 most_general_template (tmpl),
3974 /* Make sure the template headers we got make sense. */
3976 parms = DECL_TEMPLATE_PARMS (tmpl);
3977 i = TMPL_PARMS_DEPTH (parms);
3978 if (TMPL_ARGS_DEPTH (args) != i)
3980 error ("expected %d levels of template parms for %q#D, got %d",
3981 i, decl, TMPL_ARGS_DEPTH (args));
3984 for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
3986 a = TMPL_ARGS_LEVEL (args, i);
3987 t = INNERMOST_TEMPLATE_PARMS (parms);
3989 if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
3991 if (current == decl)
3992 error ("got %d template parameters for %q#D",
3993 TREE_VEC_LENGTH (a), decl);
3995 error ("got %d template parameters for %q#T",
3996 TREE_VEC_LENGTH (a), current);
3997 error (" but %d required", TREE_VEC_LENGTH (t));
3998 return error_mark_node;
4001 if (current == decl)
4004 current = (TYPE_P (current)
4005 ? TYPE_CONTEXT (current)
4006 : DECL_CONTEXT (current));
4009 /* Check that the parms are used in the appropriate qualifying scopes
4010 in the declarator. */
4011 if (!comp_template_args
4013 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl)))))
4016 template arguments to %qD do not match original template %qD",
4017 decl, DECL_TEMPLATE_RESULT (tmpl));
4018 if (!uses_template_parms (TI_ARGS (tinfo)))
4019 inform ("use template<> for an explicit specialization");
4020 /* Avoid crash in import_export_decl. */
4021 DECL_INTERFACE_KNOWN (decl) = 1;
4022 return error_mark_node;
4026 DECL_TEMPLATE_RESULT (tmpl) = decl;
4027 TREE_TYPE (tmpl) = TREE_TYPE (decl);
4029 /* Push template declarations for global functions and types. Note
4030 that we do not try to push a global template friend declared in a
4031 template class; such a thing may well depend on the template
4032 parameters of the class. */
4033 if (new_template_p && !ctx
4034 && !(is_friend && template_class_depth (current_class_type) > 0))
4036 tmpl = pushdecl_namespace_level (tmpl, is_friend);
4037 if (tmpl == error_mark_node)
4038 return error_mark_node;
4040 /* Hide template friend classes that haven't been declared yet. */
4041 if (is_friend && TREE_CODE (decl) == TYPE_DECL)
4043 DECL_ANTICIPATED (tmpl) = 1;
4044 DECL_FRIEND_P (tmpl) = 1;
4050 tree parms = DECL_TEMPLATE_PARMS (tmpl);
4053 DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
4054 if (DECL_CONV_FN_P (tmpl))
4056 int depth = TMPL_PARMS_DEPTH (parms);
4058 /* It is a conversion operator. See if the type converted to
4059 depends on innermost template operands. */
4061 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl)),
4063 DECL_TEMPLATE_CONV_FN_P (tmpl) = 1;
4066 /* Give template template parms a DECL_CONTEXT of the template
4067 for which they are a parameter. */
4068 parms = INNERMOST_TEMPLATE_PARMS (parms);
4069 for (i = TREE_VEC_LENGTH (parms) - 1; i >= 0; --i)
4071 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
4072 if (TREE_CODE (parm) == TEMPLATE_DECL)
4073 DECL_CONTEXT (parm) = tmpl;
4077 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
4078 back to its most general template. If TMPL is a specialization,
4079 ARGS may only have the innermost set of arguments. Add the missing
4080 argument levels if necessary. */
4081 if (DECL_TEMPLATE_INFO (tmpl))
4082 args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);
4084 info = tree_cons (tmpl, args, NULL_TREE);
4086 if (DECL_IMPLICIT_TYPEDEF_P (decl))
4087 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
4088 else if (DECL_LANG_SPECIFIC (decl))
4089 DECL_TEMPLATE_INFO (decl) = info;
4091 return DECL_TEMPLATE_RESULT (tmpl);
4095 push_template_decl (tree decl)
4097 return push_template_decl_real (decl, false);
4100 /* Called when a class template TYPE is redeclared with the indicated
4101 template PARMS, e.g.:
4103 template <class T> struct S;
4104 template <class T> struct S {}; */
4107 redeclare_class_template (tree type, tree parms)
4113 if (!TYPE_TEMPLATE_INFO (type))
4115 error ("%qT is not a template type", type);
4119 tmpl = TYPE_TI_TEMPLATE (type);
4120 if (!PRIMARY_TEMPLATE_P (tmpl))
4121 /* The type is nested in some template class. Nothing to worry
4122 about here; there are no new template parameters for the nested
4128 error ("template specifiers not specified in declaration of %qD",
4133 parms = INNERMOST_TEMPLATE_PARMS (parms);
4134 tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
4136 if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
4138 error ("redeclared with %d template parameter(s)",
4139 TREE_VEC_LENGTH (parms));
4140 inform ("previous declaration %q+D used %d template parameter(s)",
4141 tmpl, TREE_VEC_LENGTH (tmpl_parms));
4145 for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
4152 if (TREE_VEC_ELT (tmpl_parms, i) == error_mark_node
4153 || TREE_VEC_ELT (parms, i) == error_mark_node)
4156 tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
4157 parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
4158 tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i));
4159 parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
4161 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
4163 if (tmpl_parm != error_mark_node
4164 && (TREE_CODE (tmpl_parm) != TREE_CODE (parm)
4165 || (TREE_CODE (tmpl_parm) != TYPE_DECL
4166 && !same_type_p (TREE_TYPE (tmpl_parm), TREE_TYPE (parm)))
4167 || (TREE_CODE (tmpl_parm) != PARM_DECL
4168 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm))
4169 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm))))
4170 || (TREE_CODE (tmpl_parm) == PARM_DECL
4171 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm))
4172 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm))))))
4174 error ("template parameter %q+#D", tmpl_parm);
4175 error ("redeclared here as %q#D", parm);
4179 if (tmpl_default != NULL_TREE && parm_default != NULL_TREE)
4181 /* We have in [temp.param]:
4183 A template-parameter may not be given default arguments
4184 by two different declarations in the same scope. */
4185 error ("redefinition of default argument for %q#D", parm);
4186 inform ("%Joriginal definition appeared here", tmpl_parm);
4190 if (parm_default != NULL_TREE)
4191 /* Update the previous template parameters (which are the ones
4192 that will really count) with the new default value. */
4193 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default;
4194 else if (tmpl_default != NULL_TREE)
4195 /* Update the new parameters, too; they'll be used as the
4196 parameters for any members. */
4197 TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default;
4203 /* Simplify EXPR if it is a non-dependent expression. Returns the
4204 (possibly simplified) expression. */
4207 fold_non_dependent_expr (tree expr)
4209 if (expr == NULL_TREE)
4212 /* If we're in a template, but EXPR isn't value dependent, simplify
4213 it. We're supposed to treat:
4215 template <typename T> void f(T[1 + 1]);
4216 template <typename T> void f(T[2]);
4218 as two declarations of the same function, for example. */
4219 if (processing_template_decl
4220 && !type_dependent_expression_p (expr)
4221 && !value_dependent_expression_p (expr))
4223 HOST_WIDE_INT saved_processing_template_decl;
4225 saved_processing_template_decl = processing_template_decl;
4226 processing_template_decl = 0;
4227 expr = tsubst_copy_and_build (expr,
4230 /*in_decl=*/NULL_TREE,
4231 /*function_p=*/false,
4232 /*integral_constant_expression_p=*/true);
4233 processing_template_decl = saved_processing_template_decl;
4238 /* EXPR is an expression which is used in a constant-expression context.
4239 For instance, it could be a VAR_DECL with a constant initializer.
4240 Extract the innermost constant expression.
4242 This is basically a more powerful version of
4243 integral_constant_value, which can be used also in templates where
4244 initializers can maintain a syntactic rather than semantic form
4245 (even if they are non-dependent, for access-checking purposes). */
4248 fold_decl_constant_value (tree expr)
4250 tree const_expr = expr;
4253 expr = fold_non_dependent_expr (const_expr);
4254 const_expr = integral_constant_value (expr);
4256 while (expr != const_expr);
4261 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
4262 must be a function or a pointer-to-function type, as specified
4263 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
4264 and check that the resulting function has external linkage. */
4267 convert_nontype_argument_function (tree type, tree expr)
4272 fn = instantiate_type (type, fns, tf_none);
4273 if (fn == error_mark_node)
4274 return error_mark_node;
4277 if (TREE_CODE (fn_no_ptr) == ADDR_EXPR)
4278 fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0);
4279 if (TREE_CODE (fn_no_ptr) == BASELINK)
4280 fn_no_ptr = BASELINK_FUNCTIONS (fn_no_ptr);
4282 /* [temp.arg.nontype]/1
4284 A template-argument for a non-type, non-template template-parameter
4287 -- the address of an object or function with external linkage. */
4288 if (!DECL_EXTERNAL_LINKAGE_P (fn_no_ptr))
4290 error ("%qE is not a valid template argument for type %qT "
4291 "because function %qD has not external linkage",
4292 expr, type, fn_no_ptr);
4299 /* Attempt to convert the non-type template parameter EXPR to the
4300 indicated TYPE. If the conversion is successful, return the
4301 converted value. If the conversion is unsuccessful, return
4302 NULL_TREE if we issued an error message, or error_mark_node if we
4303 did not. We issue error messages for out-and-out bad template
4304 parameters, but not simply because the conversion failed, since we
4305 might be just trying to do argument deduction. Both TYPE and EXPR
4306 must be non-dependent.
4308 The conversion follows the special rules described in
4309 [temp.arg.nontype], and it is much more strict than an implicit
4312 This function is called twice for each template argument (see
4313 lookup_template_class for a more accurate description of this
4314 problem). This means that we need to handle expressions which
4315 are not valid in a C++ source, but can be created from the
4316 first call (for instance, casts to perform conversions). These
4317 hacks can go away after we fix the double coercion problem. */
4320 convert_nontype_argument (tree type, tree expr)
4324 /* Detect immediately string literals as invalid non-type argument.
4325 This special-case is not needed for correctness (we would easily
4326 catch this later), but only to provide better diagnostic for this
4327 common user mistake. As suggested by DR 100, we do not mention
4328 linkage issues in the diagnostic as this is not the point. */
4329 if (TREE_CODE (expr) == STRING_CST)
4331 error ("%qE is not a valid template argument for type %qT "
4332 "because string literals can never be used in this context",
4337 /* If we are in a template, EXPR may be non-dependent, but still
4338 have a syntactic, rather than semantic, form. For example, EXPR
4339 might be a SCOPE_REF, rather than the VAR_DECL to which the
4340 SCOPE_REF refers. Preserving the qualifying scope is necessary
4341 so that access checking can be performed when the template is
4342 instantiated -- but here we need the resolved form so that we can
4343 convert the argument. */
4344 expr = fold_non_dependent_expr (expr);
4345 if (error_operand_p (expr))
4346 return error_mark_node;
4347 expr_type = TREE_TYPE (expr);
4349 /* HACK: Due to double coercion, we can get a
4350 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
4351 which is the tree that we built on the first call (see
4352 below when coercing to reference to object or to reference to
4353 function). We just strip everything and get to the arg.
4354 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
4356 if (TREE_CODE (expr) == NOP_EXPR)
4358 if (TYPE_REF_OBJ_P (type) || TYPE_REFFN_P (type))
4360 /* ??? Maybe we could use convert_from_reference here, but we
4361 would need to relax its constraints because the NOP_EXPR
4362 could actually change the type to something more cv-qualified,
4363 and this is not folded by convert_from_reference. */
4364 tree addr = TREE_OPERAND (expr, 0);
4365 gcc_assert (TREE_CODE (expr_type) == REFERENCE_TYPE);
4366 gcc_assert (TREE_CODE (addr) == ADDR_EXPR);
4367 gcc_assert (TREE_CODE (TREE_TYPE (addr)) == POINTER_TYPE);
4368 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4369 (TREE_TYPE (expr_type),
4370 TREE_TYPE (TREE_TYPE (addr))));
4372 expr = TREE_OPERAND (addr, 0);
4373 expr_type = TREE_TYPE (expr);
4376 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
4377 parameter is a pointer to object, through decay and
4378 qualification conversion. Let's strip everything. */
4379 else if (TYPE_PTROBV_P (type))
4382 gcc_assert (TREE_CODE (expr) == ADDR_EXPR);
4383 gcc_assert (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE);
4384 /* Skip the ADDR_EXPR only if it is part of the decay for
4385 an array. Otherwise, it is part of the original argument
4386 in the source code. */
4387 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == ARRAY_TYPE)
4388 expr = TREE_OPERAND (expr, 0);
4389 expr_type = TREE_TYPE (expr);
4393 /* [temp.arg.nontype]/5, bullet 1
4395 For a non-type template-parameter of integral or enumeration type,
4396 integral promotions (_conv.prom_) and integral conversions
4397 (_conv.integral_) are applied. */
4398 if (INTEGRAL_TYPE_P (type))
4400 if (!INTEGRAL_TYPE_P (expr_type))
4401 return error_mark_node;
4403 expr = fold_decl_constant_value (expr);
4404 /* Notice that there are constant expressions like '4 % 0' which
4405 do not fold into integer constants. */
4406 if (TREE_CODE (expr) != INTEGER_CST)
4408 error ("%qE is not a valid template argument for type %qT "
4409 "because it is a non-constant expression", expr, type);
4413 /* At this point, an implicit conversion does what we want,
4414 because we already know that the expression is of integral
4416 expr = ocp_convert (type, expr, CONV_IMPLICIT, LOOKUP_PROTECT);
4417 if (expr == error_mark_node)
4418 return error_mark_node;
4420 /* Conversion was allowed: fold it to a bare integer constant. */
4423 /* [temp.arg.nontype]/5, bullet 2
4425 For a non-type template-parameter of type pointer to object,
4426 qualification conversions (_conv.qual_) and the array-to-pointer
4427 conversion (_conv.array_) are applied. */
4428 else if (TYPE_PTROBV_P (type))
4430 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
4432 A template-argument for a non-type, non-template template-parameter
4433 shall be one of: [...]
4435 -- the name of a non-type template-parameter;
4436 -- the address of an object or function with external linkage, [...]
4437 expressed as "& id-expression" where the & is optional if the name
4438 refers to a function or array, or if the corresponding
4439 template-parameter is a reference.
4441 Here, we do not care about functions, as they are invalid anyway
4442 for a parameter of type pointer-to-object. */
4444 if (DECL_P (expr) && DECL_TEMPLATE_PARM_P (expr))
4445 /* Non-type template parameters are OK. */
4447 else if (TREE_CODE (expr) != ADDR_EXPR
4448 && TREE_CODE (expr_type) != ARRAY_TYPE)
4450 if (TREE_CODE (expr) == VAR_DECL)
4452 error ("%qD is not a valid template argument "
4453 "because %qD is a variable, not the address of "
4458 /* Other values, like integer constants, might be valid
4459 non-type arguments of some other type. */
4460 return error_mark_node;
4466 decl = ((TREE_CODE (expr) == ADDR_EXPR)
4467 ? TREE_OPERAND (expr, 0) : expr);
4468 if (TREE_CODE (decl) != VAR_DECL)
4470 error ("%qE is not a valid template argument of type %qT "
4471 "because %qE is not a variable",
4475 else if (!DECL_EXTERNAL_LINKAGE_P (decl))
4477 error ("%qE is not a valid template argument of type %qT "
4478 "because %qD does not have external linkage",
4484 expr = decay_conversion (expr);
4485 if (expr == error_mark_node)
4486 return error_mark_node;
4488 expr = perform_qualification_conversions (type, expr);
4489 if (expr == error_mark_node)
4490 return error_mark_node;
4492 /* [temp.arg.nontype]/5, bullet 3
4494 For a non-type template-parameter of type reference to object, no
4495 conversions apply. The type referred to by the reference may be more
4496 cv-qualified than the (otherwise identical) type of the
4497 template-argument. The template-parameter is bound directly to the
4498 template-argument, which must be an lvalue. */
4499 else if (TYPE_REF_OBJ_P (type))
4501 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type),
4503 return error_mark_node;
4505 if (!at_least_as_qualified_p (TREE_TYPE (type), expr_type))
4507 error ("%qE is not a valid template argument for type %qT "
4508 "because of conflicts in cv-qualification", expr, type);
4512 if (!real_lvalue_p (expr))
4514 error ("%qE is not a valid template argument for type %qT "
4515 "because it is not an lvalue", expr, type);
4519 /* [temp.arg.nontype]/1
4521 A template-argument for a non-type, non-template template-parameter
4522 shall be one of: [...]
4524 -- the address of an object or function with external linkage. */
4525 if (!DECL_EXTERNAL_LINKAGE_P (expr))
4527 error ("%qE is not a valid template argument for type %qT "
4528 "because object %qD has not external linkage",
4533 expr = build_nop (type, build_address (expr));
4535 /* [temp.arg.nontype]/5, bullet 4
4537 For a non-type template-parameter of type pointer to function, only
4538 the function-to-pointer conversion (_conv.func_) is applied. If the
4539 template-argument represents a set of overloaded functions (or a
4540 pointer to such), the matching function is selected from the set
4542 else if (TYPE_PTRFN_P (type))
4544 /* If the argument is a template-id, we might not have enough
4545 context information to decay the pointer. */
4546 if (!type_unknown_p (expr_type))
4548 expr = decay_conversion (expr);
4549 if (expr == error_mark_node)
4550 return error_mark_node;
4553 expr = convert_nontype_argument_function (type, expr);
4554 if (!expr || expr == error_mark_node)
4557 /* [temp.arg.nontype]/5, bullet 5
4559 For a non-type template-parameter of type reference to function, no
4560 conversions apply. If the template-argument represents a set of
4561 overloaded functions, the matching function is selected from the set
4563 else if (TYPE_REFFN_P (type))
4565 if (TREE_CODE (expr) == ADDR_EXPR)
4567 error ("%qE is not a valid template argument for type %qT "
4568 "because it is a pointer", expr, type);
4569 inform ("try using %qE instead", TREE_OPERAND (expr, 0));
4573 expr = convert_nontype_argument_function (TREE_TYPE (type), expr);
4574 if (!expr || expr == error_mark_node)
4577 expr = build_nop (type, build_address (expr));
4579 /* [temp.arg.nontype]/5, bullet 6
4581 For a non-type template-parameter of type pointer to member function,
4582 no conversions apply. If the template-argument represents a set of
4583 overloaded member functions, the matching member function is selected
4584 from the set (_over.over_). */
4585 else if (TYPE_PTRMEMFUNC_P (type))
4587 expr = instantiate_type (type, expr, tf_none);
4588 if (expr == error_mark_node)
4589 return error_mark_node;
4591 /* There is no way to disable standard conversions in
4592 resolve_address_of_overloaded_function (called by
4593 instantiate_type). It is possible that the call succeeded by
4594 converting &B::I to &D::I (where B is a base of D), so we need
4595 to reject this conversion here.
4597 Actually, even if there was a way to disable standard conversions,
4598 it would still be better to reject them here so that we can
4599 provide a superior diagnostic. */
4600 if (!same_type_p (TREE_TYPE (expr), type))
4602 /* Make sure we are just one standard conversion off. */
4603 gcc_assert (can_convert (type, TREE_TYPE (expr)));
4604 error ("%qE is not a valid template argument for type %qT "
4605 "because it is of type %qT", expr, type,
4607 inform ("standard conversions are not allowed in this context");
4611 /* [temp.arg.nontype]/5, bullet 7
4613 For a non-type template-parameter of type pointer to data member,
4614 qualification conversions (_conv.qual_) are applied. */
4615 else if (TYPE_PTRMEM_P (type))
4617 expr = perform_qualification_conversions (type, expr);
4618 if (expr == error_mark_node)
4621 /* A template non-type parameter must be one of the above. */
4625 /* Sanity check: did we actually convert the argument to the
4627 gcc_assert (same_type_p (type, TREE_TYPE (expr)));
4631 /* Subroutine of coerce_template_template_parms, which returns 1 if
4632 PARM_PARM and ARG_PARM match using the rule for the template
4633 parameters of template template parameters. Both PARM and ARG are
4634 template parameters; the rest of the arguments are the same as for
4635 coerce_template_template_parms.
4638 coerce_template_template_parm (tree parm,
4640 tsubst_flags_t complain,
4644 if (arg == NULL_TREE || arg == error_mark_node
4645 || parm == NULL_TREE || parm == error_mark_node)
4648 if (TREE_CODE (arg) != TREE_CODE (parm))
4651 switch (TREE_CODE (parm))
4654 /* We encounter instantiations of templates like
4655 template <template <template <class> class> class TT>
4658 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
4659 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
4661 if (!coerce_template_template_parms
4662 (parmparm, argparm, complain, in_decl, outer_args))
4668 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg))
4669 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm)))
4670 /* Argument is a parameter pack but parameter is not. */
4675 /* The tsubst call is used to handle cases such as
4677 template <int> class C {};
4678 template <class T, template <T> class TT> class D {};
4681 i.e. the parameter list of TT depends on earlier parameters. */
4682 if (!dependent_type_p (TREE_TYPE (arg))
4684 (tsubst (TREE_TYPE (parm), outer_args, complain, in_decl),
4688 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg))
4689 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))
4690 /* Argument is a parameter pack but parameter is not. */
4703 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
4704 template template parameters. Both PARM_PARMS and ARG_PARMS are
4705 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
4708 Consider the example:
4709 template <class T> class A;
4710 template<template <class U> class TT> class B;
4712 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
4713 the parameters to A, and OUTER_ARGS contains A. */
4716 coerce_template_template_parms (tree parm_parms,
4718 tsubst_flags_t complain,
4722 int nparms, nargs, i;
4726 gcc_assert (TREE_CODE (parm_parms) == TREE_VEC);
4727 gcc_assert (TREE_CODE (arg_parms) == TREE_VEC);
4729 nparms = TREE_VEC_LENGTH (parm_parms);
4730 nargs = TREE_VEC_LENGTH (arg_parms);
4732 /* Determine whether we have a parameter pack at the end of the
4733 template template parameter's template parameter list. */
4734 if (TREE_VEC_ELT (parm_parms, nparms - 1) != error_mark_node)
4736 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, nparms - 1));
4738 switch (TREE_CODE (parm))
4742 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm)))
4747 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))
4757 && !(variadic_p && nargs >= nparms - 1))
4760 /* Check all of the template parameters except the parameter pack at
4761 the end (if any). */
4762 for (i = 0; i < nparms - variadic_p; ++i)
4764 if (TREE_VEC_ELT (parm_parms, i) == error_mark_node
4765 || TREE_VEC_ELT (arg_parms, i) == error_mark_node)
4768 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
4769 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
4771 if (!coerce_template_template_parm (parm, arg, complain, in_decl,
4779 /* Check each of the template parameters in the template
4780 argument against the template parameter pack at the end of
4781 the template template parameter. */
4782 if (TREE_VEC_ELT (parm_parms, i) == error_mark_node)
4785 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
4787 for (; i < nargs; ++i)
4789 if (TREE_VEC_ELT (arg_parms, i) == error_mark_node)
4792 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
4794 if (!coerce_template_template_parm (parm, arg, complain, in_decl,
4803 /* Verifies that the deduced template arguments (in TARGS) for the
4804 template template parameters (in TPARMS) represent valid bindings,
4805 by comparing the template parameter list of each template argument
4806 to the template parameter list of its corresponding template
4807 template parameter, in accordance with DR150. This
4808 routine can only be called after all template arguments have been
4809 deduced. It will return TRUE if all of the template template
4810 parameter bindings are okay, FALSE otherwise. */
4812 template_template_parm_bindings_ok_p (tree tparms, tree targs)
4814 int i, ntparms = TREE_VEC_LENGTH (tparms);
4817 /* We're dealing with template parms in this process. */
4818 ++processing_template_decl;
4820 targs = INNERMOST_TEMPLATE_ARGS (targs);
4822 for (i = 0; i < ntparms; ++i)
4824 tree tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
4825 tree targ = TREE_VEC_ELT (targs, i);
4827 if (TREE_CODE (tparm) == TEMPLATE_DECL && targ)
4829 tree packed_args = NULL_TREE;
4832 if (ARGUMENT_PACK_P (targ))
4834 /* Look inside the argument pack. */
4835 packed_args = ARGUMENT_PACK_ARGS (targ);
4836 len = TREE_VEC_LENGTH (packed_args);
4839 for (idx = 0; idx < len; ++idx)
4841 tree targ_parms = NULL_TREE;
4844 /* Extract the next argument from the argument
4846 targ = TREE_VEC_ELT (packed_args, idx);
4848 if (PACK_EXPANSION_P (targ))
4849 /* Look at the pattern of the pack expansion. */
4850 targ = PACK_EXPANSION_PATTERN (targ);
4852 /* Extract the template parameters from the template
4854 if (TREE_CODE (targ) == TEMPLATE_DECL)
4855 targ_parms = DECL_INNERMOST_TEMPLATE_PARMS (targ);
4856 else if (TREE_CODE (targ) == TEMPLATE_TEMPLATE_PARM)
4857 targ_parms = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ));
4859 /* Verify that we can coerce the template template
4860 parameters from the template argument to the template
4861 parameter. This requires an exact match. */
4863 && !coerce_template_template_parms
4864 (DECL_INNERMOST_TEMPLATE_PARMS (tparm),
4879 --processing_template_decl;
4883 /* Convert the indicated template ARG as necessary to match the
4884 indicated template PARM. Returns the converted ARG, or
4885 error_mark_node if the conversion was unsuccessful. Error and
4886 warning messages are issued under control of COMPLAIN. This
4887 conversion is for the Ith parameter in the parameter list. ARGS is
4888 the full set of template arguments deduced so far. */
4891 convert_template_argument (tree parm,
4894 tsubst_flags_t complain,
4900 int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
4902 if (TREE_CODE (arg) == TREE_LIST
4903 && TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF)
4905 /* The template argument was the name of some
4906 member function. That's usually
4907 invalid, but static members are OK. In any
4908 case, grab the underlying fields/functions
4909 and issue an error later if required. */
4910 orig_arg = TREE_VALUE (arg);
4911 TREE_TYPE (arg) = unknown_type_node;
4916 requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
4917 requires_type = (TREE_CODE (parm) == TYPE_DECL
4918 || requires_tmpl_type);
4920 /* When determining whether an argument pack expansion is a template,
4921 look at the pattern. */
4922 if (TREE_CODE (arg) == TYPE_PACK_EXPANSION)
4923 arg = PACK_EXPANSION_PATTERN (arg);
4926 ((TREE_CODE (arg) == TEMPLATE_DECL
4927 && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
4928 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4929 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
4932 && (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4933 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE))
4934 arg = TYPE_STUB_DECL (arg);
4936 is_type = TYPE_P (arg) || is_tmpl_type;
4938 if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
4939 && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
4941 permerror ("to refer to a type member of a template parameter, "
4942 "use %<typename %E%>", orig_arg);
4944 orig_arg = make_typename_type (TREE_OPERAND (arg, 0),
4945 TREE_OPERAND (arg, 1),
4947 complain & tf_error);
4951 if (is_type != requires_type)
4955 if (complain & tf_error)
4957 error ("type/value mismatch at argument %d in template "
4958 "parameter list for %qD",
4961 error (" expected a constant of type %qT, got %qT",
4963 (DECL_P (arg) ? DECL_NAME (arg) : orig_arg));
4964 else if (requires_tmpl_type)
4965 error (" expected a class template, got %qE", orig_arg);
4967 error (" expected a type, got %qE", orig_arg);
4970 return error_mark_node;
4972 if (is_tmpl_type ^ requires_tmpl_type)
4974 if (in_decl && (complain & tf_error))
4976 error ("type/value mismatch at argument %d in template "
4977 "parameter list for %qD",
4980 error (" expected a type, got %qT", DECL_NAME (arg));
4982 error (" expected a class template, got %qT", orig_arg);
4984 return error_mark_node;
4989 if (requires_tmpl_type)
4991 if (TREE_CODE (TREE_TYPE (arg)) == UNBOUND_CLASS_TEMPLATE)
4992 /* The number of argument required is not known yet.
4993 Just accept it for now. */
4994 val = TREE_TYPE (arg);
4997 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
5000 argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
5002 if (coerce_template_template_parms (parmparm, argparm,
5008 /* TEMPLATE_TEMPLATE_PARM node is preferred over
5010 if (val != error_mark_node)
5012 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val))
5013 val = TREE_TYPE (val);
5014 else if (TREE_CODE (val) == TYPE_PACK_EXPANSION
5015 && DECL_TEMPLATE_TEMPLATE_PARM_P (arg))
5017 val = TREE_TYPE (arg);
5018 val = make_pack_expansion (val);
5024 if (in_decl && (complain & tf_error))
5026 error ("type/value mismatch at argument %d in "
5027 "template parameter list for %qD",
5029 error (" expected a template of type %qD, got %qD",
5033 val = error_mark_node;
5039 /* We only form one instance of each template specialization.
5040 Therefore, if we use a non-canonical variant (i.e., a
5041 typedef), any future messages referring to the type will use
5042 the typedef, which is confusing if those future uses do not
5043 themselves also use the typedef. */
5045 val = canonical_type_variant (val);
5049 tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl);
5051 if (invalid_nontype_parm_type_p (t, complain))
5052 return error_mark_node;
5054 if (!uses_template_parms (orig_arg) && !uses_template_parms (t))
5055 /* We used to call digest_init here. However, digest_init
5056 will report errors, which we don't want when complain
5057 is zero. More importantly, digest_init will try too
5058 hard to convert things: for example, `0' should not be
5059 converted to pointer type at this point according to
5060 the standard. Accepting this is not merely an
5061 extension, since deciding whether or not these
5062 conversions can occur is part of determining which
5063 function template to call, or whether a given explicit
5064 argument specification is valid. */
5065 val = convert_nontype_argument (t, orig_arg);
5069 if (val == NULL_TREE)
5070 val = error_mark_node;
5071 else if (val == error_mark_node && (complain & tf_error))
5072 error ("could not convert template argument %qE to %qT", orig_arg, t);
5078 /* Coerces the remaining template arguments in INNER_ARGS (from
5079 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
5080 Returns the coerced argument pack. PARM_IDX is the position of this
5081 parameter in the template parameter list. ARGS is the original
5082 template argument list. */
5084 coerce_template_parameter_pack (tree parms,
5092 tsubst_flags_t complain)
5094 tree parm = TREE_VEC_ELT (parms, parm_idx);
5095 int nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
5098 tree packed_types = NULL_TREE;
5100 if (arg_idx > nargs)
5103 packed_args = make_tree_vec (nargs - arg_idx);
5105 if (TREE_CODE (TREE_VALUE (parm)) == PARM_DECL
5106 && uses_parameter_packs (TREE_TYPE (TREE_VALUE (parm))))
5108 /* When the template parameter is a non-type template
5109 parameter pack whose type uses parameter packs, we need
5110 to look at each of the template arguments
5111 separately. Build a vector of the types for these
5112 non-type template parameters in PACKED_TYPES. */
5114 = make_pack_expansion (TREE_TYPE (TREE_VALUE (parm)));
5115 packed_types = tsubst_pack_expansion (expansion, args,
5118 if (packed_types == error_mark_node)
5119 return error_mark_node;
5121 /* Check that we have the right number of arguments. */
5123 && !PACK_EXPANSION_P (TREE_VEC_ELT (inner_args, arg_idx))
5124 && nargs - arg_idx != TREE_VEC_LENGTH (packed_types))
5127 = TREE_VEC_LENGTH (parms) - 1 + TREE_VEC_LENGTH (packed_types);
5128 error ("wrong number of template arguments (%d, should be %d)",
5129 nargs, needed_parms);
5130 return error_mark_node;
5133 /* If we aren't able to check the actual arguments now
5134 (because they haven't been expanded yet), we can at least
5135 verify that all of the types used for the non-type
5136 template parameter pack are, in fact, valid for non-type
5137 template parameters. */
5139 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args, arg_idx)))
5141 int j, len = TREE_VEC_LENGTH (packed_types);
5142 for (j = 0; j < len; ++j)
5144 tree t = TREE_VEC_ELT (packed_types, j);
5145 if (invalid_nontype_parm_type_p (t, complain))
5146 return error_mark_node;
5151 /* Convert the remaining arguments, which will be a part of the
5152 parameter pack "parm". */
5153 for (; arg_idx < nargs; ++arg_idx)
5155 tree arg = TREE_VEC_ELT (inner_args, arg_idx);
5156 tree actual_parm = TREE_VALUE (parm);
5158 if (packed_types && !PACK_EXPANSION_P (arg))
5160 /* When we have a vector of types (corresponding to the
5161 non-type template parameter pack that uses parameter
5162 packs in its type, as mention above), and the
5163 argument is not an expansion (which expands to a
5164 currently unknown number of arguments), clone the
5165 parm and give it the next type in PACKED_TYPES. */
5166 actual_parm = copy_node (actual_parm);
5167 TREE_TYPE (actual_parm) =
5168 TREE_VEC_ELT (packed_types, arg_idx - parm_idx);
5171 if (arg != error_mark_node)
5172 arg = convert_template_argument (actual_parm,
5173 arg, new_args, complain, parm_idx,
5175 if (arg == error_mark_node)
5177 TREE_VEC_ELT (packed_args, arg_idx - parm_idx) = arg;
5180 if (TREE_CODE (TREE_VALUE (parm)) == TYPE_DECL
5181 || TREE_CODE (TREE_VALUE (parm)) == TEMPLATE_DECL)
5182 argument_pack = make_node (TYPE_ARGUMENT_PACK);
5185 argument_pack = make_node (NONTYPE_ARGUMENT_PACK);
5186 TREE_TYPE (argument_pack)
5187 = tsubst (TREE_TYPE (TREE_VALUE (parm)), new_args, complain, in_decl);
5188 TREE_CONSTANT (argument_pack) = 1;
5191 SET_ARGUMENT_PACK_ARGS (argument_pack, packed_args);
5192 return argument_pack;
5195 /* Convert all template arguments to their appropriate types, and
5196 return a vector containing the innermost resulting template
5197 arguments. If any error occurs, return error_mark_node. Error and
5198 warning messages are issued under control of COMPLAIN.
5200 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
5201 for arguments not specified in ARGS. Otherwise, if
5202 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
5203 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
5204 USE_DEFAULT_ARGS is false, then all arguments must be specified in
5208 coerce_template_parms (tree parms,
5211 tsubst_flags_t complain,
5212 bool require_all_args,
5213 bool use_default_args)
5215 int nparms, nargs, parm_idx, arg_idx, lost = 0;
5218 tree new_inner_args;
5219 bool saved_skip_evaluation;
5221 /* When used as a boolean value, indicates whether this is a
5222 variadic template parameter list. Since it's an int, we can also
5223 subtract it from nparms to get the number of non-variadic
5228 = expand_template_argument_pack (INNERMOST_TEMPLATE_ARGS (args));
5230 nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
5231 nparms = TREE_VEC_LENGTH (parms);
5233 /* Determine if there are any parameter packs. */
5234 for (parm_idx = 0; parm_idx < nparms; ++parm_idx)
5236 tree tparm = TREE_VALUE (TREE_VEC_ELT (parms, parm_idx));
5237 if (template_parameter_pack_p (tparm))
5244 if ((nargs > nparms - variadic_p && !variadic_p)
5245 || (nargs < nparms - variadic_p
5247 && (!use_default_args
5248 || (TREE_VEC_ELT (parms, nargs) != error_mark_node
5249 && !TREE_PURPOSE (TREE_VEC_ELT (parms, nargs))))))
5251 if (complain & tf_error)
5253 const char *or_more = "";
5256 or_more = " or more";
5260 error ("wrong number of template arguments (%d, should be %d%s)",
5261 nargs, nparms, or_more);
5264 error ("provided for %q+D", in_decl);
5267 return error_mark_node;
5270 /* We need to evaluate the template arguments, even though this
5271 template-id may be nested within a "sizeof". */
5272 saved_skip_evaluation = skip_evaluation;
5273 skip_evaluation = false;
5274 new_inner_args = make_tree_vec (nparms);
5275 new_args = add_outermost_template_args (args, new_inner_args);
5276 for (parm_idx = 0, arg_idx = 0; parm_idx < nparms; parm_idx++, arg_idx++)
5281 /* Get the Ith template parameter. */
5282 parm = TREE_VEC_ELT (parms, parm_idx);
5284 if (parm == error_mark_node)
5286 TREE_VEC_ELT (new_inner_args, arg_idx) = error_mark_node;
5290 /* Calculate the next argument. */
5291 if (template_parameter_pack_p (TREE_VALUE (parm)))
5293 /* All remaining arguments will be placed in the
5294 template parameter pack PARM. */
5295 arg = coerce_template_parameter_pack (parms, parm_idx, args,
5296 inner_args, arg_idx,
5300 /* Store this argument. */
5301 if (arg == error_mark_node)
5303 TREE_VEC_ELT (new_inner_args, parm_idx) = arg;
5305 /* We are done with all of the arguments. */
5310 else if (arg_idx < nargs)
5312 arg = TREE_VEC_ELT (inner_args, arg_idx);
5314 if (arg && PACK_EXPANSION_P (arg))
5316 if (complain & tf_error)
5318 /* If ARG is a pack expansion, but PARM is not a
5319 template parameter pack (if it were, we would have
5320 handled it above), we're trying to expand into a
5321 fixed-length argument list. */
5322 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
5323 error ("cannot expand %<%E%> into a fixed-length "
5324 "argument list", arg);
5326 error ("cannot expand %<%T%> into a fixed-length "
5327 "argument list", arg);
5329 return error_mark_node;
5332 else if (require_all_args)
5333 /* There must be a default arg in this case. */
5334 arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
5339 if (arg == error_mark_node)
5341 if (complain & tf_error)
5342 error ("template argument %d is invalid", arg_idx + 1);
5345 /* This only occurs if there was an error in the template
5346 parameter list itself (which we would already have
5347 reported) that we are trying to recover from, e.g., a class
5348 template with a parameter list such as
5349 template<typename..., typename>. */
5350 return error_mark_node;
5352 arg = convert_template_argument (TREE_VALUE (parm),
5353 arg, new_args, complain,
5356 if (arg == error_mark_node)
5358 TREE_VEC_ELT (new_inner_args, arg_idx) = arg;
5360 skip_evaluation = saved_skip_evaluation;
5363 return error_mark_node;
5365 return new_inner_args;
5368 /* Returns 1 if template args OT and NT are equivalent. */
5371 template_args_equal (tree ot, tree nt)
5376 if (TREE_CODE (nt) == TREE_VEC)
5377 /* For member templates */
5378 return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt);
5379 else if (PACK_EXPANSION_P (ot))
5380 return PACK_EXPANSION_P (nt)
5381 && template_args_equal (PACK_EXPANSION_PATTERN (ot),
5382 PACK_EXPANSION_PATTERN (nt));
5383 else if (TYPE_P (nt))
5384 return TYPE_P (ot) && same_type_p (ot, nt);
5385 else if (TREE_CODE (ot) == TREE_VEC || TYPE_P (ot))
5388 return cp_tree_equal (ot, nt);
5391 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
5392 of template arguments. Returns 0 otherwise. */
5395 comp_template_args (tree oldargs, tree newargs)
5399 oldargs = expand_template_argument_pack (oldargs);
5400 newargs = expand_template_argument_pack (newargs);
5402 if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
5405 for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
5407 tree nt = TREE_VEC_ELT (newargs, i);
5408 tree ot = TREE_VEC_ELT (oldargs, i);
5410 if (! template_args_equal (ot, nt))
5417 add_pending_template (tree d)
5419 tree ti = (TYPE_P (d)
5420 ? CLASSTYPE_TEMPLATE_INFO (d)
5421 : DECL_TEMPLATE_INFO (d));
5422 struct pending_template *pt;
5425 if (TI_PENDING_TEMPLATE_FLAG (ti))
5428 /* We are called both from instantiate_decl, where we've already had a
5429 tinst_level pushed, and instantiate_template, where we haven't.
5431 level = !current_tinst_level || current_tinst_level->decl != d;
5434 push_tinst_level (d);
5436 pt = GGC_NEW (struct pending_template);
5438 pt->tinst = current_tinst_level;
5439 if (last_pending_template)
5440 last_pending_template->next = pt;
5442 pending_templates = pt;
5444 last_pending_template = pt;
5446 TI_PENDING_TEMPLATE_FLAG (ti) = 1;
5453 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
5454 ARGLIST. Valid choices for FNS are given in the cp-tree.def
5455 documentation for TEMPLATE_ID_EXPR. */
5458 lookup_template_function (tree fns, tree arglist)
5462 if (fns == error_mark_node || arglist == error_mark_node)
5463 return error_mark_node;
5465 gcc_assert (!arglist || TREE_CODE (arglist) == TREE_VEC);
5466 gcc_assert (fns && (is_overloaded_fn (fns)
5467 || TREE_CODE (fns) == IDENTIFIER_NODE));
5469 if (BASELINK_P (fns))
5471 BASELINK_FUNCTIONS (fns) = build2 (TEMPLATE_ID_EXPR,
5473 BASELINK_FUNCTIONS (fns),
5478 type = TREE_TYPE (fns);
5479 if (TREE_CODE (fns) == OVERLOAD || !type)
5480 type = unknown_type_node;
5482 return build2 (TEMPLATE_ID_EXPR, type, fns, arglist);
5485 /* Within the scope of a template class S<T>, the name S gets bound
5486 (in build_self_reference) to a TYPE_DECL for the class, not a
5487 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
5488 or one of its enclosing classes, and that type is a template,
5489 return the associated TEMPLATE_DECL. Otherwise, the original
5490 DECL is returned. */
5493 maybe_get_template_decl_from_type_decl (tree decl)
5495 return (decl != NULL_TREE
5496 && TREE_CODE (decl) == TYPE_DECL
5497 && DECL_ARTIFICIAL (decl)
5498 && CLASS_TYPE_P (TREE_TYPE (decl))
5499 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
5500 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl;
5503 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
5504 parameters, find the desired type.
5506 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
5508 IN_DECL, if non-NULL, is the template declaration we are trying to
5511 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
5512 the class we are looking up.
5514 Issue error and warning messages under control of COMPLAIN.
5516 If the template class is really a local class in a template
5517 function, then the FUNCTION_CONTEXT is the function in which it is
5520 ??? Note that this function is currently called *twice* for each
5521 template-id: the first time from the parser, while creating the
5522 incomplete type (finish_template_type), and the second type during the
5523 real instantiation (instantiate_template_class). This is surely something
5524 that we want to avoid. It also causes some problems with argument
5525 coercion (see convert_nontype_argument for more information on this). */
5528 lookup_template_class (tree d1,
5533 tsubst_flags_t complain)
5535 tree templ = NULL_TREE, parmlist;
5538 timevar_push (TV_NAME_LOOKUP);
5540 if (TREE_CODE (d1) == IDENTIFIER_NODE)
5542 tree value = innermost_non_namespace_value (d1);
5543 if (value && DECL_TEMPLATE_TEMPLATE_PARM_P (value))
5548 push_decl_namespace (context);
5549 templ = lookup_name (d1);
5550 templ = maybe_get_template_decl_from_type_decl (templ);
5552 pop_decl_namespace ();
5555 context = DECL_CONTEXT (templ);
5557 else if (TREE_CODE (d1) == TYPE_DECL && MAYBE_CLASS_TYPE_P (TREE_TYPE (d1)))
5559 tree type = TREE_TYPE (d1);
5561 /* If we are declaring a constructor, say A<T>::A<T>, we will get
5562 an implicit typename for the second A. Deal with it. */
5563 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5564 type = TREE_TYPE (type);
5566 if (CLASSTYPE_TEMPLATE_INFO (type))
5568 templ = CLASSTYPE_TI_TEMPLATE (type);
5569 d1 = DECL_NAME (templ);
5572 else if (TREE_CODE (d1) == ENUMERAL_TYPE
5573 || (TYPE_P (d1) && MAYBE_CLASS_TYPE_P (d1)))
5575 templ = TYPE_TI_TEMPLATE (d1);
5576 d1 = DECL_NAME (templ);
5578 else if (TREE_CODE (d1) == TEMPLATE_DECL
5579 && TREE_CODE (DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL)
5582 d1 = DECL_NAME (templ);
5583 context = DECL_CONTEXT (templ);
5586 /* Issue an error message if we didn't find a template. */
5589 if (complain & tf_error)
5590 error ("%qT is not a template", d1);
5591 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5594 if (TREE_CODE (templ) != TEMPLATE_DECL
5595 /* Make sure it's a user visible template, if it was named by
5597 || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (templ)
5598 && !PRIMARY_TEMPLATE_P (templ)))
5600 if (complain & tf_error)
5602 error ("non-template type %qT used as a template", d1);
5604 error ("for template declaration %q+D", in_decl);
5606 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5609 complain &= ~tf_user;
5611 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ))
5613 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
5614 template arguments */
5620 parmlist = DECL_INNERMOST_TEMPLATE_PARMS (templ);
5622 /* Consider an example where a template template parameter declared as
5624 template <class T, class U = std::allocator<T> > class TT
5626 The template parameter level of T and U are one level larger than
5627 of TT. To proper process the default argument of U, say when an
5628 instantiation `TT<int>' is seen, we need to build the full
5629 arguments containing {int} as the innermost level. Outer levels,
5630 available when not appearing as default template argument, can be
5631 obtained from the arguments of the enclosing template.
5633 Suppose that TT is later substituted with std::vector. The above
5634 instantiation is `TT<int, std::allocator<T> >' with TT at
5635 level 1, and T at level 2, while the template arguments at level 1
5636 becomes {std::vector} and the inner level 2 is {int}. */
5638 outer = DECL_CONTEXT (templ);
5640 outer = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer)));
5641 else if (current_template_parms)
5642 /* This is an argument of the current template, so we haven't set
5643 DECL_CONTEXT yet. */
5644 outer = current_template_args ();
5647 arglist = add_to_template_args (outer, arglist);
5649 arglist2 = coerce_template_parms (parmlist, arglist, templ,
5651 /*require_all_args=*/true,
5652 /*use_default_args=*/true);
5653 if (arglist2 == error_mark_node
5654 || (!uses_template_parms (arglist2)
5655 && check_instantiated_args (templ, arglist2, complain)))
5656 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5658 parm = bind_template_template_parm (TREE_TYPE (templ), arglist2);
5659 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, parm);
5663 tree template_type = TREE_TYPE (templ);
5666 tree found = NULL_TREE;
5669 int is_partial_instantiation;
5671 gen_tmpl = most_general_template (templ);
5672 parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
5673 parm_depth = TMPL_PARMS_DEPTH (parmlist);
5674 arg_depth = TMPL_ARGS_DEPTH (arglist);
5676 if (arg_depth == 1 && parm_depth > 1)
5678 /* We've been given an incomplete set of template arguments.
5681 template <class T> struct S1 {
5682 template <class U> struct S2 {};
5683 template <class U> struct S2<U*> {};
5686 we will be called with an ARGLIST of `U*', but the
5687 TEMPLATE will be `template <class T> template
5688 <class U> struct S1<T>::S2'. We must fill in the missing
5691 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (templ)),
5693 arg_depth = TMPL_ARGS_DEPTH (arglist);
5696 /* Now we should have enough arguments. */
5697 gcc_assert (parm_depth == arg_depth);
5699 /* From here on, we're only interested in the most general
5703 /* Calculate the BOUND_ARGS. These will be the args that are
5704 actually tsubst'd into the definition to create the
5708 /* We have multiple levels of arguments to coerce, at once. */
5710 int saved_depth = TMPL_ARGS_DEPTH (arglist);
5712 tree bound_args = make_tree_vec (parm_depth);
5714 for (i = saved_depth,
5715 t = DECL_TEMPLATE_PARMS (templ);
5716 i > 0 && t != NULL_TREE;
5717 --i, t = TREE_CHAIN (t))
5719 tree a = coerce_template_parms (TREE_VALUE (t),
5722 /*require_all_args=*/true,
5723 /*use_default_args=*/true);
5725 /* Don't process further if one of the levels fails. */
5726 if (a == error_mark_node)
5728 /* Restore the ARGLIST to its full size. */
5729 TREE_VEC_LENGTH (arglist) = saved_depth;
5730 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5733 SET_TMPL_ARGS_LEVEL (bound_args, i, a);
5735 /* We temporarily reduce the length of the ARGLIST so
5736 that coerce_template_parms will see only the arguments
5737 corresponding to the template parameters it is
5739 TREE_VEC_LENGTH (arglist)--;
5742 /* Restore the ARGLIST to its full size. */
5743 TREE_VEC_LENGTH (arglist) = saved_depth;
5745 arglist = bound_args;
5749 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist),
5750 INNERMOST_TEMPLATE_ARGS (arglist),
5753 /*require_all_args=*/true,
5754 /*use_default_args=*/true);
5756 if (arglist == error_mark_node)
5757 /* We were unable to bind the arguments. */
5758 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5760 /* In the scope of a template class, explicit references to the
5761 template class refer to the type of the template, not any
5762 instantiation of it. For example, in:
5764 template <class T> class C { void f(C<T>); }
5766 the `C<T>' is just the same as `C'. Outside of the
5767 class, however, such a reference is an instantiation. */
5768 if (comp_template_args (TYPE_TI_ARGS (template_type),
5771 found = template_type;
5773 if (!entering_scope && PRIMARY_TEMPLATE_P (templ))
5777 for (ctx = current_class_type;
5778 ctx && TREE_CODE (ctx) != NAMESPACE_DECL;
5780 ? TYPE_CONTEXT (ctx)
5781 : DECL_CONTEXT (ctx)))
5782 if (TYPE_P (ctx) && same_type_p (ctx, template_type))
5785 /* We're not in the scope of the class, so the
5786 TEMPLATE_TYPE is not the type we want after all. */
5792 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
5794 /* If we already have this specialization, return it. */
5795 found = retrieve_specialization (templ, arglist,
5796 /*class_specializations_p=*/false);
5798 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
5800 /* This type is a "partial instantiation" if any of the template
5801 arguments still involve template parameters. Note that we set
5802 IS_PARTIAL_INSTANTIATION for partial specializations as
5804 is_partial_instantiation = uses_template_parms (arglist);
5806 /* If the deduced arguments are invalid, then the binding
5808 if (!is_partial_instantiation
5809 && check_instantiated_args (templ,
5810 INNERMOST_TEMPLATE_ARGS (arglist),
5812 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5814 if (!is_partial_instantiation
5815 && !PRIMARY_TEMPLATE_P (templ)
5816 && TREE_CODE (CP_DECL_CONTEXT (templ)) == NAMESPACE_DECL)
5818 found = xref_tag_from_type (TREE_TYPE (templ),
5820 /*tag_scope=*/ts_global);
5821 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
5824 context = tsubst (DECL_CONTEXT (templ), arglist,
5827 context = global_namespace;
5829 /* Create the type. */
5830 if (TREE_CODE (template_type) == ENUMERAL_TYPE)
5832 if (!is_partial_instantiation)
5834 set_current_access_from_decl (TYPE_NAME (template_type));
5835 t = start_enum (TYPE_IDENTIFIER (template_type));
5838 /* We don't want to call start_enum for this type, since
5839 the values for the enumeration constants may involve
5840 template parameters. And, no one should be interested
5841 in the enumeration constants for such a type. */
5842 t = make_node (ENUMERAL_TYPE);
5846 t = make_class_type (TREE_CODE (template_type));
5847 CLASSTYPE_DECLARED_CLASS (t)
5848 = CLASSTYPE_DECLARED_CLASS (template_type);
5849 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
5850 TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);
5852 /* A local class. Make sure the decl gets registered properly. */
5853 if (context == current_function_decl)
5854 pushtag (DECL_NAME (templ), t, /*tag_scope=*/ts_current);
5856 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type), arglist))
5857 /* This instantiation is another name for the primary
5858 template type. Set the TYPE_CANONICAL field
5860 TYPE_CANONICAL (t) = template_type;
5861 else if (any_template_arguments_need_structural_equality_p (arglist))
5862 /* Some of the template arguments require structural
5863 equality testing, so this template class requires
5864 structural equality testing. */
5865 SET_TYPE_STRUCTURAL_EQUALITY (t);
5868 /* If we called start_enum or pushtag above, this information
5869 will already be set up. */
5872 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5874 type_decl = create_implicit_typedef (DECL_NAME (templ), t);
5875 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
5876 TYPE_STUB_DECL (t) = type_decl;
5877 DECL_SOURCE_LOCATION (type_decl)
5878 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type));
5881 type_decl = TYPE_NAME (t);
5883 TREE_PRIVATE (type_decl)
5884 = TREE_PRIVATE (TYPE_STUB_DECL (template_type));
5885 TREE_PROTECTED (type_decl)
5886 = TREE_PROTECTED (TYPE_STUB_DECL (template_type));
5887 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type))
5889 DECL_VISIBILITY_SPECIFIED (type_decl) = 1;
5890 DECL_VISIBILITY (type_decl) = CLASSTYPE_VISIBILITY (template_type);
5893 /* Set up the template information. We have to figure out which
5894 template is the immediate parent if this is a full
5896 if (parm_depth == 1 || is_partial_instantiation
5897 || !PRIMARY_TEMPLATE_P (templ))
5898 /* This case is easy; there are no member templates involved. */
5902 /* This is a full instantiation of a member template. Look
5903 for a partial instantiation of which this is an instance. */
5905 for (found = DECL_TEMPLATE_INSTANTIATIONS (templ);
5906 found; found = TREE_CHAIN (found))
5909 tree tmpl = CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found));
5911 /* We only want partial instantiations, here, not
5912 specializations or full instantiations. */
5913 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found))
5914 || !uses_template_parms (TREE_VALUE (found)))
5917 /* Temporarily reduce by one the number of levels in the
5918 ARGLIST and in FOUND so as to avoid comparing the
5919 last set of arguments. */
5920 TREE_VEC_LENGTH (arglist)--;
5921 TREE_VEC_LENGTH (TREE_PURPOSE (found)) --;
5923 /* See if the arguments match. If they do, then TMPL is
5924 the partial instantiation we want. */
5925 success = comp_template_args (TREE_PURPOSE (found), arglist);
5927 /* Restore the argument vectors to their full size. */
5928 TREE_VEC_LENGTH (arglist)++;
5929 TREE_VEC_LENGTH (TREE_PURPOSE (found))++;
5940 /* There was no partial instantiation. This happens
5941 where C<T> is a member template of A<T> and it's used
5944 template <typename T> struct B { A<T>::C<int> m; };
5947 Create the partial instantiation.
5949 TREE_VEC_LENGTH (arglist)--;
5950 found = tsubst (templ, arglist, complain, NULL_TREE);
5951 TREE_VEC_LENGTH (arglist)++;
5955 SET_TYPE_TEMPLATE_INFO (t, tree_cons (found, arglist, NULL_TREE));
5956 DECL_TEMPLATE_INSTANTIATIONS (templ)
5957 = tree_cons (arglist, t,
5958 DECL_TEMPLATE_INSTANTIATIONS (templ));
5960 if (TREE_CODE (t) == ENUMERAL_TYPE
5961 && !is_partial_instantiation)
5962 /* Now that the type has been registered on the instantiations
5963 list, we set up the enumerators. Because the enumeration
5964 constants may involve the enumeration type itself, we make
5965 sure to register the type first, and then create the
5966 constants. That way, doing tsubst_expr for the enumeration
5967 constants won't result in recursive calls here; we'll find
5968 the instantiation and exit above. */
5969 tsubst_enum (template_type, t, arglist);
5971 if (is_partial_instantiation)
5972 /* If the type makes use of template parameters, the
5973 code that generates debugging information will crash. */
5974 DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1;
5976 /* Possibly limit visibility based on template args. */
5977 TREE_PUBLIC (type_decl) = 1;
5978 determine_visibility (type_decl);
5980 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
5982 timevar_pop (TV_NAME_LOOKUP);
5989 /* True when we should also visit template parameters that occur in
5990 non-deduced contexts. */
5991 bool include_nondeduced_p;
5992 struct pointer_set_t *visited;
5995 /* Called from for_each_template_parm via walk_tree. */
5998 for_each_template_parm_r (tree *tp, int *walk_subtrees, void *d)
6001 struct pair_fn_data *pfd = (struct pair_fn_data *) d;
6002 tree_fn_t fn = pfd->fn;
6003 void *data = pfd->data;
6006 && (pfd->include_nondeduced_p || TREE_CODE (t) != TYPENAME_TYPE)
6007 && for_each_template_parm (TYPE_CONTEXT (t), fn, data, pfd->visited,
6008 pfd->include_nondeduced_p))
6009 return error_mark_node;
6011 switch (TREE_CODE (t))
6014 if (TYPE_PTRMEMFUNC_P (t))
6020 if (!TYPE_TEMPLATE_INFO (t))
6022 else if (for_each_template_parm (TREE_VALUE (TYPE_TEMPLATE_INFO (t)),
6023 fn, data, pfd->visited,
6024 pfd->include_nondeduced_p))
6025 return error_mark_node;
6029 if (for_each_template_parm (TYPE_MIN_VALUE (t),
6030 fn, data, pfd->visited,
6031 pfd->include_nondeduced_p)
6032 || for_each_template_parm (TYPE_MAX_VALUE (t),
6033 fn, data, pfd->visited,
6034 pfd->include_nondeduced_p))
6035 return error_mark_node;
6039 /* Since we're not going to walk subtrees, we have to do this
6041 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data,
6042 pfd->visited, pfd->include_nondeduced_p))
6043 return error_mark_node;
6047 /* Check the return type. */
6048 if (for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited,
6049 pfd->include_nondeduced_p))
6050 return error_mark_node;
6052 /* Check the parameter types. Since default arguments are not
6053 instantiated until they are needed, the TYPE_ARG_TYPES may
6054 contain expressions that involve template parameters. But,
6055 no-one should be looking at them yet. And, once they're
6056 instantiated, they don't contain template parameters, so
6057 there's no point in looking at them then, either. */
6061 for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm))
6062 if (for_each_template_parm (TREE_VALUE (parm), fn, data,
6063 pfd->visited, pfd->include_nondeduced_p))
6064 return error_mark_node;
6066 /* Since we've already handled the TYPE_ARG_TYPES, we don't
6067 want walk_tree walking into them itself. */
6073 if (pfd->include_nondeduced_p
6074 && for_each_template_parm (TYPE_FIELDS (t), fn, data,
6076 pfd->include_nondeduced_p))
6077 return error_mark_node;
6082 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
6083 && for_each_template_parm (DECL_TI_ARGS (t), fn, data,
6084 pfd->visited, pfd->include_nondeduced_p))
6085 return error_mark_node;
6090 if (TREE_CODE (t) == CONST_DECL && DECL_TEMPLATE_PARM_P (t)
6091 && for_each_template_parm (DECL_INITIAL (t), fn, data,
6092 pfd->visited, pfd->include_nondeduced_p))
6093 return error_mark_node;
6094 if (DECL_CONTEXT (t)
6095 && pfd->include_nondeduced_p
6096 && for_each_template_parm (DECL_CONTEXT (t), fn, data,
6097 pfd->visited, pfd->include_nondeduced_p))
6098 return error_mark_node;
6101 case BOUND_TEMPLATE_TEMPLATE_PARM:
6102 /* Record template parameters such as `T' inside `TT<T>'. */
6103 if (for_each_template_parm (TYPE_TI_ARGS (t), fn, data, pfd->visited,
6104 pfd->include_nondeduced_p))
6105 return error_mark_node;
6108 case TEMPLATE_TEMPLATE_PARM:
6109 case TEMPLATE_TYPE_PARM:
6110 case TEMPLATE_PARM_INDEX:
6111 if (fn && (*fn)(t, data))
6112 return error_mark_node;
6114 return error_mark_node;
6118 /* A template template parameter is encountered. */
6119 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)
6120 && for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited,
6121 pfd->include_nondeduced_p))
6122 return error_mark_node;
6124 /* Already substituted template template parameter */
6130 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t), fn,
6132 pfd->include_nondeduced_p))
6133 return error_mark_node;
6137 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))
6138 && pfd->include_nondeduced_p
6139 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
6140 (TREE_TYPE (t)), fn, data,
6141 pfd->visited, pfd->include_nondeduced_p))
6142 return error_mark_node;
6147 /* If there's no type, then this thing must be some expression
6148 involving template parameters. */
6149 if (!fn && !TREE_TYPE (t))
6150 return error_mark_node;
6155 case REINTERPRET_CAST_EXPR:
6156 case CONST_CAST_EXPR:
6157 case STATIC_CAST_EXPR:
6158 case DYNAMIC_CAST_EXPR:
6162 case PSEUDO_DTOR_EXPR:
6164 return error_mark_node;
6171 /* We didn't find any template parameters we liked. */
6175 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
6176 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
6177 call FN with the parameter and the DATA.
6178 If FN returns nonzero, the iteration is terminated, and
6179 for_each_template_parm returns 1. Otherwise, the iteration
6180 continues. If FN never returns a nonzero value, the value
6181 returned by for_each_template_parm is 0. If FN is NULL, it is
6182 considered to be the function which always returns 1.
6184 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
6185 parameters that occur in non-deduced contexts. When false, only
6186 visits those template parameters that can be deduced. */
6189 for_each_template_parm (tree t, tree_fn_t fn, void* data,
6190 struct pointer_set_t *visited,
6191 bool include_nondeduced_p)
6193 struct pair_fn_data pfd;
6199 pfd.include_nondeduced_p = include_nondeduced_p;
6201 /* Walk the tree. (Conceptually, we would like to walk without
6202 duplicates, but for_each_template_parm_r recursively calls
6203 for_each_template_parm, so we would need to reorganize a fair
6204 bit to use walk_tree_without_duplicates, so we keep our own
6207 pfd.visited = visited;
6209 pfd.visited = pointer_set_create ();
6210 result = cp_walk_tree (&t,
6211 for_each_template_parm_r,
6213 pfd.visited) != NULL_TREE;
6218 pointer_set_destroy (pfd.visited);
6225 /* Returns true if T depends on any template parameter. */
6228 uses_template_parms (tree t)
6231 int saved_processing_template_decl;
6233 saved_processing_template_decl = processing_template_decl;
6234 if (!saved_processing_template_decl)
6235 processing_template_decl = 1;
6237 dependent_p = dependent_type_p (t);
6238 else if (TREE_CODE (t) == TREE_VEC)
6239 dependent_p = any_dependent_template_arguments_p (t);
6240 else if (TREE_CODE (t) == TREE_LIST)
6241 dependent_p = (uses_template_parms (TREE_VALUE (t))
6242 || uses_template_parms (TREE_CHAIN (t)));
6243 else if (TREE_CODE (t) == TYPE_DECL)
6244 dependent_p = dependent_type_p (TREE_TYPE (t));
6247 || TREE_CODE (t) == TEMPLATE_PARM_INDEX
6248 || TREE_CODE (t) == OVERLOAD
6249 || TREE_CODE (t) == BASELINK
6250 || TREE_CODE (t) == IDENTIFIER_NODE
6251 || TREE_CODE (t) == TRAIT_EXPR
6252 || CONSTANT_CLASS_P (t))
6253 dependent_p = (type_dependent_expression_p (t)
6254 || value_dependent_expression_p (t));
6257 gcc_assert (t == error_mark_node);
6258 dependent_p = false;
6261 processing_template_decl = saved_processing_template_decl;
6266 /* Returns true if T depends on any template parameter with level LEVEL. */
6269 uses_template_parms_level (tree t, int level)
6271 return for_each_template_parm (t, template_parm_this_level_p, &level, NULL,
6272 /*include_nondeduced_p=*/true);
6275 static int tinst_depth;
6276 extern int max_tinst_depth;
6277 #ifdef GATHER_STATISTICS
6280 static int tinst_level_tick;
6281 static int last_template_error_tick;
6283 /* We're starting to instantiate D; record the template instantiation context
6284 for diagnostics and to restore it later. */
6287 push_tinst_level (tree d)
6289 struct tinst_level *new_level;
6291 if (tinst_depth >= max_tinst_depth)
6293 /* If the instantiation in question still has unbound template parms,
6294 we don't really care if we can't instantiate it, so just return.
6295 This happens with base instantiation for implicit `typename'. */
6296 if (uses_template_parms (d))
6299 last_template_error_tick = tinst_level_tick;
6300 error ("template instantiation depth exceeds maximum of %d (use "
6301 "-ftemplate-depth-NN to increase the maximum) instantiating %qD",
6302 max_tinst_depth, d);
6304 print_instantiation_context ();
6309 new_level = GGC_NEW (struct tinst_level);
6310 new_level->decl = d;
6311 new_level->locus = input_location;
6312 new_level->in_system_header_p = in_system_header;
6313 new_level->next = current_tinst_level;
6314 current_tinst_level = new_level;
6317 #ifdef GATHER_STATISTICS
6318 if (tinst_depth > depth_reached)
6319 depth_reached = tinst_depth;
6326 /* We're done instantiating this template; return to the instantiation
6330 pop_tinst_level (void)
6332 /* Restore the filename and line number stashed away when we started
6333 this instantiation. */
6334 input_location = current_tinst_level->locus;
6335 current_tinst_level = current_tinst_level->next;
6340 /* We're instantiating a deferred template; restore the template
6341 instantiation context in which the instantiation was requested, which
6342 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
6345 reopen_tinst_level (struct tinst_level *level)
6347 struct tinst_level *t;
6350 for (t = level; t; t = t->next)
6353 current_tinst_level = level;
6358 /* Returns the TINST_LEVEL which gives the original instantiation
6361 struct tinst_level *
6362 outermost_tinst_level (void)
6364 struct tinst_level *level = current_tinst_level;
6367 level = level->next;
6371 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
6372 vector of template arguments, as for tsubst.
6374 Returns an appropriate tsubst'd friend declaration. */
6377 tsubst_friend_function (tree decl, tree args)
6381 if (TREE_CODE (decl) == FUNCTION_DECL
6382 && DECL_TEMPLATE_INSTANTIATION (decl)
6383 && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
6384 /* This was a friend declared with an explicit template
6385 argument list, e.g.:
6389 to indicate that f was a template instantiation, not a new
6390 function declaration. Now, we have to figure out what
6391 instantiation of what template. */
6393 tree template_id, arglist, fns;
6396 tree ns = decl_namespace_context (TYPE_MAIN_DECL (current_class_type));
6398 /* Friend functions are looked up in the containing namespace scope.
6399 We must enter that scope, to avoid finding member functions of the
6400 current class with same name. */
6401 push_nested_namespace (ns);
6402 fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args,
6403 tf_warning_or_error, NULL_TREE,
6404 /*integral_constant_expression_p=*/false);
6405 pop_nested_namespace (ns);
6406 arglist = tsubst (DECL_TI_ARGS (decl), args,
6407 tf_warning_or_error, NULL_TREE);
6408 template_id = lookup_template_function (fns, arglist);
6410 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
6411 tmpl = determine_specialization (template_id, new_friend,
6413 /*need_member_template=*/0,
6414 TREE_VEC_LENGTH (args),
6416 return instantiate_template (tmpl, new_args, tf_error);
6419 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
6421 /* The NEW_FRIEND will look like an instantiation, to the
6422 compiler, but is not an instantiation from the point of view of
6423 the language. For example, we might have had:
6425 template <class T> struct S {
6426 template <class U> friend void f(T, U);
6429 Then, in S<int>, template <class U> void f(int, U) is not an
6430 instantiation of anything. */
6431 if (new_friend == error_mark_node)
6432 return error_mark_node;
6434 DECL_USE_TEMPLATE (new_friend) = 0;
6435 if (TREE_CODE (decl) == TEMPLATE_DECL)
6437 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0;
6438 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend))
6439 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
6442 /* The mangled name for the NEW_FRIEND is incorrect. The function
6443 is not a template instantiation and should not be mangled like
6444 one. Therefore, we forget the mangling here; we'll recompute it
6445 later if we need it. */
6446 if (TREE_CODE (new_friend) != TEMPLATE_DECL)
6448 SET_DECL_RTL (new_friend, NULL_RTX);
6449 SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE);
6452 if (DECL_NAMESPACE_SCOPE_P (new_friend))
6455 tree new_friend_template_info;
6456 tree new_friend_result_template_info;
6458 int new_friend_is_defn;
6460 /* We must save some information from NEW_FRIEND before calling
6461 duplicate decls since that function will free NEW_FRIEND if
6463 new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
6464 new_friend_is_defn =
6465 (DECL_INITIAL (DECL_TEMPLATE_RESULT
6466 (template_for_substitution (new_friend)))
6468 if (TREE_CODE (new_friend) == TEMPLATE_DECL)
6470 /* This declaration is a `primary' template. */
6471 DECL_PRIMARY_TEMPLATE (new_friend) = new_friend;
6473 new_friend_result_template_info
6474 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend));
6477 new_friend_result_template_info = NULL_TREE;
6479 /* Make the init_value nonzero so pushdecl knows this is a defn. */
6480 if (new_friend_is_defn)
6481 DECL_INITIAL (new_friend) = error_mark_node;
6483 /* Inside pushdecl_namespace_level, we will push into the
6484 current namespace. However, the friend function should go
6485 into the namespace of the template. */
6486 ns = decl_namespace_context (new_friend);
6487 push_nested_namespace (ns);
6488 old_decl = pushdecl_namespace_level (new_friend, /*is_friend=*/true);
6489 pop_nested_namespace (ns);
6491 if (old_decl == error_mark_node)
6492 return error_mark_node;
6494 if (old_decl != new_friend)
6496 /* This new friend declaration matched an existing
6497 declaration. For example, given:
6499 template <class T> void f(T);
6500 template <class U> class C {
6501 template <class T> friend void f(T) {}
6504 the friend declaration actually provides the definition
6505 of `f', once C has been instantiated for some type. So,
6506 old_decl will be the out-of-class template declaration,
6507 while new_friend is the in-class definition.
6509 But, if `f' was called before this point, the
6510 instantiation of `f' will have DECL_TI_ARGS corresponding
6511 to `T' but not to `U', references to which might appear
6512 in the definition of `f'. Previously, the most general
6513 template for an instantiation of `f' was the out-of-class
6514 version; now it is the in-class version. Therefore, we
6515 run through all specialization of `f', adding to their
6516 DECL_TI_ARGS appropriately. In particular, they need a
6517 new set of outer arguments, corresponding to the
6518 arguments for this class instantiation.
6520 The same situation can arise with something like this:
6523 template <class T> class C {
6527 when `C<int>' is instantiated. Now, `f(int)' is defined
6530 if (!new_friend_is_defn)
6531 /* On the other hand, if the in-class declaration does
6532 *not* provide a definition, then we don't want to alter
6533 existing definitions. We can just leave everything
6538 /* Overwrite whatever template info was there before, if
6539 any, with the new template information pertaining to
6541 DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
6543 if (TREE_CODE (old_decl) != TEMPLATE_DECL)
6544 reregister_specialization (new_friend,
6545 most_general_template (old_decl),
6550 tree new_friend_args;
6552 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl))
6553 = new_friend_result_template_info;
6555 new_friend_args = TI_ARGS (new_friend_template_info);
6556 for (t = DECL_TEMPLATE_SPECIALIZATIONS (old_decl);
6560 tree spec = TREE_VALUE (t);
6563 = add_outermost_template_args (new_friend_args,
6564 DECL_TI_ARGS (spec));
6567 /* Now, since specializations are always supposed to
6568 hang off of the most general template, we must move
6570 t = most_general_template (old_decl);
6573 DECL_TEMPLATE_SPECIALIZATIONS (t)
6574 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t),
6575 DECL_TEMPLATE_SPECIALIZATIONS (old_decl));
6576 DECL_TEMPLATE_SPECIALIZATIONS (old_decl) = NULL_TREE;
6581 /* The information from NEW_FRIEND has been merged into OLD_DECL
6582 by duplicate_decls. */
6583 new_friend = old_decl;
6588 tree context = DECL_CONTEXT (new_friend);
6592 template <class T> class C {
6593 template <class U> friend void C1<U>::f (); // case 1
6594 friend void C2<T>::f (); // case 2
6596 we only need to make sure CONTEXT is a complete type for
6597 case 2. To distinguish between the two cases, we note that
6598 CONTEXT of case 1 remains dependent type after tsubst while
6599 this isn't true for case 2. */
6600 ++processing_template_decl;
6601 dependent_p = dependent_type_p (context);
6602 --processing_template_decl;
6605 && !complete_type_or_else (context, NULL_TREE))
6606 return error_mark_node;
6608 if (COMPLETE_TYPE_P (context))
6610 /* Check to see that the declaration is really present, and,
6611 possibly obtain an improved declaration. */
6612 tree fn = check_classfn (context,
6613 new_friend, NULL_TREE);
6623 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
6624 template arguments, as for tsubst.
6626 Returns an appropriate tsubst'd friend type or error_mark_node on
6630 tsubst_friend_class (tree friend_tmpl, tree args)
6636 context = DECL_CONTEXT (friend_tmpl);
6640 if (TREE_CODE (context) == NAMESPACE_DECL)
6641 push_nested_namespace (context);
6643 push_nested_class (tsubst (context, args, tf_none, NULL_TREE));
6646 /* Look for a class template declaration. We look for hidden names
6647 because two friend declarations of the same template are the
6648 same. For example, in:
6651 template <typename> friend class F;
6653 template <typename> struct B {
6654 template <typename> friend class F;
6657 both F templates are the same. */
6658 tmpl = lookup_name_real (DECL_NAME (friend_tmpl), 0, 0,
6659 /*block_p=*/true, 0,
6660 LOOKUP_COMPLAIN | LOOKUP_HIDDEN);
6662 /* But, if we don't find one, it might be because we're in a
6663 situation like this:
6671 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
6672 for `S<int>', not the TEMPLATE_DECL. */
6673 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
6675 tmpl = lookup_name_prefer_type (DECL_NAME (friend_tmpl), 1);
6676 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
6679 if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
6681 /* The friend template has already been declared. Just
6682 check to see that the declarations match, and install any new
6683 default parameters. We must tsubst the default parameters,
6684 of course. We only need the innermost template parameters
6685 because that is all that redeclare_class_template will look
6687 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl))
6688 > TMPL_ARGS_DEPTH (args))
6691 location_t saved_input_location;
6692 parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
6693 args, tf_warning_or_error);
6695 saved_input_location = input_location;
6696 input_location = DECL_SOURCE_LOCATION (friend_tmpl);
6697 redeclare_class_template (TREE_TYPE (tmpl), parms);
6698 input_location = saved_input_location;
6702 friend_type = TREE_TYPE (tmpl);
6706 /* The friend template has not already been declared. In this
6707 case, the instantiation of the template class will cause the
6708 injection of this template into the global scope. */
6709 tmpl = tsubst (friend_tmpl, args, tf_warning_or_error, NULL_TREE);
6710 if (tmpl == error_mark_node)
6711 return error_mark_node;
6713 /* The new TMPL is not an instantiation of anything, so we
6714 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
6715 the new type because that is supposed to be the corresponding
6716 template decl, i.e., TMPL. */
6717 DECL_USE_TEMPLATE (tmpl) = 0;
6718 DECL_TEMPLATE_INFO (tmpl) = NULL_TREE;
6719 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0;
6720 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl))
6721 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)));
6723 /* Inject this template into the global scope. */
6724 friend_type = TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl, true));
6729 if (TREE_CODE (context) == NAMESPACE_DECL)
6730 pop_nested_namespace (context);
6732 pop_nested_class ();
6738 /* Returns zero if TYPE cannot be completed later due to circularity.
6739 Otherwise returns one. */
6742 can_complete_type_without_circularity (tree type)
6744 if (type == NULL_TREE || type == error_mark_node)
6746 else if (COMPLETE_TYPE_P (type))
6748 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
6749 return can_complete_type_without_circularity (TREE_TYPE (type));
6750 else if (CLASS_TYPE_P (type)
6751 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type)))
6757 /* Apply any attributes which had to be deferred until instantiation
6758 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
6759 ARGS, COMPLAIN, IN_DECL are as tsubst. */
6762 apply_late_template_attributes (tree *decl_p, tree attributes, int attr_flags,
6763 tree args, tsubst_flags_t complain, tree in_decl)
6765 tree last_dep = NULL_TREE;
6769 for (t = attributes; t; t = TREE_CHAIN (t))
6770 if (ATTR_IS_DEPENDENT (t))
6773 attributes = copy_list (attributes);
6777 if (DECL_P (*decl_p))
6779 if (TREE_TYPE (*decl_p) == error_mark_node)
6781 p = &DECL_ATTRIBUTES (*decl_p);
6784 p = &TYPE_ATTRIBUTES (*decl_p);
6788 tree late_attrs = NULL_TREE;
6789 tree *q = &late_attrs;
6791 for (*p = attributes; *p; )
6794 if (ATTR_IS_DEPENDENT (t))
6796 *p = TREE_CHAIN (t);
6797 TREE_CHAIN (t) = NULL_TREE;
6798 /* If the first attribute argument is an identifier, don't
6799 pass it through tsubst. Attributes like mode, format,
6800 cleanup and several target specific attributes expect it
6803 && TREE_CODE (TREE_VALUE (t)) == TREE_LIST
6804 && TREE_VALUE (TREE_VALUE (t))
6805 && (TREE_CODE (TREE_VALUE (TREE_VALUE (t)))
6806 == IDENTIFIER_NODE))
6809 = tsubst_expr (TREE_CHAIN (TREE_VALUE (t)), args, complain,
6811 /*integral_constant_expression_p=*/false);
6812 if (chain != TREE_CHAIN (TREE_VALUE (t)))
6814 = tree_cons (NULL_TREE, TREE_VALUE (TREE_VALUE (t)),
6819 = tsubst_expr (TREE_VALUE (t), args, complain, in_decl,
6820 /*integral_constant_expression_p=*/false);
6822 q = &TREE_CHAIN (t);
6825 p = &TREE_CHAIN (t);
6828 cplus_decl_attributes (decl_p, late_attrs, attr_flags);
6833 instantiate_class_template (tree type)
6835 tree templ, args, pattern, t, member;
6840 if (type == error_mark_node)
6841 return error_mark_node;
6843 if (TYPE_BEING_DEFINED (type)
6844 || COMPLETE_TYPE_P (type)
6845 || dependent_type_p (type))
6848 /* Figure out which template is being instantiated. */
6849 templ = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
6850 gcc_assert (TREE_CODE (templ) == TEMPLATE_DECL);
6852 /* Determine what specialization of the original template to
6854 t = most_specialized_class (type, templ);
6855 if (t == error_mark_node)
6857 TYPE_BEING_DEFINED (type) = 1;
6858 return error_mark_node;
6862 /* This TYPE is actually an instantiation of a partial
6863 specialization. We replace the innermost set of ARGS with
6864 the arguments appropriate for substitution. For example,
6867 template <class T> struct S {};
6868 template <class T> struct S<T*> {};
6870 and supposing that we are instantiating S<int*>, ARGS will
6871 presently be {int*} -- but we need {int}. */
6872 pattern = TREE_TYPE (t);
6873 args = TREE_PURPOSE (t);
6877 pattern = TREE_TYPE (templ);
6878 args = CLASSTYPE_TI_ARGS (type);
6881 /* If the template we're instantiating is incomplete, then clearly
6882 there's nothing we can do. */
6883 if (!COMPLETE_TYPE_P (pattern))
6886 /* If we've recursively instantiated too many templates, stop. */
6887 if (! push_tinst_level (type))
6890 /* Now we're really doing the instantiation. Mark the type as in
6891 the process of being defined. */
6892 TYPE_BEING_DEFINED (type) = 1;
6894 /* We may be in the middle of deferred access check. Disable
6896 push_deferring_access_checks (dk_no_deferred);
6898 push_to_top_level ();
6900 SET_CLASSTYPE_INTERFACE_UNKNOWN (type);
6902 /* Set the input location to the template definition. This is needed
6903 if tsubsting causes an error. */
6904 typedecl = TYPE_MAIN_DECL (type);
6905 input_location = DECL_SOURCE_LOCATION (typedecl);
6907 TYPE_HAS_USER_CONSTRUCTOR (type) = TYPE_HAS_USER_CONSTRUCTOR (pattern);
6908 TYPE_HAS_NEW_OPERATOR (type) = TYPE_HAS_NEW_OPERATOR (pattern);
6909 TYPE_HAS_ARRAY_NEW_OPERATOR (type) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern);
6910 TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern);
6911 TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern);
6912 TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern);
6913 TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern);
6914 TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern);
6915 TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern);
6916 TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern);
6917 TYPE_PACKED (type) = TYPE_PACKED (pattern);
6918 TYPE_ALIGN (type) = TYPE_ALIGN (pattern);
6919 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);
6920 TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */
6921 if (ANON_AGGR_TYPE_P (pattern))
6922 SET_ANON_AGGR_TYPE_P (type);
6923 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern))
6925 CLASSTYPE_VISIBILITY_SPECIFIED (type) = 1;
6926 CLASSTYPE_VISIBILITY (type) = CLASSTYPE_VISIBILITY (pattern);
6929 pbinfo = TYPE_BINFO (pattern);
6931 /* We should never instantiate a nested class before its enclosing
6932 class; we need to look up the nested class by name before we can
6933 instantiate it, and that lookup should instantiate the enclosing
6935 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))
6936 || COMPLETE_TYPE_P (TYPE_CONTEXT (type))
6937 || TYPE_BEING_DEFINED (TYPE_CONTEXT (type)));
6939 base_list = NULL_TREE;
6940 if (BINFO_N_BASE_BINFOS (pbinfo))
6943 tree context = TYPE_CONTEXT (type);
6947 /* We must enter the scope containing the type, as that is where
6948 the accessibility of types named in dependent bases are
6950 pushed_scope = push_scope (context ? context : global_namespace);
6952 /* Substitute into each of the bases to determine the actual
6954 for (i = 0; BINFO_BASE_ITERATE (pbinfo, i, pbase_binfo); i++)
6957 tree access = BINFO_BASE_ACCESS (pbinfo, i);
6958 tree expanded_bases = NULL_TREE;
6961 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo)))
6964 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo),
6965 args, tf_error, NULL_TREE);
6966 if (expanded_bases == error_mark_node)
6969 len = TREE_VEC_LENGTH (expanded_bases);
6972 for (idx = 0; idx < len; idx++)
6975 /* Extract the already-expanded base class. */
6976 base = TREE_VEC_ELT (expanded_bases, idx);
6978 /* Substitute to figure out the base class. */
6979 base = tsubst (BINFO_TYPE (pbase_binfo), args, tf_error,
6982 if (base == error_mark_node)
6985 base_list = tree_cons (access, base, base_list);
6986 if (BINFO_VIRTUAL_P (pbase_binfo))
6987 TREE_TYPE (base_list) = integer_type_node;
6991 /* The list is now in reverse order; correct that. */
6992 base_list = nreverse (base_list);
6995 pop_scope (pushed_scope);
6997 /* Now call xref_basetypes to set up all the base-class
6999 xref_basetypes (type, base_list);
7001 apply_late_template_attributes (&type, TYPE_ATTRIBUTES (pattern),
7002 (int) ATTR_FLAG_TYPE_IN_PLACE,
7003 args, tf_error, NULL_TREE);
7005 /* Now that our base classes are set up, enter the scope of the
7006 class, so that name lookups into base classes, etc. will work
7007 correctly. This is precisely analogous to what we do in
7008 begin_class_definition when defining an ordinary non-template
7009 class, except we also need to push the enclosing classes. */
7010 push_nested_class (type);
7012 /* Now members are processed in the order of declaration. */
7013 for (member = CLASSTYPE_DECL_LIST (pattern);
7014 member; member = TREE_CHAIN (member))
7016 tree t = TREE_VALUE (member);
7018 if (TREE_PURPOSE (member))
7022 /* Build new CLASSTYPE_NESTED_UTDS. */
7025 bool class_template_p;
7027 class_template_p = (TREE_CODE (t) != ENUMERAL_TYPE
7028 && TYPE_LANG_SPECIFIC (t)
7029 && CLASSTYPE_IS_TEMPLATE (t));
7030 /* If the member is a class template, then -- even after
7031 substitution -- there may be dependent types in the
7032 template argument list for the class. We increment
7033 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
7034 that function will assume that no types are dependent
7035 when outside of a template. */
7036 if (class_template_p)
7037 ++processing_template_decl;
7038 newtag = tsubst (t, args, tf_error, NULL_TREE);
7039 if (class_template_p)
7040 --processing_template_decl;
7041 if (newtag == error_mark_node)
7044 if (TREE_CODE (newtag) != ENUMERAL_TYPE)
7046 tree name = TYPE_IDENTIFIER (t);
7048 if (class_template_p)
7049 /* Unfortunately, lookup_template_class sets
7050 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
7051 instantiation (i.e., for the type of a member
7052 template class nested within a template class.)
7053 This behavior is required for
7054 maybe_process_partial_specialization to work
7055 correctly, but is not accurate in this case;
7056 the TAG is not an instantiation of anything.
7057 (The corresponding TEMPLATE_DECL is an
7058 instantiation, but the TYPE is not.) */
7059 CLASSTYPE_USE_TEMPLATE (newtag) = 0;
7061 /* Now, we call pushtag to put this NEWTAG into the scope of
7062 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
7063 pushtag calling push_template_decl. We don't have to do
7064 this for enums because it will already have been done in
7067 SET_IDENTIFIER_TYPE_VALUE (name, newtag);
7068 pushtag (name, newtag, /*tag_scope=*/ts_current);
7071 else if (TREE_CODE (t) == FUNCTION_DECL
7072 || DECL_FUNCTION_TEMPLATE_P (t))
7074 /* Build new TYPE_METHODS. */
7077 if (TREE_CODE (t) == TEMPLATE_DECL)
7078 ++processing_template_decl;
7079 r = tsubst (t, args, tf_error, NULL_TREE);
7080 if (TREE_CODE (t) == TEMPLATE_DECL)
7081 --processing_template_decl;
7082 set_current_access_from_decl (r);
7083 finish_member_declaration (r);
7087 /* Build new TYPE_FIELDS. */
7088 if (TREE_CODE (t) == STATIC_ASSERT)
7091 tsubst_expr (STATIC_ASSERT_CONDITION (t), args,
7092 tf_warning_or_error, NULL_TREE,
7093 /*integral_constant_expression_p=*/true);
7094 finish_static_assert (condition,
7095 STATIC_ASSERT_MESSAGE (t),
7096 STATIC_ASSERT_SOURCE_LOCATION (t),
7099 else if (TREE_CODE (t) != CONST_DECL)
7103 /* The file and line for this declaration, to
7104 assist in error message reporting. Since we
7105 called push_tinst_level above, we don't need to
7107 input_location = DECL_SOURCE_LOCATION (t);
7109 if (TREE_CODE (t) == TEMPLATE_DECL)
7110 ++processing_template_decl;
7111 r = tsubst (t, args, tf_warning_or_error, NULL_TREE);
7112 if (TREE_CODE (t) == TEMPLATE_DECL)
7113 --processing_template_decl;
7114 if (TREE_CODE (r) == VAR_DECL)
7118 [t]he initialization (and any associated
7119 side-effects) of a static data member does
7120 not occur unless the static data member is
7121 itself used in a way that requires the
7122 definition of the static data member to
7125 Therefore, we do not substitute into the
7126 initialized for the static data member here. */
7127 finish_static_data_member_decl
7130 /*init_const_expr_p=*/false,
7131 /*asmspec_tree=*/NULL_TREE,
7133 if (DECL_INITIALIZED_IN_CLASS_P (r))
7134 check_static_variable_definition (r, TREE_TYPE (r));
7136 else if (TREE_CODE (r) == FIELD_DECL)
7138 /* Determine whether R has a valid type and can be
7139 completed later. If R is invalid, then it is
7140 replaced by error_mark_node so that it will not be
7141 added to TYPE_FIELDS. */
7142 tree rtype = TREE_TYPE (r);
7143 if (can_complete_type_without_circularity (rtype))
7144 complete_type (rtype);
7146 if (!COMPLETE_TYPE_P (rtype))
7148 cxx_incomplete_type_error (r, rtype);
7149 r = error_mark_node;
7153 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
7154 such a thing will already have been added to the field
7155 list by tsubst_enum in finish_member_declaration in the
7156 CLASSTYPE_NESTED_UTDS case above. */
7157 if (!(TREE_CODE (r) == TYPE_DECL
7158 && TREE_CODE (TREE_TYPE (r)) == ENUMERAL_TYPE
7159 && DECL_ARTIFICIAL (r)))
7161 set_current_access_from_decl (r);
7162 finish_member_declaration (r);
7169 if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t))
7171 /* Build new CLASSTYPE_FRIEND_CLASSES. */
7173 tree friend_type = t;
7174 bool adjust_processing_template_decl = false;
7176 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
7178 /* template <class T> friend class C; */
7179 friend_type = tsubst_friend_class (friend_type, args);
7180 adjust_processing_template_decl = true;
7182 else if (TREE_CODE (friend_type) == UNBOUND_CLASS_TEMPLATE)
7184 /* template <class T> friend class C::D; */
7185 friend_type = tsubst (friend_type, args,
7186 tf_warning_or_error, NULL_TREE);
7187 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
7188 friend_type = TREE_TYPE (friend_type);
7189 adjust_processing_template_decl = true;
7191 else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
7193 /* This could be either
7197 when dependent_type_p is false or
7199 template <class U> friend class T::C;
7202 friend_type = tsubst (friend_type, args,
7203 tf_warning_or_error, NULL_TREE);
7204 /* Bump processing_template_decl for correct
7205 dependent_type_p calculation. */
7206 ++processing_template_decl;
7207 if (dependent_type_p (friend_type))
7208 adjust_processing_template_decl = true;
7209 --processing_template_decl;
7211 else if (!CLASSTYPE_USE_TEMPLATE (friend_type)
7212 && hidden_name_p (TYPE_NAME (friend_type)))
7216 where C hasn't been declared yet. Let's lookup name
7217 from namespace scope directly, bypassing any name that
7218 come from dependent base class. */
7219 tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type));
7221 /* The call to xref_tag_from_type does injection for friend
7223 push_nested_namespace (ns);
7225 xref_tag_from_type (friend_type, NULL_TREE,
7226 /*tag_scope=*/ts_current);
7227 pop_nested_namespace (ns);
7229 else if (uses_template_parms (friend_type))
7230 /* friend class C<T>; */
7231 friend_type = tsubst (friend_type, args,
7232 tf_warning_or_error, NULL_TREE);
7237 where C is already declared or
7239 friend class C<int>;
7241 We don't have to do anything in these cases. */
7243 if (adjust_processing_template_decl)
7244 /* Trick make_friend_class into realizing that the friend
7245 we're adding is a template, not an ordinary class. It's
7246 important that we use make_friend_class since it will
7247 perform some error-checking and output cross-reference
7249 ++processing_template_decl;
7251 if (friend_type != error_mark_node)
7252 make_friend_class (type, friend_type, /*complain=*/false);
7254 if (adjust_processing_template_decl)
7255 --processing_template_decl;
7259 /* Build new DECL_FRIENDLIST. */
7262 /* The file and line for this declaration, to
7263 assist in error message reporting. Since we
7264 called push_tinst_level above, we don't need to
7266 input_location = DECL_SOURCE_LOCATION (t);
7268 if (TREE_CODE (t) == TEMPLATE_DECL)
7270 ++processing_template_decl;
7271 push_deferring_access_checks (dk_no_check);
7274 r = tsubst_friend_function (t, args);
7275 add_friend (type, r, /*complain=*/false);
7276 if (TREE_CODE (t) == TEMPLATE_DECL)
7278 pop_deferring_access_checks ();
7279 --processing_template_decl;
7285 /* Set the file and line number information to whatever is given for
7286 the class itself. This puts error messages involving generated
7287 implicit functions at a predictable point, and the same point
7288 that would be used for non-template classes. */
7289 input_location = DECL_SOURCE_LOCATION (typedecl);
7291 unreverse_member_declarations (type);
7292 finish_struct_1 (type);
7293 TYPE_BEING_DEFINED (type) = 0;
7295 /* Now that the class is complete, instantiate default arguments for
7296 any member functions. We don't do this earlier because the
7297 default arguments may reference members of the class. */
7298 if (!PRIMARY_TEMPLATE_P (templ))
7299 for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t))
7300 if (TREE_CODE (t) == FUNCTION_DECL
7301 /* Implicitly generated member functions will not have template
7302 information; they are not instantiations, but instead are
7303 created "fresh" for each instantiation. */
7304 && DECL_TEMPLATE_INFO (t))
7305 tsubst_default_arguments (t);
7307 pop_nested_class ();
7308 pop_from_top_level ();
7309 pop_deferring_access_checks ();
7312 /* The vtable for a template class can be emitted in any translation
7313 unit in which the class is instantiated. When there is no key
7314 method, however, finish_struct_1 will already have added TYPE to
7315 the keyed_classes list. */
7316 if (TYPE_CONTAINS_VPTR_P (type) && CLASSTYPE_KEY_METHOD (type))
7317 keyed_classes = tree_cons (NULL_TREE, type, keyed_classes);
7323 tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl)
7329 else if (TYPE_P (t))
7330 r = tsubst (t, args, complain, in_decl);
7333 r = tsubst_expr (t, args, complain, in_decl,
7334 /*integral_constant_expression_p=*/true);
7335 r = fold_non_dependent_expr (r);
7340 /* Substitute ARGS into T, which is an pack expansion
7341 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
7342 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
7343 (if only a partial substitution could be performed) or
7344 ERROR_MARK_NODE if there was an error. */
7346 tsubst_pack_expansion (tree t, tree args, tsubst_flags_t complain,
7350 tree pack, packs = NULL_TREE, unsubstituted_packs = NULL_TREE;
7351 tree first_arg_pack; int i, len = -1;
7355 gcc_assert (PACK_EXPANSION_P (t));
7356 pattern = PACK_EXPANSION_PATTERN (t);
7358 /* Determine the argument packs that will instantiate the parameter
7359 packs used in the expansion expression. While we're at it,
7360 compute the number of arguments to be expanded and make sure it
7362 for (pack = PACK_EXPANSION_PARAMETER_PACKS (t); pack;
7363 pack = TREE_CHAIN (pack))
7365 tree parm_pack = TREE_VALUE (pack);
7366 tree arg_pack = NULL_TREE;
7367 tree orig_arg = NULL_TREE;
7369 if (TREE_CODE (parm_pack) == PARM_DECL)
7370 arg_pack = retrieve_local_specialization (parm_pack);
7373 int level, idx, levels;
7374 template_parm_level_and_index (parm_pack, &level, &idx);
7376 levels = TMPL_ARGS_DEPTH (args);
7377 if (level <= levels)
7378 arg_pack = TMPL_ARG (args, level, idx);
7381 orig_arg = arg_pack;
7382 if (arg_pack && TREE_CODE (arg_pack) == ARGUMENT_PACK_SELECT)
7383 arg_pack = ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack);
7385 if (arg_pack && !ARGUMENT_PACK_P (arg_pack))
7386 /* This can only happen if we forget to expand an argument
7387 pack somewhere else. Just return an error, silently. */
7389 result = make_tree_vec (1);
7390 TREE_VEC_ELT (result, 0) = error_mark_node;
7395 && TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack)) == 1
7396 && PACK_EXPANSION_P (TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg_pack), 0)))
7398 tree expansion = TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg_pack), 0);
7399 tree pattern = PACK_EXPANSION_PATTERN (expansion);
7400 if ((TYPE_P (pattern) && same_type_p (pattern, parm_pack))
7401 || (!TYPE_P (pattern) && cp_tree_equal (parm_pack, pattern)))
7402 /* The argument pack that the parameter maps to is just an
7403 expansion of the parameter itself, such as one would
7404 find in the implicit typedef of a class inside the
7405 class itself. Consider this parameter "unsubstituted",
7406 so that we will maintain the outer pack expansion. */
7407 arg_pack = NULL_TREE;
7413 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack));
7415 /* It's all-or-nothing with incomplete argument packs. */
7416 if (incomplete && !ARGUMENT_PACK_INCOMPLETE_P (arg_pack))
7417 return error_mark_node;
7419 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack))
7425 first_arg_pack = arg_pack;
7427 else if (len != my_len)
7429 if (TREE_CODE (t) == TYPE_PACK_EXPANSION)
7430 error ("mismatched argument pack lengths while expanding "
7434 error ("mismatched argument pack lengths while expanding "
7437 return error_mark_node;
7440 /* Keep track of the parameter packs and their corresponding
7442 packs = tree_cons (parm_pack, arg_pack, packs);
7443 TREE_TYPE (packs) = orig_arg;
7446 /* We can't substitute for this parameter pack. */
7447 unsubstituted_packs = tree_cons (TREE_PURPOSE (pack),
7449 unsubstituted_packs);
7452 /* We cannot expand this expansion expression, because we don't have
7453 all of the argument packs we need. Substitute into the pattern
7454 and return a PACK_EXPANSION_*. The caller will need to deal with
7456 if (unsubstituted_packs)
7457 return make_pack_expansion (tsubst (pattern, args, complain,
7460 /* We could not find any argument packs that work. */
7462 return error_mark_node;
7464 /* For each argument in each argument pack, substitute into the
7466 result = make_tree_vec (len + incomplete);
7467 for (i = 0; i < len + incomplete; ++i)
7469 /* For parameter pack, change the substitution of the parameter
7470 pack to the ith argument in its argument pack, then expand
7472 for (pack = packs; pack; pack = TREE_CHAIN (pack))
7474 tree parm = TREE_PURPOSE (pack);
7476 if (TREE_CODE (parm) == PARM_DECL)
7478 /* Select the Ith argument from the pack. */
7479 tree arg = make_node (ARGUMENT_PACK_SELECT);
7480 ARGUMENT_PACK_SELECT_FROM_PACK (arg) = TREE_VALUE (pack);
7481 ARGUMENT_PACK_SELECT_INDEX (arg) = i;
7483 register_local_specialization (arg, parm);
7489 template_parm_level_and_index (parm, &level, &idx);
7493 /* Select the Ith argument from the pack. */
7494 value = make_node (ARGUMENT_PACK_SELECT);
7495 ARGUMENT_PACK_SELECT_FROM_PACK (value) = TREE_VALUE (pack);
7496 ARGUMENT_PACK_SELECT_INDEX (value) = i;
7499 /* Update the corresponding argument. */
7500 TMPL_ARG (args, level, idx) = value;
7504 /* Substitute into the PATTERN with the altered arguments. */
7505 if (TREE_CODE (t) == EXPR_PACK_EXPANSION)
7506 TREE_VEC_ELT (result, i) =
7507 tsubst_expr (pattern, args, complain, in_decl,
7508 /*integral_constant_expression_p=*/false);
7510 TREE_VEC_ELT (result, i) = tsubst (pattern, args, complain, in_decl);
7513 /* When we have incomplete argument packs, the last "expanded"
7514 result is itself a pack expansion, which allows us
7515 to deduce more arguments. */
7516 TREE_VEC_ELT (result, i) =
7517 make_pack_expansion (TREE_VEC_ELT (result, i));
7519 if (TREE_VEC_ELT (result, i) == error_mark_node)
7521 result = error_mark_node;
7526 /* Update ARGS to restore the substitution from parameter packs to
7527 their argument packs. */
7528 for (pack = packs; pack; pack = TREE_CHAIN (pack))
7530 tree parm = TREE_PURPOSE (pack);
7532 if (TREE_CODE (parm) == PARM_DECL)
7533 register_local_specialization (TREE_TYPE (pack), parm);
7537 template_parm_level_and_index (parm, &level, &idx);
7539 /* Update the corresponding argument. */
7540 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
7541 TREE_VEC_ELT (TREE_VEC_ELT (args, level -1 ), idx) =
7544 TREE_VEC_ELT (args, idx) = TREE_TYPE (pack);
7551 /* Substitute ARGS into the vector or list of template arguments T. */
7554 tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl)
7557 int len = TREE_VEC_LENGTH (t);
7558 int need_new = 0, i, expanded_len_adjust = 0, out;
7559 tree *elts = (tree *) alloca (len * sizeof (tree));
7561 for (i = 0; i < len; i++)
7563 tree orig_arg = TREE_VEC_ELT (t, i);
7566 if (TREE_CODE (orig_arg) == TREE_VEC)
7567 new_arg = tsubst_template_args (orig_arg, args, complain, in_decl);
7568 else if (PACK_EXPANSION_P (orig_arg))
7570 /* Substitute into an expansion expression. */
7571 new_arg = tsubst_pack_expansion (orig_arg, args, complain, in_decl);
7573 if (TREE_CODE (new_arg) == TREE_VEC)
7574 /* Add to the expanded length adjustment the number of
7575 expanded arguments. We subtract one from this
7576 measurement, because the argument pack expression
7577 itself is already counted as 1 in
7578 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
7579 the argument pack is empty. */
7580 expanded_len_adjust += TREE_VEC_LENGTH (new_arg) - 1;
7582 else if (ARGUMENT_PACK_P (orig_arg))
7584 /* Substitute into each of the arguments. */
7585 new_arg = make_node (TREE_CODE (orig_arg));
7587 SET_ARGUMENT_PACK_ARGS (
7589 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg),
7590 args, complain, in_decl));
7592 if (ARGUMENT_PACK_ARGS (new_arg) == error_mark_node)
7593 new_arg = error_mark_node;
7595 if (TREE_CODE (new_arg) == NONTYPE_ARGUMENT_PACK) {
7596 TREE_TYPE (new_arg) = tsubst (TREE_TYPE (orig_arg), args,
7598 TREE_CONSTANT (new_arg) = TREE_CONSTANT (orig_arg);
7600 if (TREE_TYPE (new_arg) == error_mark_node)
7601 new_arg = error_mark_node;
7605 new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl);
7607 if (new_arg == error_mark_node)
7608 return error_mark_node;
7611 if (new_arg != orig_arg)
7618 /* Make space for the expanded arguments coming from template
7620 t = make_tree_vec (len + expanded_len_adjust);
7621 for (i = 0, out = 0; i < len; i++)
7623 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t, i))
7624 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t, i)))
7625 && TREE_CODE (elts[i]) == TREE_VEC)
7629 /* Now expand the template argument pack "in place". */
7630 for (idx = 0; idx < TREE_VEC_LENGTH (elts[i]); idx++, out++)
7631 TREE_VEC_ELT (t, out) = TREE_VEC_ELT (elts[i], idx);
7635 TREE_VEC_ELT (t, out) = elts[i];
7643 /* Return the result of substituting ARGS into the template parameters
7644 given by PARMS. If there are m levels of ARGS and m + n levels of
7645 PARMS, then the result will contain n levels of PARMS. For
7646 example, if PARMS is `template <class T> template <class U>
7647 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
7648 result will be `template <int*, double, class V>'. */
7651 tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain)
7656 /* When substituting into a template, we must set
7657 PROCESSING_TEMPLATE_DECL as the template parameters may be
7658 dependent if they are based on one-another, and the dependency
7659 predicates are short-circuit outside of templates. */
7660 ++processing_template_decl;
7662 for (new_parms = &r;
7663 TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args);
7664 new_parms = &(TREE_CHAIN (*new_parms)),
7665 parms = TREE_CHAIN (parms))
7668 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms)));
7671 for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i)
7677 if (parms == error_mark_node)
7680 tuple = TREE_VEC_ELT (TREE_VALUE (parms), i);
7682 if (tuple == error_mark_node)
7685 default_value = TREE_PURPOSE (tuple);
7686 parm_decl = TREE_VALUE (tuple);
7688 parm_decl = tsubst (parm_decl, args, complain, NULL_TREE);
7689 if (TREE_CODE (parm_decl) == PARM_DECL
7690 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl), complain))
7691 parm_decl = error_mark_node;
7692 default_value = tsubst_template_arg (default_value, args,
7693 complain, NULL_TREE);
7695 tuple = build_tree_list (default_value, parm_decl);
7696 TREE_VEC_ELT (new_vec, i) = tuple;
7700 tree_cons (size_int (TMPL_PARMS_DEPTH (parms)
7701 - TMPL_ARGS_DEPTH (args)),
7702 new_vec, NULL_TREE);
7705 --processing_template_decl;
7710 /* Substitute the ARGS into the indicated aggregate (or enumeration)
7711 type T. If T is not an aggregate or enumeration type, it is
7712 handled as if by tsubst. IN_DECL is as for tsubst. If
7713 ENTERING_SCOPE is nonzero, T is the context for a template which
7714 we are presently tsubst'ing. Return the substituted value. */
7717 tsubst_aggr_type (tree t,
7719 tsubst_flags_t complain,
7726 switch (TREE_CODE (t))
7729 if (TYPE_PTRMEMFUNC_P (t))
7730 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl);
7732 /* Else fall through. */
7735 if (TYPE_TEMPLATE_INFO (t) && uses_template_parms (t))
7740 bool saved_skip_evaluation;
7742 /* In "sizeof(X<I>)" we need to evaluate "I". */
7743 saved_skip_evaluation = skip_evaluation;
7744 skip_evaluation = false;
7746 /* First, determine the context for the type we are looking
7748 context = TYPE_CONTEXT (t);
7751 context = tsubst_aggr_type (context, args, complain,
7752 in_decl, /*entering_scope=*/1);
7753 /* If context is a nested class inside a class template,
7754 it may still need to be instantiated (c++/33959). */
7755 if (TYPE_P (context))
7756 context = complete_type (context);
7759 /* Then, figure out what arguments are appropriate for the
7760 type we are trying to find. For example, given:
7762 template <class T> struct S;
7763 template <class T, class U> void f(T, U) { S<U> su; }
7765 and supposing that we are instantiating f<int, double>,
7766 then our ARGS will be {int, double}, but, when looking up
7767 S we only want {double}. */
7768 argvec = tsubst_template_args (TYPE_TI_ARGS (t), args,
7770 if (argvec == error_mark_node)
7771 r = error_mark_node;
7774 r = lookup_template_class (t, argvec, in_decl, context,
7775 entering_scope, complain);
7776 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
7779 skip_evaluation = saved_skip_evaluation;
7784 /* This is not a template type, so there's nothing to do. */
7788 return tsubst (t, args, complain, in_decl);
7792 /* Substitute into the default argument ARG (a default argument for
7793 FN), which has the indicated TYPE. */
7796 tsubst_default_argument (tree fn, tree type, tree arg)
7798 tree saved_class_ptr = NULL_TREE;
7799 tree saved_class_ref = NULL_TREE;
7801 /* This default argument came from a template. Instantiate the
7802 default argument here, not in tsubst. In the case of
7811 we must be careful to do name lookup in the scope of S<T>,
7812 rather than in the current class. */
7813 push_access_scope (fn);
7814 /* The "this" pointer is not valid in a default argument. */
7817 saved_class_ptr = current_class_ptr;
7818 cp_function_chain->x_current_class_ptr = NULL_TREE;
7819 saved_class_ref = current_class_ref;
7820 cp_function_chain->x_current_class_ref = NULL_TREE;
7823 push_deferring_access_checks(dk_no_deferred);
7824 /* The default argument expression may cause implicitly defined
7825 member functions to be synthesized, which will result in garbage
7826 collection. We must treat this situation as if we were within
7827 the body of function so as to avoid collecting live data on the
7830 arg = tsubst_expr (arg, DECL_TI_ARGS (fn),
7831 tf_warning_or_error, NULL_TREE,
7832 /*integral_constant_expression_p=*/false);
7834 pop_deferring_access_checks();
7836 /* Restore the "this" pointer. */
7839 cp_function_chain->x_current_class_ptr = saved_class_ptr;
7840 cp_function_chain->x_current_class_ref = saved_class_ref;
7843 pop_access_scope (fn);
7845 /* Make sure the default argument is reasonable. */
7846 arg = check_default_argument (type, arg);
7851 /* Substitute into all the default arguments for FN. */
7854 tsubst_default_arguments (tree fn)
7859 tmpl_args = DECL_TI_ARGS (fn);
7861 /* If this function is not yet instantiated, we certainly don't need
7862 its default arguments. */
7863 if (uses_template_parms (tmpl_args))
7866 for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
7868 arg = TREE_CHAIN (arg))
7869 if (TREE_PURPOSE (arg))
7870 TREE_PURPOSE (arg) = tsubst_default_argument (fn,
7872 TREE_PURPOSE (arg));
7875 /* Substitute the ARGS into the T, which is a _DECL. Return the
7876 result of the substitution. Issue error and warning messages under
7877 control of COMPLAIN. */
7880 tsubst_decl (tree t, tree args, tsubst_flags_t complain)
7882 location_t saved_loc;
7886 /* Set the filename and linenumber to improve error-reporting. */
7887 saved_loc = input_location;
7888 input_location = DECL_SOURCE_LOCATION (t);
7890 switch (TREE_CODE (t))
7894 /* We can get here when processing a member function template,
7895 member class template, and template template parameter of
7896 a template class. */
7897 tree decl = DECL_TEMPLATE_RESULT (t);
7902 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
7904 /* Template template parameter is treated here. */
7905 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
7906 if (new_type == error_mark_node)
7907 return error_mark_node;
7910 TREE_CHAIN (r) = NULL_TREE;
7911 TREE_TYPE (r) = new_type;
7912 DECL_TEMPLATE_RESULT (r)
7913 = build_decl (TYPE_DECL, DECL_NAME (decl), new_type);
7914 DECL_TEMPLATE_PARMS (r)
7915 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
7917 TYPE_NAME (new_type) = r;
7921 /* We might already have an instance of this template.
7922 The ARGS are for the surrounding class type, so the
7923 full args contain the tsubst'd args for the context,
7924 plus the innermost args from the template decl. */
7925 tmpl_args = DECL_CLASS_TEMPLATE_P (t)
7926 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t))
7927 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t));
7928 /* Because this is a template, the arguments will still be
7929 dependent, even after substitution. If
7930 PROCESSING_TEMPLATE_DECL is not set, the dependency
7931 predicates will short-circuit. */
7932 ++processing_template_decl;
7933 full_args = tsubst_template_args (tmpl_args, args,
7935 --processing_template_decl;
7936 if (full_args == error_mark_node)
7937 return error_mark_node;
7939 /* tsubst_template_args doesn't copy the vector if
7940 nothing changed. But, *something* should have
7942 gcc_assert (full_args != tmpl_args);
7944 spec = retrieve_specialization (t, full_args,
7945 /*class_specializations_p=*/true);
7946 if (spec != NULL_TREE)
7952 /* Make a new template decl. It will be similar to the
7953 original, but will record the current template arguments.
7954 We also create a new function declaration, which is just
7955 like the old one, but points to this new template, rather
7956 than the old one. */
7958 gcc_assert (DECL_LANG_SPECIFIC (r) != 0);
7959 TREE_CHAIN (r) = NULL_TREE;
7961 DECL_TEMPLATE_INFO (r) = build_tree_list (t, args);
7963 if (TREE_CODE (decl) == TYPE_DECL)
7966 ++processing_template_decl;
7967 new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
7968 --processing_template_decl;
7969 if (new_type == error_mark_node)
7970 return error_mark_node;
7972 TREE_TYPE (r) = new_type;
7973 CLASSTYPE_TI_TEMPLATE (new_type) = r;
7974 DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type);
7975 DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type);
7976 DECL_CONTEXT (r) = TYPE_CONTEXT (new_type);
7981 ++processing_template_decl;
7982 new_decl = tsubst (decl, args, complain, in_decl);
7983 --processing_template_decl;
7984 if (new_decl == error_mark_node)
7985 return error_mark_node;
7987 DECL_TEMPLATE_RESULT (r) = new_decl;
7988 DECL_TI_TEMPLATE (new_decl) = r;
7989 TREE_TYPE (r) = TREE_TYPE (new_decl);
7990 DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl);
7991 DECL_CONTEXT (r) = DECL_CONTEXT (new_decl);
7994 SET_DECL_IMPLICIT_INSTANTIATION (r);
7995 DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE;
7996 DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE;
7998 /* The template parameters for this new template are all the
7999 template parameters for the old template, except the
8000 outermost level of parameters. */
8001 DECL_TEMPLATE_PARMS (r)
8002 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
8005 if (PRIMARY_TEMPLATE_P (t))
8006 DECL_PRIMARY_TEMPLATE (r) = r;
8008 if (TREE_CODE (decl) != TYPE_DECL)
8009 /* Record this non-type partial instantiation. */
8010 register_specialization (r, t,
8011 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r)),
8019 tree argvec = NULL_TREE;
8027 /* Nobody should be tsubst'ing into non-template functions. */
8028 gcc_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE);
8030 if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL)
8035 /* If T is not dependent, just return it. We have to
8036 increment PROCESSING_TEMPLATE_DECL because
8037 value_dependent_expression_p assumes that nothing is
8038 dependent when PROCESSING_TEMPLATE_DECL is zero. */
8039 ++processing_template_decl;
8040 dependent_p = value_dependent_expression_p (t);
8041 --processing_template_decl;
8045 /* Calculate the most general template of which R is a
8046 specialization, and the complete set of arguments used to
8048 gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
8049 argvec = tsubst_template_args (DECL_TI_ARGS
8050 (DECL_TEMPLATE_RESULT (gen_tmpl)),
8051 args, complain, in_decl);
8053 /* Check to see if we already have this specialization. */
8054 spec = retrieve_specialization (gen_tmpl, argvec,
8055 /*class_specializations_p=*/false);
8063 /* We can see more levels of arguments than parameters if
8064 there was a specialization of a member template, like
8067 template <class T> struct S { template <class U> void f(); }
8068 template <> template <class U> void S<int>::f(U);
8070 Here, we'll be substituting into the specialization,
8071 because that's where we can find the code we actually
8072 want to generate, but we'll have enough arguments for
8073 the most general template.
8075 We also deal with the peculiar case:
8077 template <class T> struct S {
8078 template <class U> friend void f();
8080 template <class U> void f() {}
8082 template void f<double>();
8084 Here, the ARGS for the instantiation of will be {int,
8085 double}. But, we only need as many ARGS as there are
8086 levels of template parameters in CODE_PATTERN. We are
8087 careful not to get fooled into reducing the ARGS in
8090 template <class T> struct S { template <class U> void f(U); }
8091 template <class T> template <> void S<T>::f(int) {}
8093 which we can spot because the pattern will be a
8094 specialization in this case. */
8095 args_depth = TMPL_ARGS_DEPTH (args);
8097 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t)));
8098 if (args_depth > parms_depth
8099 && !DECL_TEMPLATE_SPECIALIZATION (t))
8100 args = get_innermost_template_args (args, parms_depth);
8104 /* This special case arises when we have something like this:
8106 template <class T> struct S {
8107 friend void f<int>(int, double);
8110 Here, the DECL_TI_TEMPLATE for the friend declaration
8111 will be an IDENTIFIER_NODE. We are being called from
8112 tsubst_friend_function, and we want only to create a
8113 new decl (R) with appropriate types so that we can call
8114 determine_specialization. */
8115 gen_tmpl = NULL_TREE;
8118 if (DECL_CLASS_SCOPE_P (t))
8120 if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t)))
8124 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
8125 complain, t, /*entering_scope=*/1);
8130 ctx = DECL_CONTEXT (t);
8132 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8133 if (type == error_mark_node)
8134 return error_mark_node;
8136 /* We do NOT check for matching decls pushed separately at this
8137 point, as they may not represent instantiations of this
8138 template, and in any case are considered separate under the
8141 DECL_USE_TEMPLATE (r) = 0;
8142 TREE_TYPE (r) = type;
8143 /* Clear out the mangled name and RTL for the instantiation. */
8144 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
8145 SET_DECL_RTL (r, NULL_RTX);
8146 DECL_INITIAL (r) = NULL_TREE;
8147 DECL_CONTEXT (r) = ctx;
8149 if (member && DECL_CONV_FN_P (r))
8150 /* Type-conversion operator. Reconstruct the name, in
8151 case it's the name of one of the template's parameters. */
8152 DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type));
8154 DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args,
8156 DECL_RESULT (r) = NULL_TREE;
8158 TREE_STATIC (r) = 0;
8159 TREE_PUBLIC (r) = TREE_PUBLIC (t);
8160 DECL_EXTERNAL (r) = 1;
8161 /* If this is an instantiation of a function with internal
8162 linkage, we already know what object file linkage will be
8163 assigned to the instantiation. */
8164 DECL_INTERFACE_KNOWN (r) = !TREE_PUBLIC (r);
8165 DECL_DEFER_OUTPUT (r) = 0;
8166 TREE_CHAIN (r) = NULL_TREE;
8167 DECL_PENDING_INLINE_INFO (r) = 0;
8168 DECL_PENDING_INLINE_P (r) = 0;
8169 DECL_SAVED_TREE (r) = NULL_TREE;
8171 if (DECL_CLONED_FUNCTION (r))
8173 DECL_CLONED_FUNCTION (r) = tsubst (DECL_CLONED_FUNCTION (t),
8175 TREE_CHAIN (r) = TREE_CHAIN (DECL_CLONED_FUNCTION (r));
8176 TREE_CHAIN (DECL_CLONED_FUNCTION (r)) = r;
8179 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
8180 this in the special friend case mentioned above where
8181 GEN_TMPL is NULL. */
8184 DECL_TEMPLATE_INFO (r)
8185 = tree_cons (gen_tmpl, argvec, NULL_TREE);
8186 SET_DECL_IMPLICIT_INSTANTIATION (r);
8187 register_specialization (r, gen_tmpl, argvec, false);
8189 /* We're not supposed to instantiate default arguments
8190 until they are called, for a template. But, for a
8193 template <class T> void f ()
8194 { extern void g(int i = T()); }
8196 we should do the substitution when the template is
8197 instantiated. We handle the member function case in
8198 instantiate_class_template since the default arguments
8199 might refer to other members of the class. */
8201 && !PRIMARY_TEMPLATE_P (gen_tmpl)
8202 && !uses_template_parms (argvec))
8203 tsubst_default_arguments (r);
8206 DECL_TEMPLATE_INFO (r) = NULL_TREE;
8208 /* Copy the list of befriending classes. */
8209 for (friends = &DECL_BEFRIENDING_CLASSES (r);
8211 friends = &TREE_CHAIN (*friends))
8213 *friends = copy_node (*friends);
8214 TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends),
8219 if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r))
8221 maybe_retrofit_in_chrg (r);
8222 if (DECL_CONSTRUCTOR_P (r))
8223 grok_ctor_properties (ctx, r);
8224 /* If this is an instantiation of a member template, clone it.
8225 If it isn't, that'll be handled by
8226 clone_constructors_and_destructors. */
8227 if (PRIMARY_TEMPLATE_P (gen_tmpl))
8228 clone_function_decl (r, /*update_method_vec_p=*/0);
8230 else if (IDENTIFIER_OPNAME_P (DECL_NAME (r))
8231 && !grok_op_properties (r, (complain & tf_error) != 0))
8232 return error_mark_node;
8234 if (DECL_FRIEND_P (t) && DECL_FRIEND_CONTEXT (t))
8235 SET_DECL_FRIEND_CONTEXT (r,
8236 tsubst (DECL_FRIEND_CONTEXT (t),
8237 args, complain, in_decl));
8239 /* Possibly limit visibility based on template args. */
8240 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
8241 if (DECL_VISIBILITY_SPECIFIED (t))
8243 DECL_VISIBILITY_SPECIFIED (r) = 0;
8245 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
8247 determine_visibility (r);
8249 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
8250 args, complain, in_decl);
8256 tree type = NULL_TREE;
8258 tree expanded_types = NULL_TREE;
8259 tree prev_r = NULL_TREE;
8260 tree first_r = NULL_TREE;
8262 if (FUNCTION_PARAMETER_PACK_P (t))
8264 /* If there is a local specialization that isn't a
8265 parameter pack, it means that we're doing a "simple"
8266 substitution from inside tsubst_pack_expansion. Just
8267 return the local specialization (which will be a single
8269 tree spec = retrieve_local_specialization (t);
8271 && TREE_CODE (spec) == PARM_DECL
8272 && TREE_CODE (TREE_TYPE (spec)) != TYPE_PACK_EXPANSION)
8275 /* Expand the TYPE_PACK_EXPANSION that provides the types for
8276 the parameters in this function parameter pack. */
8277 expanded_types = tsubst_pack_expansion (TREE_TYPE (t), args,
8279 if (TREE_CODE (expanded_types) == TREE_VEC)
8281 len = TREE_VEC_LENGTH (expanded_types);
8283 /* Zero-length parameter packs are boring. Just substitute
8286 return tsubst (TREE_CHAIN (t), args, complain,
8291 /* All we did was update the type. Make a note of that. */
8292 type = expanded_types;
8293 expanded_types = NULL_TREE;
8297 /* Loop through all of the parameter's we'll build. When T is
8298 a function parameter pack, LEN is the number of expanded
8299 types in EXPANDED_TYPES; otherwise, LEN is 1. */
8301 for (i = 0; i < len; ++i)
8305 if (DECL_TEMPLATE_PARM_P (t))
8306 SET_DECL_TEMPLATE_PARM_P (r);
8309 /* We're on the Ith parameter of the function parameter
8312 /* Get the Ith type. */
8313 type = TREE_VEC_ELT (expanded_types, i);
8316 /* Rename the parameter to include the index. */
8318 make_ith_pack_parameter_name (DECL_NAME (r), i);
8321 /* We're dealing with a normal parameter. */
8322 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8324 type = type_decays_to (type);
8325 TREE_TYPE (r) = type;
8326 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
8328 if (DECL_INITIAL (r))
8330 if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
8331 DECL_INITIAL (r) = TREE_TYPE (r);
8333 DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
8337 DECL_CONTEXT (r) = NULL_TREE;
8339 if (!DECL_TEMPLATE_PARM_P (r))
8340 DECL_ARG_TYPE (r) = type_passed_as (type);
8342 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
8343 args, complain, in_decl);
8345 /* Keep track of the first new parameter we
8346 generate. That's what will be returned to the
8351 /* Build a proper chain of parameters when substituting
8352 into a function parameter pack. */
8354 TREE_CHAIN (prev_r) = r;
8358 TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args,
8359 complain, TREE_CHAIN (t));
8361 /* FIRST_R contains the start of the chain we've built. */
8371 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8372 if (type == error_mark_node)
8373 return error_mark_node;
8374 TREE_TYPE (r) = type;
8375 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
8377 /* DECL_INITIAL gives the number of bits in a bit-field. */
8379 = tsubst_expr (DECL_INITIAL (t), args,
8381 /*integral_constant_expression_p=*/true);
8382 /* We don't have to set DECL_CONTEXT here; it is set by
8383 finish_member_declaration. */
8384 TREE_CHAIN (r) = NULL_TREE;
8385 if (VOID_TYPE_P (type))
8386 error ("instantiation of %q+D as type %qT", r, type);
8388 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
8389 args, complain, in_decl);
8394 /* We reach here only for member using decls. */
8395 if (DECL_DEPENDENT_P (t))
8397 r = do_class_using_decl
8398 (tsubst_copy (USING_DECL_SCOPE (t), args, complain, in_decl),
8399 tsubst_copy (DECL_NAME (t), args, complain, in_decl));
8401 r = error_mark_node;
8406 TREE_CHAIN (r) = NULL_TREE;
8413 tree argvec = NULL_TREE;
8414 tree gen_tmpl = NULL_TREE;
8416 tree tmpl = NULL_TREE;
8418 tree type = NULL_TREE;
8421 if (TREE_CODE (t) == TYPE_DECL
8422 && t == TYPE_MAIN_DECL (TREE_TYPE (t)))
8424 /* If this is the canonical decl, we don't have to
8425 mess with instantiations, and often we can't (for
8426 typename, template type parms and such). Note that
8427 TYPE_NAME is not correct for the above test if
8428 we've copied the type for a typedef. */
8429 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8430 if (type == error_mark_node)
8431 return error_mark_node;
8432 r = TYPE_NAME (type);
8436 /* Check to see if we already have the specialization we
8439 if (DECL_CLASS_SCOPE_P (t) || DECL_NAMESPACE_SCOPE_P (t))
8441 /* T is a static data member or namespace-scope entity.
8442 We have to substitute into namespace-scope variables
8443 (even though such entities are never templates) because
8446 template <class T> void f() { extern T t; }
8448 where the entity referenced is not known until
8449 instantiation time. */
8451 ctx = DECL_CONTEXT (t);
8452 if (DECL_CLASS_SCOPE_P (t))
8454 ctx = tsubst_aggr_type (ctx, args,
8456 in_decl, /*entering_scope=*/1);
8457 /* If CTX is unchanged, then T is in fact the
8458 specialization we want. That situation occurs when
8459 referencing a static data member within in its own
8460 class. We can use pointer equality, rather than
8461 same_type_p, because DECL_CONTEXT is always
8463 if (ctx == DECL_CONTEXT (t))
8469 tmpl = DECL_TI_TEMPLATE (t);
8470 gen_tmpl = most_general_template (tmpl);
8471 argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl);
8472 spec = (retrieve_specialization
8474 /*class_specializations_p=*/false));
8479 /* A local variable. */
8481 /* Subsequent calls to pushdecl will fill this in. */
8483 spec = retrieve_local_specialization (t);
8485 /* If we already have the specialization we need, there is
8486 nothing more to do. */
8493 /* Create a new node for the specialization we need. */
8495 if (type == NULL_TREE)
8496 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8497 if (TREE_CODE (r) == VAR_DECL)
8499 /* Even if the original location is out of scope, the
8500 newly substituted one is not. */
8501 DECL_DEAD_FOR_LOCAL (r) = 0;
8502 DECL_INITIALIZED_P (r) = 0;
8503 DECL_TEMPLATE_INSTANTIATED (r) = 0;
8504 if (type == error_mark_node)
8505 return error_mark_node;
8506 if (TREE_CODE (type) == FUNCTION_TYPE)
8508 /* It may seem that this case cannot occur, since:
8513 declares a function, not a variable. However:
8516 template <typename T> void g() { T t; }
8517 template void g<f>();
8519 is an attempt to declare a variable with function
8521 error ("variable %qD has function type",
8522 /* R is not yet sufficiently initialized, so we
8523 just use its name. */
8525 return error_mark_node;
8527 type = complete_type (type);
8528 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
8529 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t);
8530 type = check_var_type (DECL_NAME (r), type);
8532 if (DECL_HAS_VALUE_EXPR_P (t))
8534 tree ve = DECL_VALUE_EXPR (t);
8535 ve = tsubst_expr (ve, args, complain, in_decl,
8536 /*constant_expression_p=*/false);
8537 SET_DECL_VALUE_EXPR (r, ve);
8540 else if (DECL_SELF_REFERENCE_P (t))
8541 SET_DECL_SELF_REFERENCE_P (r);
8542 TREE_TYPE (r) = type;
8543 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
8544 DECL_CONTEXT (r) = ctx;
8545 /* Clear out the mangled name and RTL for the instantiation. */
8546 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
8547 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
8548 SET_DECL_RTL (r, NULL_RTX);
8549 /* The initializer must not be expanded until it is required;
8551 DECL_INITIAL (r) = NULL_TREE;
8552 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
8553 SET_DECL_RTL (r, NULL_RTX);
8554 DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0;
8555 if (TREE_CODE (r) == VAR_DECL)
8557 /* Possibly limit visibility based on template args. */
8558 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
8559 if (DECL_VISIBILITY_SPECIFIED (t))
8561 DECL_VISIBILITY_SPECIFIED (r) = 0;
8563 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
8565 determine_visibility (r);
8567 /* Preserve a typedef that names a type. */
8568 else if (TREE_CODE (r) == TYPE_DECL
8569 && DECL_ORIGINAL_TYPE (t)
8570 && type != error_mark_node)
8572 DECL_ORIGINAL_TYPE (r) = tsubst (DECL_ORIGINAL_TYPE (t),
8573 args, complain, in_decl);
8574 TREE_TYPE (r) = type = build_variant_type_copy (type);
8575 TYPE_NAME (type) = r;
8580 /* A static data member declaration is always marked
8581 external when it is declared in-class, even if an
8582 initializer is present. We mimic the non-template
8584 DECL_EXTERNAL (r) = 1;
8586 register_specialization (r, gen_tmpl, argvec, false);
8587 DECL_TEMPLATE_INFO (r) = tree_cons (tmpl, argvec, NULL_TREE);
8588 SET_DECL_IMPLICIT_INSTANTIATION (r);
8591 register_local_specialization (r, t);
8593 TREE_CHAIN (r) = NULL_TREE;
8595 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r),
8596 (int) ATTR_FLAG_TYPE_IN_PLACE,
8597 args, complain, in_decl);
8606 /* Restore the file and line information. */
8607 input_location = saved_loc;
8612 /* Substitute into the ARG_TYPES of a function type. */
8615 tsubst_arg_types (tree arg_types,
8617 tsubst_flags_t complain,
8620 tree remaining_arg_types;
8621 tree type = NULL_TREE;
8623 tree expanded_args = NULL_TREE;
8626 if (!arg_types || arg_types == void_list_node)
8629 remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types),
8630 args, complain, in_decl);
8631 if (remaining_arg_types == error_mark_node)
8632 return error_mark_node;
8634 if (PACK_EXPANSION_P (TREE_VALUE (arg_types)))
8636 /* For a pack expansion, perform substitution on the
8637 entire expression. Later on, we'll handle the arguments
8639 expanded_args = tsubst_pack_expansion (TREE_VALUE (arg_types),
8640 args, complain, in_decl);
8642 if (TREE_CODE (expanded_args) == TREE_VEC)
8643 /* So that we'll spin through the parameters, one by one. */
8644 i = TREE_VEC_LENGTH (expanded_args);
8647 /* We only partially substituted into the parameter
8648 pack. Our type is TYPE_PACK_EXPANSION. */
8649 type = expanded_args;
8650 expanded_args = NULL_TREE;
8658 type = TREE_VEC_ELT (expanded_args, i);
8660 type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
8662 if (type == error_mark_node)
8663 return error_mark_node;
8664 if (VOID_TYPE_P (type))
8666 if (complain & tf_error)
8668 error ("invalid parameter type %qT", type);
8670 error ("in declaration %q+D", in_decl);
8672 return error_mark_node;
8675 /* Do array-to-pointer, function-to-pointer conversion, and ignore
8676 top-level qualifiers as required. */
8677 type = TYPE_MAIN_VARIANT (type_decays_to (type));
8679 /* We do not substitute into default arguments here. The standard
8680 mandates that they be instantiated only when needed, which is
8681 done in build_over_call. */
8682 default_arg = TREE_PURPOSE (arg_types);
8684 if (default_arg && TREE_CODE (default_arg) == DEFAULT_ARG)
8686 /* We've instantiated a template before its default arguments
8687 have been parsed. This can happen for a nested template
8688 class, and is not an error unless we require the default
8689 argument in a call of this function. */
8690 remaining_arg_types =
8691 tree_cons (default_arg, type, remaining_arg_types);
8692 VEC_safe_push (tree, gc, DEFARG_INSTANTIATIONS (default_arg),
8693 remaining_arg_types);
8696 remaining_arg_types =
8697 hash_tree_cons (default_arg, type, remaining_arg_types);
8700 return remaining_arg_types;
8703 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
8704 *not* handle the exception-specification for FNTYPE, because the
8705 initial substitution of explicitly provided template parameters
8706 during argument deduction forbids substitution into the
8707 exception-specification:
8711 All references in the function type of the function template to the
8712 corresponding template parameters are replaced by the specified tem-
8713 plate argument values. If a substitution in a template parameter or
8714 in the function type of the function template results in an invalid
8715 type, type deduction fails. [Note: The equivalent substitution in
8716 exception specifications is done only when the function is instanti-
8717 ated, at which point a program is ill-formed if the substitution
8718 results in an invalid type.] */
8721 tsubst_function_type (tree t,
8723 tsubst_flags_t complain,
8730 /* The TYPE_CONTEXT is not used for function/method types. */
8731 gcc_assert (TYPE_CONTEXT (t) == NULL_TREE);
8733 /* Substitute the return type. */
8734 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8735 if (return_type == error_mark_node)
8736 return error_mark_node;
8737 /* The standard does not presently indicate that creation of a
8738 function type with an invalid return type is a deduction failure.
8739 However, that is clearly analogous to creating an array of "void"
8740 or a reference to a reference. This is core issue #486. */
8741 if (TREE_CODE (return_type) == ARRAY_TYPE
8742 || TREE_CODE (return_type) == FUNCTION_TYPE)
8744 if (complain & tf_error)
8746 if (TREE_CODE (return_type) == ARRAY_TYPE)
8747 error ("function returning an array");
8749 error ("function returning a function");
8751 return error_mark_node;
8754 /* Substitute the argument types. */
8755 arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args,
8757 if (arg_types == error_mark_node)
8758 return error_mark_node;
8760 /* Construct a new type node and return it. */
8761 if (TREE_CODE (t) == FUNCTION_TYPE)
8762 fntype = build_function_type (return_type, arg_types);
8765 tree r = TREE_TYPE (TREE_VALUE (arg_types));
8766 if (! MAYBE_CLASS_TYPE_P (r))
8770 Type deduction may fail for any of the following
8773 -- Attempting to create "pointer to member of T" when T
8774 is not a class type. */
8775 if (complain & tf_error)
8776 error ("creating pointer to member function of non-class type %qT",
8778 return error_mark_node;
8781 fntype = build_method_type_directly (r, return_type,
8782 TREE_CHAIN (arg_types));
8784 fntype = cp_build_qualified_type_real (fntype, TYPE_QUALS (t), complain);
8785 fntype = cp_build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t));
8790 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
8791 ARGS into that specification, and return the substituted
8792 specification. If there is no specification, return NULL_TREE. */
8795 tsubst_exception_specification (tree fntype,
8797 tsubst_flags_t complain,
8803 specs = TYPE_RAISES_EXCEPTIONS (fntype);
8804 new_specs = NULL_TREE;
8807 if (! TREE_VALUE (specs))
8814 tree expanded_specs = NULL_TREE;
8816 if (PACK_EXPANSION_P (TREE_VALUE (specs)))
8818 /* Expand the pack expansion type. */
8819 expanded_specs = tsubst_pack_expansion (TREE_VALUE (specs),
8823 if (expanded_specs == error_mark_node)
8824 return error_mark_node;
8825 else if (TREE_CODE (expanded_specs) == TREE_VEC)
8826 len = TREE_VEC_LENGTH (expanded_specs);
8829 /* We're substituting into a member template, so
8830 we got a TYPE_PACK_EXPANSION back. Add that
8831 expansion and move on. */
8832 gcc_assert (TREE_CODE (expanded_specs)
8833 == TYPE_PACK_EXPANSION);
8834 new_specs = add_exception_specifier (new_specs,
8837 specs = TREE_CHAIN (specs);
8842 for (i = 0; i < len; ++i)
8845 spec = TREE_VEC_ELT (expanded_specs, i);
8847 spec = tsubst (TREE_VALUE (specs), args, complain, in_decl);
8848 if (spec == error_mark_node)
8850 new_specs = add_exception_specifier (new_specs, spec,
8854 specs = TREE_CHAIN (specs);
8860 /* Take the tree structure T and replace template parameters used
8861 therein with the argument vector ARGS. IN_DECL is an associated
8862 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
8863 Issue error and warning messages under control of COMPLAIN. Note
8864 that we must be relatively non-tolerant of extensions here, in
8865 order to preserve conformance; if we allow substitutions that
8866 should not be allowed, we may allow argument deductions that should
8867 not succeed, and therefore report ambiguous overload situations
8868 where there are none. In theory, we could allow the substitution,
8869 but indicate that it should have failed, and allow our caller to
8870 make sure that the right thing happens, but we don't try to do this
8873 This function is used for dealing with types, decls and the like;
8874 for expressions, use tsubst_expr or tsubst_copy. */
8877 tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
8881 if (t == NULL_TREE || t == error_mark_node
8882 || t == integer_type_node
8883 || t == void_type_node
8884 || t == char_type_node
8885 || t == unknown_type_node
8886 || TREE_CODE (t) == NAMESPACE_DECL)
8890 return tsubst_decl (t, args, complain);
8892 if (TREE_CODE (t) == IDENTIFIER_NODE)
8893 type = IDENTIFIER_TYPE_VALUE (t);
8895 type = TREE_TYPE (t);
8897 gcc_assert (type != unknown_type_node);
8899 /* Reuse typedefs. We need to do this to handle dependent attributes,
8900 such as attribute aligned. */
8903 && TYPE_NAME (t) != TYPE_MAIN_DECL (t))
8905 tree decl = TYPE_NAME (t);
8907 if (DECL_CLASS_SCOPE_P (decl)
8908 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl))
8909 && uses_template_parms (DECL_CONTEXT (decl)))
8911 tree tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
8912 tree gen_args = tsubst (DECL_TI_ARGS (decl), args, complain, in_decl);
8913 r = retrieve_specialization (tmpl, gen_args, false);
8915 else if (DECL_FUNCTION_SCOPE_P (decl)
8916 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl))
8917 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl))))
8918 r = retrieve_local_specialization (decl);
8920 /* The typedef is from a non-template context. */
8926 r = cp_build_qualified_type_real
8927 (r, cp_type_quals (t) | cp_type_quals (r),
8928 complain | tf_ignore_bad_quals);
8931 /* Else we must be instantiating the typedef, so fall through. */
8935 && TREE_CODE (t) != TYPENAME_TYPE
8936 && TREE_CODE (t) != IDENTIFIER_NODE
8937 && TREE_CODE (t) != FUNCTION_TYPE
8938 && TREE_CODE (t) != METHOD_TYPE)
8939 type = tsubst (type, args, complain, in_decl);
8940 if (type == error_mark_node)
8941 return error_mark_node;
8943 switch (TREE_CODE (t))
8948 return tsubst_aggr_type (t, args, complain, in_decl,
8949 /*entering_scope=*/0);
8952 case IDENTIFIER_NODE:
8964 if (t == integer_type_node)
8967 if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
8968 && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
8972 tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);
8974 max = tsubst_expr (omax, args, complain, in_decl,
8975 /*integral_constant_expression_p=*/false);
8976 max = fold_decl_constant_value (max);
8978 if (TREE_CODE (max) != INTEGER_CST
8979 && !at_function_scope_p ()
8980 && !value_dependent_expression_p (max))
8982 if (complain & tf_error)
8983 error ("array bound is not an integer constant");
8984 return error_mark_node;
8989 Type deduction may fail for any of the following
8992 Attempting to create an array with a size that is
8993 zero or negative. */
8994 if (integer_zerop (max) && !(complain & tf_error))
8995 /* We must fail if performing argument deduction (as
8996 indicated by the state of complain), so that
8997 another substitution can be found. */
8998 return error_mark_node;
8999 else if (TREE_CODE (max) == INTEGER_CST
9000 && INT_CST_LT (max, integer_zero_node))
9002 if (complain & tf_error)
9003 error ("creating array with negative size (%qE)", max);
9005 return error_mark_node;
9008 return compute_array_index_type (NULL_TREE, max);
9011 case TEMPLATE_TYPE_PARM:
9012 case TEMPLATE_TEMPLATE_PARM:
9013 case BOUND_TEMPLATE_TEMPLATE_PARM:
9014 case TEMPLATE_PARM_INDEX:
9019 tree arg = NULL_TREE;
9023 gcc_assert (TREE_VEC_LENGTH (args) > 0);
9024 template_parm_level_and_index (t, &level, &idx);
9026 levels = TMPL_ARGS_DEPTH (args);
9027 if (level <= levels)
9029 arg = TMPL_ARG (args, level, idx);
9031 if (arg && TREE_CODE (arg) == ARGUMENT_PACK_SELECT)
9032 /* See through ARGUMENT_PACK_SELECT arguments. */
9033 arg = ARGUMENT_PACK_SELECT_ARG (arg);
9036 if (arg == error_mark_node)
9037 return error_mark_node;
9038 else if (arg != NULL_TREE)
9040 if (ARGUMENT_PACK_P (arg))
9041 /* If ARG is an argument pack, we don't actually want to
9042 perform a substitution here, because substitutions
9043 for argument packs are only done
9044 element-by-element. We can get to this point when
9045 substituting the type of a non-type template
9046 parameter pack, when that type actually contains
9047 template parameter packs from an outer template, e.g.,
9049 template<typename... Types> struct A {
9050 template<Types... Values> struct B { };
9054 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
9057 gcc_assert (TYPE_P (arg));
9059 /* cv-quals from the template are discarded when
9060 substituting in a function or reference type. */
9061 if (TREE_CODE (arg) == FUNCTION_TYPE
9062 || TREE_CODE (arg) == METHOD_TYPE
9063 || TREE_CODE (arg) == REFERENCE_TYPE)
9064 quals = cp_type_quals (arg);
9066 quals = cp_type_quals (arg) | cp_type_quals (t);
9068 return cp_build_qualified_type_real
9069 (arg, quals, complain | tf_ignore_bad_quals);
9071 else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
9073 /* We are processing a type constructed from a
9074 template template parameter. */
9075 tree argvec = tsubst (TYPE_TI_ARGS (t),
9076 args, complain, in_decl);
9077 if (argvec == error_mark_node)
9078 return error_mark_node;
9080 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
9081 are resolving nested-types in the signature of a
9082 member function templates. Otherwise ARG is a
9083 TEMPLATE_DECL and is the real template to be
9085 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
9086 arg = TYPE_NAME (arg);
9088 r = lookup_template_class (arg,
9091 /*entering_scope=*/0,
9093 return cp_build_qualified_type_real
9094 (r, TYPE_QUALS (t), complain);
9097 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
9102 /* This can happen during the attempted tsubst'ing in
9103 unify. This means that we don't yet have any information
9104 about the template parameter in question. */
9107 /* If we get here, we must have been looking at a parm for a
9108 more deeply nested template. Make a new version of this
9109 template parameter, but with a lower level. */
9110 switch (TREE_CODE (t))
9112 case TEMPLATE_TYPE_PARM:
9113 case TEMPLATE_TEMPLATE_PARM:
9114 case BOUND_TEMPLATE_TEMPLATE_PARM:
9115 if (cp_type_quals (t))
9117 r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
9118 r = cp_build_qualified_type_real
9119 (r, cp_type_quals (t),
9120 complain | (TREE_CODE (t) == TEMPLATE_TYPE_PARM
9121 ? tf_ignore_bad_quals : 0));
9126 TEMPLATE_TYPE_PARM_INDEX (r)
9127 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t),
9128 r, levels, args, complain);
9129 TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r);
9130 TYPE_MAIN_VARIANT (r) = r;
9131 TYPE_POINTER_TO (r) = NULL_TREE;
9132 TYPE_REFERENCE_TO (r) = NULL_TREE;
9134 if (TREE_CODE (r) == TEMPLATE_TEMPLATE_PARM)
9135 /* We have reduced the level of the template
9136 template parameter, but not the levels of its
9137 template parameters, so canonical_type_parameter
9138 will not be able to find the canonical template
9139 template parameter for this level. Thus, we
9140 require structural equality checking to compare
9141 TEMPLATE_TEMPLATE_PARMs. */
9142 SET_TYPE_STRUCTURAL_EQUALITY (r);
9143 else if (TYPE_STRUCTURAL_EQUALITY_P (t))
9144 SET_TYPE_STRUCTURAL_EQUALITY (r);
9146 TYPE_CANONICAL (r) = canonical_type_parameter (r);
9148 if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
9150 tree argvec = tsubst (TYPE_TI_ARGS (t), args,
9152 if (argvec == error_mark_node)
9153 return error_mark_node;
9155 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r)
9156 = tree_cons (TYPE_TI_TEMPLATE (t), argvec, NULL_TREE);
9161 case TEMPLATE_PARM_INDEX:
9162 r = reduce_template_parm_level (t, type, levels, args, complain);
9174 tree purpose, value, chain;
9176 if (t == void_list_node)
9179 purpose = TREE_PURPOSE (t);
9182 purpose = tsubst (purpose, args, complain, in_decl);
9183 if (purpose == error_mark_node)
9184 return error_mark_node;
9186 value = TREE_VALUE (t);
9189 value = tsubst (value, args, complain, in_decl);
9190 if (value == error_mark_node)
9191 return error_mark_node;
9193 chain = TREE_CHAIN (t);
9194 if (chain && chain != void_type_node)
9196 chain = tsubst (chain, args, complain, in_decl);
9197 if (chain == error_mark_node)
9198 return error_mark_node;
9200 if (purpose == TREE_PURPOSE (t)
9201 && value == TREE_VALUE (t)
9202 && chain == TREE_CHAIN (t))
9204 return hash_tree_cons (purpose, value, chain);
9208 /* We should never be tsubsting a binfo. */
9212 /* A vector of template arguments. */
9214 return tsubst_template_args (t, args, complain, in_decl);
9217 case REFERENCE_TYPE:
9219 enum tree_code code;
9221 if (type == TREE_TYPE (t) && TREE_CODE (type) != METHOD_TYPE)
9224 code = TREE_CODE (t);
9229 Type deduction may fail for any of the following
9232 -- Attempting to create a pointer to reference type.
9233 -- Attempting to create a reference to a reference type or
9234 a reference to void.
9236 Core issue 106 says that creating a reference to a reference
9237 during instantiation is no longer a cause for failure. We
9238 only enforce this check in strict C++98 mode. */
9239 if ((TREE_CODE (type) == REFERENCE_TYPE
9240 && (((cxx_dialect == cxx98) && flag_iso) || code != REFERENCE_TYPE))
9241 || (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE))
9243 static location_t last_loc;
9245 /* We keep track of the last time we issued this error
9246 message to avoid spewing a ton of messages during a
9247 single bad template instantiation. */
9248 if (complain & tf_error
9249 && last_loc != input_location)
9251 if (TREE_CODE (type) == VOID_TYPE)
9252 error ("forming reference to void");
9254 error ("forming %s to reference type %qT",
9255 (code == POINTER_TYPE) ? "pointer" : "reference",
9257 last_loc = input_location;
9260 return error_mark_node;
9262 else if (code == POINTER_TYPE)
9264 r = build_pointer_type (type);
9265 if (TREE_CODE (type) == METHOD_TYPE)
9266 r = build_ptrmemfunc_type (r);
9268 else if (TREE_CODE (type) == REFERENCE_TYPE)
9269 /* In C++0x, during template argument substitution, when there is an
9270 attempt to create a reference to a reference type, reference
9271 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
9273 "If a template-argument for a template-parameter T names a type
9274 that is a reference to a type A, an attempt to create the type
9275 'lvalue reference to cv T' creates the type 'lvalue reference to
9276 A,' while an attempt to create the type type rvalue reference to
9277 cv T' creates the type T"
9279 r = cp_build_reference_type
9281 TYPE_REF_IS_RVALUE (t) && TYPE_REF_IS_RVALUE (type));
9283 r = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
9284 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
9286 if (r != error_mark_node)
9287 /* Will this ever be needed for TYPE_..._TO values? */
9294 r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
9295 if (r == error_mark_node || !MAYBE_CLASS_TYPE_P (r))
9299 Type deduction may fail for any of the following
9302 -- Attempting to create "pointer to member of T" when T
9303 is not a class type. */
9304 if (complain & tf_error)
9305 error ("creating pointer to member of non-class type %qT", r);
9306 return error_mark_node;
9308 if (TREE_CODE (type) == REFERENCE_TYPE)
9310 if (complain & tf_error)
9311 error ("creating pointer to member reference type %qT", type);
9312 return error_mark_node;
9314 if (TREE_CODE (type) == VOID_TYPE)
9316 if (complain & tf_error)
9317 error ("creating pointer to member of type void");
9318 return error_mark_node;
9320 gcc_assert (TREE_CODE (type) != METHOD_TYPE);
9321 if (TREE_CODE (type) == FUNCTION_TYPE)
9323 /* The type of the implicit object parameter gets its
9324 cv-qualifiers from the FUNCTION_TYPE. */
9326 tree this_type = cp_build_qualified_type (TYPE_MAIN_VARIANT (r),
9327 cp_type_quals (type));
9329 method_type = build_method_type_directly (this_type,
9331 TYPE_ARG_TYPES (type));
9332 memptr = build_ptrmemfunc_type (build_pointer_type (method_type));
9333 return cp_build_qualified_type_real (memptr, cp_type_quals (t),
9337 return cp_build_qualified_type_real (build_ptrmem_type (r, type),
9346 fntype = tsubst_function_type (t, args, complain, in_decl);
9347 if (fntype == error_mark_node)
9348 return error_mark_node;
9350 /* Substitute the exception specification. */
9351 specs = tsubst_exception_specification (t, args, complain,
9353 if (specs == error_mark_node)
9354 return error_mark_node;
9356 fntype = build_exception_variant (fntype, specs);
9361 tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
9362 if (domain == error_mark_node)
9363 return error_mark_node;
9365 /* As an optimization, we avoid regenerating the array type if
9366 it will obviously be the same as T. */
9367 if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
9370 /* These checks should match the ones in grokdeclarator.
9374 The deduction may fail for any of the following reasons:
9376 -- Attempting to create an array with an element type that
9377 is void, a function type, or a reference type, or [DR337]
9378 an abstract class type. */
9379 if (TREE_CODE (type) == VOID_TYPE
9380 || TREE_CODE (type) == FUNCTION_TYPE
9381 || TREE_CODE (type) == REFERENCE_TYPE)
9383 if (complain & tf_error)
9384 error ("creating array of %qT", type);
9385 return error_mark_node;
9387 if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
9389 if (complain & tf_error)
9390 error ("creating array of %qT, which is an abstract class type",
9392 return error_mark_node;
9395 r = build_cplus_array_type (type, domain);
9397 if (TYPE_USER_ALIGN (t))
9399 TYPE_ALIGN (r) = TYPE_ALIGN (t);
9400 TYPE_USER_ALIGN (r) = 1;
9409 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
9410 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
9412 if (e1 == error_mark_node || e2 == error_mark_node)
9413 return error_mark_node;
9415 return fold_build2 (TREE_CODE (t), TREE_TYPE (t), e1, e2);
9421 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
9422 if (e == error_mark_node)
9423 return error_mark_node;
9425 return fold_build1 (TREE_CODE (t), TREE_TYPE (t), e);
9430 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
9431 in_decl, /*entering_scope=*/1);
9432 tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
9435 if (ctx == error_mark_node || f == error_mark_node)
9436 return error_mark_node;
9438 if (!MAYBE_CLASS_TYPE_P (ctx))
9440 if (complain & tf_error)
9441 error ("%qT is not a class, struct, or union type", ctx);
9442 return error_mark_node;
9444 else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
9446 /* Normally, make_typename_type does not require that the CTX
9447 have complete type in order to allow things like:
9449 template <class T> struct S { typename S<T>::X Y; };
9451 But, such constructs have already been resolved by this
9452 point, so here CTX really should have complete type, unless
9453 it's a partial instantiation. */
9454 ctx = complete_type (ctx);
9455 if (!COMPLETE_TYPE_P (ctx))
9457 if (complain & tf_error)
9458 cxx_incomplete_type_error (NULL_TREE, ctx);
9459 return error_mark_node;
9463 f = make_typename_type (ctx, f, typename_type,
9464 (complain & tf_error) | tf_keep_type_decl);
9465 if (f == error_mark_node)
9467 if (TREE_CODE (f) == TYPE_DECL)
9469 complain |= tf_ignore_bad_quals;
9473 if (TREE_CODE (f) != TYPENAME_TYPE)
9475 if (TYPENAME_IS_ENUM_P (t) && TREE_CODE (f) != ENUMERAL_TYPE)
9476 error ("%qT resolves to %qT, which is not an enumeration type",
9478 else if (TYPENAME_IS_CLASS_P (t) && !CLASS_TYPE_P (f))
9479 error ("%qT resolves to %qT, which is is not a class type",
9483 return cp_build_qualified_type_real
9484 (f, cp_type_quals (f) | cp_type_quals (t), complain);
9487 case UNBOUND_CLASS_TEMPLATE:
9489 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
9490 in_decl, /*entering_scope=*/1);
9491 tree name = TYPE_IDENTIFIER (t);
9492 tree parm_list = DECL_TEMPLATE_PARMS (TYPE_NAME (t));
9494 if (ctx == error_mark_node || name == error_mark_node)
9495 return error_mark_node;
9498 parm_list = tsubst_template_parms (parm_list, args, complain);
9499 return make_unbound_class_template (ctx, name, parm_list, complain);
9509 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
9510 tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl,
9511 /*integral_constant_expression_p=*/false);
9512 if (e1 == error_mark_node || e2 == error_mark_node)
9513 return error_mark_node;
9515 return build_nt (ARRAY_REF, e1, e2, NULL_TREE, NULL_TREE);
9520 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
9521 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
9522 if (e1 == error_mark_node || e2 == error_mark_node)
9523 return error_mark_node;
9525 return build_qualified_name (/*type=*/NULL_TREE,
9526 e1, e2, QUALIFIED_NAME_IS_TEMPLATE (t));
9533 type = finish_typeof (tsubst_expr
9534 (TYPEOF_TYPE_EXPR (t), args,
9536 /*integral_constant_expression_p=*/false));
9537 return cp_build_qualified_type_real (type,
9539 | cp_type_quals (type),
9548 finish_decltype_type (tsubst_expr
9549 (DECLTYPE_TYPE_EXPR (t), args,
9551 /*integral_constant_expression_p=*/false),
9552 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t));
9553 return cp_build_qualified_type_real (type,
9555 | cp_type_quals (type),
9559 case TYPE_ARGUMENT_PACK:
9560 case NONTYPE_ARGUMENT_PACK:
9562 tree r = make_node (TREE_CODE (t));
9564 tsubst_template_args (ARGUMENT_PACK_ARGS (t),
9568 SET_ARGUMENT_PACK_ARGS (r, packed_out);
9570 /* For template nontype argument packs, also substitute into
9572 if (TREE_CODE (t) == NONTYPE_ARGUMENT_PACK)
9573 TREE_TYPE (r) = tsubst (TREE_TYPE (t), args, complain, in_decl);
9580 sorry ("use of %qs in template",
9581 tree_code_name [(int) TREE_CODE (t)]);
9582 return error_mark_node;
9586 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
9587 type of the expression on the left-hand side of the "." or "->"
9591 tsubst_baselink (tree baselink, tree object_type,
9592 tree args, tsubst_flags_t complain, tree in_decl)
9595 tree qualifying_scope;
9598 tree template_args = 0;
9599 bool template_id_p = false;
9601 /* A baselink indicates a function from a base class. Both the
9602 BASELINK_ACCESS_BINFO and the base class referenced may
9603 indicate bases of the template class, rather than the
9604 instantiated class. In addition, lookups that were not
9605 ambiguous before may be ambiguous now. Therefore, we perform
9606 the lookup again. */
9607 qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink));
9608 qualifying_scope = tsubst (qualifying_scope, args,
9610 fns = BASELINK_FUNCTIONS (baselink);
9611 optype = BASELINK_OPTYPE (baselink);
9612 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
9614 template_id_p = true;
9615 template_args = TREE_OPERAND (fns, 1);
9616 fns = TREE_OPERAND (fns, 0);
9618 template_args = tsubst_template_args (template_args, args,
9621 name = DECL_NAME (get_first_fn (fns));
9622 baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1);
9624 /* If lookup found a single function, mark it as used at this
9625 point. (If it lookup found multiple functions the one selected
9626 later by overload resolution will be marked as used at that
9628 if (BASELINK_P (baselink))
9629 fns = BASELINK_FUNCTIONS (baselink);
9630 if (!template_id_p && !really_overloaded_fn (fns))
9631 mark_used (OVL_CURRENT (fns));
9633 /* Add back the template arguments, if present. */
9634 if (BASELINK_P (baselink) && template_id_p)
9635 BASELINK_FUNCTIONS (baselink)
9636 = build_nt (TEMPLATE_ID_EXPR,
9637 BASELINK_FUNCTIONS (baselink),
9639 /* Update the conversion operator type. */
9640 BASELINK_OPTYPE (baselink)
9641 = tsubst (optype, args, complain, in_decl);
9644 object_type = current_class_type;
9645 return adjust_result_of_qualified_name_lookup (baselink,
9650 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
9651 true if the qualified-id will be a postfix-expression in-and-of
9652 itself; false if more of the postfix-expression follows the
9653 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
9657 tsubst_qualified_id (tree qualified_id, tree args,
9658 tsubst_flags_t complain, tree in_decl,
9659 bool done, bool address_p)
9667 gcc_assert (TREE_CODE (qualified_id) == SCOPE_REF);
9669 /* Figure out what name to look up. */
9670 name = TREE_OPERAND (qualified_id, 1);
9671 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
9674 template_args = TREE_OPERAND (name, 1);
9676 template_args = tsubst_template_args (template_args, args,
9678 name = TREE_OPERAND (name, 0);
9682 is_template = false;
9683 template_args = NULL_TREE;
9686 /* Substitute into the qualifying scope. When there are no ARGS, we
9687 are just trying to simplify a non-dependent expression. In that
9688 case the qualifying scope may be dependent, and, in any case,
9689 substituting will not help. */
9690 scope = TREE_OPERAND (qualified_id, 0);
9693 scope = tsubst (scope, args, complain, in_decl);
9694 expr = tsubst_copy (name, args, complain, in_decl);
9699 if (dependent_type_p (scope))
9700 return build_qualified_name (/*type=*/NULL_TREE,
9702 QUALIFIED_NAME_IS_TEMPLATE (qualified_id));
9704 if (!BASELINK_P (name) && !DECL_P (expr))
9706 if (TREE_CODE (expr) == BIT_NOT_EXPR)
9707 /* If this were actually a destructor call, it would have been
9708 parsed as such by the parser. */
9709 expr = error_mark_node;
9711 expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0, false);
9712 if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL
9713 ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL)
9715 if (complain & tf_error)
9717 error ("dependent-name %qE is parsed as a non-type, but "
9718 "instantiation yields a type", qualified_id);
9719 inform ("say %<typename %E%> if a type is meant", qualified_id);
9721 return error_mark_node;
9727 check_accessibility_of_qualified_id (expr, /*object_type=*/NULL_TREE,
9729 /* Remember that there was a reference to this entity. */
9733 if (expr == error_mark_node || TREE_CODE (expr) == TREE_LIST)
9735 if (complain & tf_error)
9736 qualified_name_lookup_error (scope,
9737 TREE_OPERAND (qualified_id, 1),
9738 expr, input_location);
9739 return error_mark_node;
9743 expr = lookup_template_function (expr, template_args);
9745 if (expr == error_mark_node && complain & tf_error)
9746 qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1),
9747 expr, input_location);
9748 else if (TYPE_P (scope))
9750 expr = (adjust_result_of_qualified_name_lookup
9751 (expr, scope, current_class_type));
9752 expr = (finish_qualified_id_expr
9753 (scope, expr, done, address_p,
9754 QUALIFIED_NAME_IS_TEMPLATE (qualified_id),
9755 /*template_arg_p=*/false));
9758 /* Expressions do not generally have reference type. */
9759 if (TREE_CODE (expr) != SCOPE_REF
9760 /* However, if we're about to form a pointer-to-member, we just
9761 want the referenced member referenced. */
9762 && TREE_CODE (expr) != OFFSET_REF)
9763 expr = convert_from_reference (expr);
9768 /* Like tsubst, but deals with expressions. This function just replaces
9769 template parms; to finish processing the resultant expression, use
9773 tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
9775 enum tree_code code;
9778 if (t == NULL_TREE || t == error_mark_node)
9781 code = TREE_CODE (t);
9786 r = retrieve_local_specialization (t);
9787 gcc_assert (r != NULL);
9788 if (TREE_CODE (r) == ARGUMENT_PACK_SELECT)
9789 r = ARGUMENT_PACK_SELECT_ARG (r);
9798 if (DECL_TEMPLATE_PARM_P (t))
9799 return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
9800 /* There is no need to substitute into namespace-scope
9802 if (DECL_NAMESPACE_SCOPE_P (t))
9804 /* If ARGS is NULL, then T is known to be non-dependent. */
9805 if (args == NULL_TREE)
9806 return integral_constant_value (t);
9808 /* Unfortunately, we cannot just call lookup_name here.
9811 template <int I> int f() {
9813 struct S { void g() { E e = a; } };
9816 When we instantiate f<7>::S::g(), say, lookup_name is not
9817 clever enough to find f<7>::a. */
9819 = tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl,
9820 /*entering_scope=*/0);
9822 for (v = TYPE_VALUES (enum_type);
9825 if (TREE_PURPOSE (v) == DECL_NAME (t))
9826 return TREE_VALUE (v);
9828 /* We didn't find the name. That should never happen; if
9829 name-lookup found it during preliminary parsing, we
9830 should find it again here during instantiation. */
9836 if (DECL_CONTEXT (t))
9840 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
9841 /*entering_scope=*/1);
9842 if (ctx != DECL_CONTEXT (t))
9844 tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
9847 if (complain & tf_error)
9848 error ("using invalid field %qD", t);
9849 return error_mark_node;
9859 if ((DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
9860 || local_variable_p (t))
9861 t = tsubst (t, args, complain, in_decl);
9866 return tsubst_baselink (t, current_class_type, args, complain, in_decl);
9869 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
9870 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
9871 args, complain, in_decl);
9872 else if (DECL_FUNCTION_TEMPLATE_P (t) && DECL_MEMBER_TEMPLATE_P (t))
9873 return tsubst (t, args, complain, in_decl);
9874 else if (DECL_CLASS_SCOPE_P (t)
9875 && uses_template_parms (DECL_CONTEXT (t)))
9877 /* Template template argument like the following example need
9880 template <template <class> class TT> struct C {};
9881 template <class T> struct D {
9882 template <class U> struct E {};
9887 We are processing the template argument `E' in #1 for
9888 the template instantiation #2. Originally, `E' is a
9889 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
9890 have to substitute this with one having context `D<int>'. */
9892 tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
9893 return lookup_field (context, DECL_NAME(t), 0, false);
9896 /* Ordinary template template argument. */
9900 case REINTERPRET_CAST_EXPR:
9901 case CONST_CAST_EXPR:
9902 case STATIC_CAST_EXPR:
9903 case DYNAMIC_CAST_EXPR:
9906 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
9907 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
9910 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
9912 /* We only want to compute the number of arguments. */
9913 tree expanded = tsubst_pack_expansion (TREE_OPERAND (t, 0), args,
9917 if (TREE_CODE (expanded) == TREE_VEC)
9918 len = TREE_VEC_LENGTH (expanded);
9920 if (expanded == error_mark_node)
9921 return error_mark_node;
9922 else if (PACK_EXPANSION_P (expanded)
9923 || (TREE_CODE (expanded) == TREE_VEC
9925 && PACK_EXPANSION_P (TREE_VEC_ELT (expanded, len-1))))
9927 if (TREE_CODE (expanded) == TREE_VEC)
9928 expanded = TREE_VEC_ELT (expanded, len - 1);
9930 if (TYPE_P (expanded))
9931 return cxx_sizeof_or_alignof_type (expanded, SIZEOF_EXPR,
9932 complain & tf_error);
9934 return cxx_sizeof_or_alignof_expr (expanded, SIZEOF_EXPR,
9935 complain & tf_error);
9938 return build_int_cst (size_type_node, len);
9944 case TRUTH_NOT_EXPR:
9947 case UNARY_PLUS_EXPR: /* Unary + */
9955 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
9956 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
9963 object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
9964 name = TREE_OPERAND (t, 1);
9965 if (TREE_CODE (name) == BIT_NOT_EXPR)
9967 name = tsubst_copy (TREE_OPERAND (name, 0), args,
9969 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
9971 else if (TREE_CODE (name) == SCOPE_REF
9972 && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
9974 tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
9976 name = TREE_OPERAND (name, 1);
9977 name = tsubst_copy (TREE_OPERAND (name, 0), args,
9979 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
9980 name = build_qualified_name (/*type=*/NULL_TREE,
9982 /*template_p=*/false);
9984 else if (TREE_CODE (name) == BASELINK)
9985 name = tsubst_baselink (name,
9986 non_reference (TREE_TYPE (object)),
9990 name = tsubst_copy (name, args, complain, in_decl);
9991 return build_nt (COMPONENT_REF, object, name, NULL_TREE);
9997 case TRUNC_DIV_EXPR:
9999 case FLOOR_DIV_EXPR:
10000 case ROUND_DIV_EXPR:
10001 case EXACT_DIV_EXPR:
10005 case TRUNC_MOD_EXPR:
10006 case FLOOR_MOD_EXPR:
10007 case TRUTH_ANDIF_EXPR:
10008 case TRUTH_ORIF_EXPR:
10009 case TRUTH_AND_EXPR:
10010 case TRUTH_OR_EXPR:
10023 case COMPOUND_EXPR:
10026 case PREDECREMENT_EXPR:
10027 case PREINCREMENT_EXPR:
10028 case POSTDECREMENT_EXPR:
10029 case POSTINCREMENT_EXPR:
10031 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
10032 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
10035 return build_qualified_name (/*type=*/NULL_TREE,
10036 tsubst_copy (TREE_OPERAND (t, 0),
10037 args, complain, in_decl),
10038 tsubst_copy (TREE_OPERAND (t, 1),
10039 args, complain, in_decl),
10040 QUALIFIED_NAME_IS_TEMPLATE (t));
10045 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
10046 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
10047 NULL_TREE, NULL_TREE);
10051 int n = VL_EXP_OPERAND_LENGTH (t);
10052 tree result = build_vl_exp (CALL_EXPR, n);
10054 for (i = 0; i < n; i++)
10055 TREE_OPERAND (t, i) = tsubst_copy (TREE_OPERAND (t, i), args,
10056 complain, in_decl);
10062 case PSEUDO_DTOR_EXPR:
10065 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
10066 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
10067 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
10068 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
10075 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
10076 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
10077 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
10078 NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
10085 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
10086 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
10087 DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
10088 DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
10092 case TEMPLATE_ID_EXPR:
10094 /* Substituted template arguments */
10095 tree fn = TREE_OPERAND (t, 0);
10096 tree targs = TREE_OPERAND (t, 1);
10098 fn = tsubst_copy (fn, args, complain, in_decl);
10100 targs = tsubst_template_args (targs, args, complain, in_decl);
10102 return lookup_template_function (fn, targs);
10107 tree purpose, value, chain;
10109 if (t == void_list_node)
10112 purpose = TREE_PURPOSE (t);
10114 purpose = tsubst_copy (purpose, args, complain, in_decl);
10115 value = TREE_VALUE (t);
10117 value = tsubst_copy (value, args, complain, in_decl);
10118 chain = TREE_CHAIN (t);
10119 if (chain && chain != void_type_node)
10120 chain = tsubst_copy (chain, args, complain, in_decl);
10121 if (purpose == TREE_PURPOSE (t)
10122 && value == TREE_VALUE (t)
10123 && chain == TREE_CHAIN (t))
10125 return tree_cons (purpose, value, chain);
10130 case ENUMERAL_TYPE:
10132 case TEMPLATE_TYPE_PARM:
10133 case TEMPLATE_TEMPLATE_PARM:
10134 case BOUND_TEMPLATE_TEMPLATE_PARM:
10135 case TEMPLATE_PARM_INDEX:
10137 case REFERENCE_TYPE:
10139 case FUNCTION_TYPE:
10142 case TYPENAME_TYPE:
10143 case UNBOUND_CLASS_TEMPLATE:
10145 case DECLTYPE_TYPE:
10147 return tsubst (t, args, complain, in_decl);
10149 case IDENTIFIER_NODE:
10150 if (IDENTIFIER_TYPENAME_P (t))
10152 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10153 return mangle_conv_op_name_for_type (new_type);
10159 /* This is handled by tsubst_copy_and_build. */
10160 gcc_unreachable ();
10163 return build_x_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain,
10165 tsubst (TREE_TYPE (t), args, complain, in_decl));
10167 case CLEANUP_POINT_EXPR:
10168 /* We shouldn't have built any of these during initial template
10169 generation. Instead, they should be built during instantiation
10170 in response to the saved STMT_IS_FULL_EXPR_P setting. */
10171 gcc_unreachable ();
10174 mark_used (TREE_OPERAND (t, 1));
10177 case EXPR_PACK_EXPANSION:
10178 error ("invalid use of pack expansion expression");
10179 return error_mark_node;
10181 case NONTYPE_ARGUMENT_PACK:
10182 error ("use %<...%> to expand argument pack");
10183 return error_mark_node;
10190 /* Like tsubst_copy, but specifically for OpenMP clauses. */
10193 tsubst_omp_clauses (tree clauses, tree args, tsubst_flags_t complain,
10196 tree new_clauses = NULL, nc, oc;
10198 for (oc = clauses; oc ; oc = OMP_CLAUSE_CHAIN (oc))
10200 nc = copy_node (oc);
10201 OMP_CLAUSE_CHAIN (nc) = new_clauses;
10204 switch (OMP_CLAUSE_CODE (nc))
10206 case OMP_CLAUSE_LASTPRIVATE:
10207 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc))
10209 OMP_CLAUSE_LASTPRIVATE_STMT (nc) = push_stmt_list ();
10210 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc), args, complain,
10211 in_decl, /*integral_constant_expression_p=*/false);
10212 OMP_CLAUSE_LASTPRIVATE_STMT (nc)
10213 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc));
10216 case OMP_CLAUSE_PRIVATE:
10217 case OMP_CLAUSE_SHARED:
10218 case OMP_CLAUSE_FIRSTPRIVATE:
10219 case OMP_CLAUSE_REDUCTION:
10220 case OMP_CLAUSE_COPYIN:
10221 case OMP_CLAUSE_COPYPRIVATE:
10222 case OMP_CLAUSE_IF:
10223 case OMP_CLAUSE_NUM_THREADS:
10224 case OMP_CLAUSE_SCHEDULE:
10225 case OMP_CLAUSE_COLLAPSE:
10226 OMP_CLAUSE_OPERAND (nc, 0)
10227 = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 0), args, complain,
10228 in_decl, /*integral_constant_expression_p=*/false);
10230 case OMP_CLAUSE_NOWAIT:
10231 case OMP_CLAUSE_ORDERED:
10232 case OMP_CLAUSE_DEFAULT:
10233 case OMP_CLAUSE_UNTIED:
10236 gcc_unreachable ();
10240 return finish_omp_clauses (nreverse (new_clauses));
10243 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
10246 tsubst_copy_asm_operands (tree t, tree args, tsubst_flags_t complain,
10249 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
10251 tree purpose, value, chain;
10256 if (TREE_CODE (t) != TREE_LIST)
10257 return tsubst_copy_and_build (t, args, complain, in_decl,
10258 /*function_p=*/false,
10259 /*integral_constant_expression_p=*/false);
10261 if (t == void_list_node)
10264 purpose = TREE_PURPOSE (t);
10266 purpose = RECUR (purpose);
10267 value = TREE_VALUE (t);
10269 value = RECUR (value);
10270 chain = TREE_CHAIN (t);
10271 if (chain && chain != void_type_node)
10272 chain = RECUR (chain);
10273 return tree_cons (purpose, value, chain);
10277 /* Substitute one OMP_FOR iterator. */
10280 tsubst_omp_for_iterator (tree t, int i, tree declv, tree initv,
10281 tree condv, tree incrv, tree *clauses,
10282 tree args, tsubst_flags_t complain, tree in_decl,
10283 bool integral_constant_expression_p)
10285 #define RECUR(NODE) \
10286 tsubst_expr ((NODE), args, complain, in_decl, \
10287 integral_constant_expression_p)
10288 tree decl, init, cond, incr;
10290 init = TREE_VEC_ELT (OMP_FOR_INIT (t), i);
10291 gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
10292 decl = RECUR (TREE_OPERAND (init, 0));
10293 init = TREE_OPERAND (init, 1);
10294 gcc_assert (!type_dependent_expression_p (decl));
10296 if (!CLASS_TYPE_P (TREE_TYPE (decl)))
10298 cond = RECUR (TREE_VEC_ELT (OMP_FOR_COND (t), i));
10299 incr = TREE_VEC_ELT (OMP_FOR_INCR (t), i);
10300 if (TREE_CODE (incr) == MODIFY_EXPR)
10301 incr = build_x_modify_expr (RECUR (TREE_OPERAND (incr, 0)), NOP_EXPR,
10302 RECUR (TREE_OPERAND (incr, 1)),
10305 incr = RECUR (incr);
10306 TREE_VEC_ELT (declv, i) = decl;
10307 TREE_VEC_ELT (initv, i) = init;
10308 TREE_VEC_ELT (condv, i) = cond;
10309 TREE_VEC_ELT (incrv, i) = incr;
10313 if (init && TREE_CODE (init) != DECL_EXPR)
10316 for (c = *clauses; c ; c = OMP_CLAUSE_CHAIN (c))
10318 if ((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_PRIVATE
10319 || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE)
10320 && OMP_CLAUSE_DECL (c) == decl)
10322 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
10323 && OMP_CLAUSE_DECL (c) == decl)
10324 error ("iteration variable %qD should not be firstprivate", decl);
10325 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
10326 && OMP_CLAUSE_DECL (c) == decl)
10327 error ("iteration variable %qD should not be reduction", decl);
10331 c = build_omp_clause (OMP_CLAUSE_PRIVATE);
10332 OMP_CLAUSE_DECL (c) = decl;
10333 c = finish_omp_clauses (c);
10336 OMP_CLAUSE_CHAIN (c) = *clauses;
10341 cond = TREE_VEC_ELT (OMP_FOR_COND (t), i);
10342 if (COMPARISON_CLASS_P (cond))
10343 cond = build2 (TREE_CODE (cond), boolean_type_node,
10344 RECUR (TREE_OPERAND (cond, 0)),
10345 RECUR (TREE_OPERAND (cond, 1)));
10347 cond = RECUR (cond);
10348 incr = TREE_VEC_ELT (OMP_FOR_INCR (t), i);
10349 switch (TREE_CODE (incr))
10351 case PREINCREMENT_EXPR:
10352 case PREDECREMENT_EXPR:
10353 case POSTINCREMENT_EXPR:
10354 case POSTDECREMENT_EXPR:
10355 incr = build2 (TREE_CODE (incr), TREE_TYPE (decl),
10356 RECUR (TREE_OPERAND (incr, 0)), NULL_TREE);
10359 if (TREE_CODE (TREE_OPERAND (incr, 1)) == PLUS_EXPR
10360 || TREE_CODE (TREE_OPERAND (incr, 1)) == MINUS_EXPR)
10362 tree rhs = TREE_OPERAND (incr, 1);
10363 incr = build2 (MODIFY_EXPR, TREE_TYPE (decl),
10364 RECUR (TREE_OPERAND (incr, 0)),
10365 build2 (TREE_CODE (rhs), TREE_TYPE (decl),
10366 RECUR (TREE_OPERAND (rhs, 0)),
10367 RECUR (TREE_OPERAND (rhs, 1))));
10370 incr = RECUR (incr);
10373 if (TREE_CODE (TREE_OPERAND (incr, 1)) == PLUS_EXPR
10374 || TREE_CODE (TREE_OPERAND (incr, 1)) == MINUS_EXPR)
10376 tree lhs = RECUR (TREE_OPERAND (incr, 0));
10377 incr = build2 (MODIFY_EXPR, TREE_TYPE (decl), lhs,
10378 build2 (TREE_CODE (TREE_OPERAND (incr, 1)),
10379 TREE_TYPE (decl), lhs,
10380 RECUR (TREE_OPERAND (incr, 2))));
10382 else if (TREE_CODE (TREE_OPERAND (incr, 1)) == NOP_EXPR
10383 && (TREE_CODE (TREE_OPERAND (incr, 2)) == PLUS_EXPR
10384 || (TREE_CODE (TREE_OPERAND (incr, 2)) == MINUS_EXPR)))
10386 tree rhs = TREE_OPERAND (incr, 2);
10387 incr = build2 (MODIFY_EXPR, TREE_TYPE (decl),
10388 RECUR (TREE_OPERAND (incr, 0)),
10389 build2 (TREE_CODE (rhs), TREE_TYPE (decl),
10390 RECUR (TREE_OPERAND (rhs, 0)),
10391 RECUR (TREE_OPERAND (rhs, 1))));
10394 incr = RECUR (incr);
10397 incr = RECUR (incr);
10401 TREE_VEC_ELT (declv, i) = decl;
10402 TREE_VEC_ELT (initv, i) = init;
10403 TREE_VEC_ELT (condv, i) = cond;
10404 TREE_VEC_ELT (incrv, i) = incr;
10408 /* Like tsubst_copy for expressions, etc. but also does semantic
10412 tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl,
10413 bool integral_constant_expression_p)
10415 #define RECUR(NODE) \
10416 tsubst_expr ((NODE), args, complain, in_decl, \
10417 integral_constant_expression_p)
10421 if (t == NULL_TREE || t == error_mark_node)
10424 if (EXPR_HAS_LOCATION (t))
10425 input_location = EXPR_LOCATION (t);
10426 if (STATEMENT_CODE_P (TREE_CODE (t)))
10427 current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
10429 switch (TREE_CODE (t))
10431 case STATEMENT_LIST:
10433 tree_stmt_iterator i;
10434 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
10435 RECUR (tsi_stmt (i));
10439 case CTOR_INITIALIZER:
10440 finish_mem_initializers (tsubst_initializer_list
10441 (TREE_OPERAND (t, 0), args));
10445 finish_return_stmt (RECUR (TREE_OPERAND (t, 0)));
10449 tmp = RECUR (EXPR_STMT_EXPR (t));
10450 if (EXPR_STMT_STMT_EXPR_RESULT (t))
10451 finish_stmt_expr_expr (tmp, cur_stmt_expr);
10453 finish_expr_stmt (tmp);
10457 do_using_directive (RECUR (USING_STMT_NAMESPACE (t)));
10465 decl = DECL_EXPR_DECL (t);
10466 if (TREE_CODE (decl) == LABEL_DECL)
10467 finish_label_decl (DECL_NAME (decl));
10468 else if (TREE_CODE (decl) == USING_DECL)
10470 tree scope = USING_DECL_SCOPE (decl);
10471 tree name = DECL_NAME (decl);
10474 scope = RECUR (scope);
10475 decl = lookup_qualified_name (scope, name,
10476 /*is_type_p=*/false,
10477 /*complain=*/false);
10478 if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
10479 qualified_name_lookup_error (scope, name, decl, input_location);
10481 do_local_using_decl (decl, scope, name);
10485 init = DECL_INITIAL (decl);
10486 decl = tsubst (decl, args, complain, in_decl);
10487 if (decl != error_mark_node)
10489 /* By marking the declaration as instantiated, we avoid
10490 trying to instantiate it. Since instantiate_decl can't
10491 handle local variables, and since we've already done
10492 all that needs to be done, that's the right thing to
10494 if (TREE_CODE (decl) == VAR_DECL)
10495 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
10496 if (TREE_CODE (decl) == VAR_DECL
10497 && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
10498 /* Anonymous aggregates are a special case. */
10499 finish_anon_union (decl);
10502 maybe_push_decl (decl);
10503 if (TREE_CODE (decl) == VAR_DECL
10504 && DECL_PRETTY_FUNCTION_P (decl))
10506 /* For __PRETTY_FUNCTION__ we have to adjust the
10508 const char *const name
10509 = cxx_printable_name (current_function_decl, 2);
10510 init = cp_fname_init (name, &TREE_TYPE (decl));
10514 tree t = RECUR (init);
10517 /* If we had an initializer but it
10518 instantiated to nothing,
10519 value-initialize the object. This will
10520 only occur when the initializer was a
10521 pack expansion where the parameter packs
10522 used in that expansion were of length
10524 init = build_default_init (TREE_TYPE (decl),
10530 finish_decl (decl, init, NULL_TREE);
10535 /* A DECL_EXPR can also be used as an expression, in the condition
10536 clause of an if/for/while construct. */
10541 stmt = begin_for_stmt ();
10542 RECUR (FOR_INIT_STMT (t));
10543 finish_for_init_stmt (stmt);
10544 tmp = RECUR (FOR_COND (t));
10545 finish_for_cond (tmp, stmt);
10546 tmp = RECUR (FOR_EXPR (t));
10547 finish_for_expr (tmp, stmt);
10548 RECUR (FOR_BODY (t));
10549 finish_for_stmt (stmt);
10553 stmt = begin_while_stmt ();
10554 tmp = RECUR (WHILE_COND (t));
10555 finish_while_stmt_cond (tmp, stmt);
10556 RECUR (WHILE_BODY (t));
10557 finish_while_stmt (stmt);
10561 stmt = begin_do_stmt ();
10562 RECUR (DO_BODY (t));
10563 finish_do_body (stmt);
10564 tmp = RECUR (DO_COND (t));
10565 finish_do_stmt (tmp, stmt);
10569 stmt = begin_if_stmt ();
10570 tmp = RECUR (IF_COND (t));
10571 finish_if_stmt_cond (tmp, stmt);
10572 RECUR (THEN_CLAUSE (t));
10573 finish_then_clause (stmt);
10575 if (ELSE_CLAUSE (t))
10577 begin_else_clause (stmt);
10578 RECUR (ELSE_CLAUSE (t));
10579 finish_else_clause (stmt);
10582 finish_if_stmt (stmt);
10586 if (BIND_EXPR_BODY_BLOCK (t))
10587 stmt = begin_function_body ();
10589 stmt = begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t)
10590 ? BCS_TRY_BLOCK : 0);
10592 RECUR (BIND_EXPR_BODY (t));
10594 if (BIND_EXPR_BODY_BLOCK (t))
10595 finish_function_body (stmt);
10597 finish_compound_stmt (stmt);
10601 finish_break_stmt ();
10604 case CONTINUE_STMT:
10605 finish_continue_stmt ();
10609 stmt = begin_switch_stmt ();
10610 tmp = RECUR (SWITCH_STMT_COND (t));
10611 finish_switch_cond (tmp, stmt);
10612 RECUR (SWITCH_STMT_BODY (t));
10613 finish_switch_stmt (stmt);
10616 case CASE_LABEL_EXPR:
10617 finish_case_label (RECUR (CASE_LOW (t)),
10618 RECUR (CASE_HIGH (t)));
10622 finish_label_stmt (DECL_NAME (LABEL_EXPR_LABEL (t)));
10626 tmp = GOTO_DESTINATION (t);
10627 if (TREE_CODE (tmp) != LABEL_DECL)
10628 /* Computed goto's must be tsubst'd into. On the other hand,
10629 non-computed gotos must not be; the identifier in question
10630 will have no binding. */
10633 tmp = DECL_NAME (tmp);
10634 finish_goto_stmt (tmp);
10638 tmp = finish_asm_stmt
10639 (ASM_VOLATILE_P (t),
10640 RECUR (ASM_STRING (t)),
10641 tsubst_copy_asm_operands (ASM_OUTPUTS (t), args, complain, in_decl),
10642 tsubst_copy_asm_operands (ASM_INPUTS (t), args, complain, in_decl),
10643 tsubst_copy_asm_operands (ASM_CLOBBERS (t), args, complain, in_decl));
10645 tree asm_expr = tmp;
10646 if (TREE_CODE (asm_expr) == CLEANUP_POINT_EXPR)
10647 asm_expr = TREE_OPERAND (asm_expr, 0);
10648 ASM_INPUT_P (asm_expr) = ASM_INPUT_P (t);
10655 stmt = begin_try_block ();
10656 RECUR (TRY_STMTS (t));
10657 finish_cleanup_try_block (stmt);
10658 finish_cleanup (RECUR (TRY_HANDLERS (t)), stmt);
10662 tree compound_stmt = NULL_TREE;
10664 if (FN_TRY_BLOCK_P (t))
10665 stmt = begin_function_try_block (&compound_stmt);
10667 stmt = begin_try_block ();
10669 RECUR (TRY_STMTS (t));
10671 if (FN_TRY_BLOCK_P (t))
10672 finish_function_try_block (stmt);
10674 finish_try_block (stmt);
10676 RECUR (TRY_HANDLERS (t));
10677 if (FN_TRY_BLOCK_P (t))
10678 finish_function_handler_sequence (stmt, compound_stmt);
10680 finish_handler_sequence (stmt);
10686 tree decl = HANDLER_PARMS (t);
10690 decl = tsubst (decl, args, complain, in_decl);
10691 /* Prevent instantiate_decl from trying to instantiate
10692 this variable. We've already done all that needs to be
10694 if (decl != error_mark_node)
10695 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
10697 stmt = begin_handler ();
10698 finish_handler_parms (decl, stmt);
10699 RECUR (HANDLER_BODY (t));
10700 finish_handler (stmt);
10705 tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
10708 case STATIC_ASSERT:
10711 tsubst_expr (STATIC_ASSERT_CONDITION (t),
10714 /*integral_constant_expression_p=*/true);
10715 finish_static_assert (condition,
10716 STATIC_ASSERT_MESSAGE (t),
10717 STATIC_ASSERT_SOURCE_LOCATION (t),
10718 /*member_p=*/false);
10723 tmp = tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t),
10724 args, complain, in_decl);
10725 stmt = begin_omp_parallel ();
10726 RECUR (OMP_PARALLEL_BODY (t));
10727 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp, stmt))
10728 = OMP_PARALLEL_COMBINED (t);
10732 tmp = tsubst_omp_clauses (OMP_TASK_CLAUSES (t),
10733 args, complain, in_decl);
10734 stmt = begin_omp_task ();
10735 RECUR (OMP_TASK_BODY (t));
10736 finish_omp_task (tmp, stmt);
10741 tree clauses, body, pre_body;
10742 tree declv, initv, condv, incrv;
10745 clauses = tsubst_omp_clauses (OMP_FOR_CLAUSES (t),
10746 args, complain, in_decl);
10747 declv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
10748 initv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
10749 condv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
10750 incrv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
10752 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (t)); i++)
10753 tsubst_omp_for_iterator (t, i, declv, initv, condv, incrv,
10754 &clauses, args, complain, in_decl,
10755 integral_constant_expression_p);
10757 stmt = begin_omp_structured_block ();
10759 for (i = 0; i < TREE_VEC_LENGTH (initv); i++)
10760 if (TREE_VEC_ELT (initv, i) == NULL
10761 || TREE_CODE (TREE_VEC_ELT (initv, i)) != DECL_EXPR)
10762 TREE_VEC_ELT (initv, i) = RECUR (TREE_VEC_ELT (initv, i));
10763 else if (CLASS_TYPE_P (TREE_TYPE (TREE_VEC_ELT (initv, i))))
10765 tree init = RECUR (TREE_VEC_ELT (initv, i));
10766 gcc_assert (init == TREE_VEC_ELT (declv, i));
10767 TREE_VEC_ELT (initv, i) = NULL_TREE;
10771 tree decl_expr = TREE_VEC_ELT (initv, i);
10772 tree init = DECL_INITIAL (DECL_EXPR_DECL (decl_expr));
10773 gcc_assert (init != NULL);
10774 TREE_VEC_ELT (initv, i) = RECUR (init);
10775 DECL_INITIAL (DECL_EXPR_DECL (decl_expr)) = NULL;
10777 DECL_INITIAL (DECL_EXPR_DECL (decl_expr)) = init;
10780 pre_body = push_stmt_list ();
10781 RECUR (OMP_FOR_PRE_BODY (t));
10782 pre_body = pop_stmt_list (pre_body);
10784 body = push_stmt_list ();
10785 RECUR (OMP_FOR_BODY (t));
10786 body = pop_stmt_list (body);
10788 t = finish_omp_for (EXPR_LOCATION (t), declv, initv, condv, incrv,
10789 body, pre_body, clauses);
10791 add_stmt (finish_omp_structured_block (stmt));
10797 tmp = tsubst_omp_clauses (OMP_CLAUSES (t), args, complain, in_decl);
10798 stmt = push_stmt_list ();
10799 RECUR (OMP_BODY (t));
10800 stmt = pop_stmt_list (stmt);
10803 OMP_BODY (t) = stmt;
10804 OMP_CLAUSES (t) = tmp;
10812 stmt = push_stmt_list ();
10813 RECUR (OMP_BODY (t));
10814 stmt = pop_stmt_list (stmt);
10817 OMP_BODY (t) = stmt;
10822 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t));
10824 tree op1 = TREE_OPERAND (t, 1);
10825 tree lhs = RECUR (TREE_OPERAND (op1, 0));
10826 tree rhs = RECUR (TREE_OPERAND (op1, 1));
10827 finish_omp_atomic (TREE_CODE (op1), lhs, rhs);
10831 case EXPR_PACK_EXPANSION:
10832 error ("invalid use of pack expansion expression");
10833 return error_mark_node;
10835 case NONTYPE_ARGUMENT_PACK:
10836 error ("use %<...%> to expand argument pack");
10837 return error_mark_node;
10840 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t)));
10842 return tsubst_copy_and_build (t, args, complain, in_decl,
10843 /*function_p=*/false,
10844 integral_constant_expression_p);
10851 /* T is a postfix-expression that is not being used in a function
10852 call. Return the substituted version of T. */
10855 tsubst_non_call_postfix_expression (tree t, tree args,
10856 tsubst_flags_t complain,
10859 if (TREE_CODE (t) == SCOPE_REF)
10860 t = tsubst_qualified_id (t, args, complain, in_decl,
10861 /*done=*/false, /*address_p=*/false);
10863 t = tsubst_copy_and_build (t, args, complain, in_decl,
10864 /*function_p=*/false,
10865 /*integral_constant_expression_p=*/false);
10870 /* Like tsubst but deals with expressions and performs semantic
10871 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
10874 tsubst_copy_and_build (tree t,
10876 tsubst_flags_t complain,
10879 bool integral_constant_expression_p)
10881 #define RECUR(NODE) \
10882 tsubst_copy_and_build (NODE, args, complain, in_decl, \
10883 /*function_p=*/false, \
10884 integral_constant_expression_p)
10888 if (t == NULL_TREE || t == error_mark_node)
10891 switch (TREE_CODE (t))
10895 /* Fall through. */
10896 case IDENTIFIER_NODE:
10900 bool non_integral_constant_expression_p;
10901 const char *error_msg;
10903 if (IDENTIFIER_TYPENAME_P (t))
10905 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10906 t = mangle_conv_op_name_for_type (new_type);
10909 /* Look up the name. */
10910 decl = lookup_name (t);
10912 /* By convention, expressions use ERROR_MARK_NODE to indicate
10913 failure, not NULL_TREE. */
10914 if (decl == NULL_TREE)
10915 decl = error_mark_node;
10917 decl = finish_id_expression (t, decl, NULL_TREE,
10919 integral_constant_expression_p,
10920 /*allow_non_integral_constant_expression_p=*/false,
10921 &non_integral_constant_expression_p,
10922 /*template_p=*/false,
10924 /*address_p=*/false,
10925 /*template_arg_p=*/false,
10930 if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE)
10931 decl = unqualified_name_lookup_error (decl);
10935 case TEMPLATE_ID_EXPR:
10938 tree templ = RECUR (TREE_OPERAND (t, 0));
10939 tree targs = TREE_OPERAND (t, 1);
10942 targs = tsubst_template_args (targs, args, complain, in_decl);
10944 if (TREE_CODE (templ) == COMPONENT_REF)
10946 object = TREE_OPERAND (templ, 0);
10947 templ = TREE_OPERAND (templ, 1);
10950 object = NULL_TREE;
10951 templ = lookup_template_function (templ, targs);
10954 return build3 (COMPONENT_REF, TREE_TYPE (templ),
10955 object, templ, NULL_TREE);
10957 return baselink_for_fns (templ);
10962 tree r = RECUR (TREE_OPERAND (t, 0));
10964 if (REFERENCE_REF_P (t))
10966 /* A type conversion to reference type will be enclosed in
10967 such an indirect ref, but the substitution of the cast
10968 will have also added such an indirect ref. */
10969 if (TREE_CODE (TREE_TYPE (r)) == REFERENCE_TYPE)
10970 r = convert_from_reference (r);
10973 r = build_x_indirect_ref (r, "unary *", complain);
10979 (tsubst (TREE_TYPE (t), args, complain, in_decl),
10980 RECUR (TREE_OPERAND (t, 0)));
10983 case REINTERPRET_CAST_EXPR:
10984 case CONST_CAST_EXPR:
10985 case DYNAMIC_CAST_EXPR:
10986 case STATIC_CAST_EXPR:
10991 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10992 if (integral_constant_expression_p
10993 && !cast_valid_in_integral_constant_expression_p (type))
10995 if (complain & tf_error)
10996 error ("a cast to a type other than an integral or "
10997 "enumeration type cannot appear in a constant-expression");
10998 return error_mark_node;
11001 op = RECUR (TREE_OPERAND (t, 0));
11003 switch (TREE_CODE (t))
11006 return build_functional_cast (type, op, complain);
11007 case REINTERPRET_CAST_EXPR:
11008 return build_reinterpret_cast (type, op, complain);
11009 case CONST_CAST_EXPR:
11010 return build_const_cast (type, op, complain);
11011 case DYNAMIC_CAST_EXPR:
11012 return build_dynamic_cast (type, op, complain);
11013 case STATIC_CAST_EXPR:
11014 return build_static_cast (type, op, complain);
11016 gcc_unreachable ();
11020 case POSTDECREMENT_EXPR:
11021 case POSTINCREMENT_EXPR:
11022 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
11023 args, complain, in_decl);
11024 return build_x_unary_op (TREE_CODE (t), op1, complain);
11026 case PREDECREMENT_EXPR:
11027 case PREINCREMENT_EXPR:
11031 case TRUTH_NOT_EXPR:
11032 case UNARY_PLUS_EXPR: /* Unary + */
11033 case REALPART_EXPR:
11034 case IMAGPART_EXPR:
11035 return build_x_unary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0)),
11039 op1 = TREE_OPERAND (t, 0);
11040 if (TREE_CODE (op1) == SCOPE_REF)
11041 op1 = tsubst_qualified_id (op1, args, complain, in_decl,
11042 /*done=*/true, /*address_p=*/true);
11044 op1 = tsubst_non_call_postfix_expression (op1, args, complain,
11046 if (TREE_CODE (op1) == LABEL_DECL)
11047 return finish_label_address_expr (DECL_NAME (op1));
11048 return build_x_unary_op (ADDR_EXPR, op1, complain);
11053 case TRUNC_DIV_EXPR:
11054 case CEIL_DIV_EXPR:
11055 case FLOOR_DIV_EXPR:
11056 case ROUND_DIV_EXPR:
11057 case EXACT_DIV_EXPR:
11061 case TRUNC_MOD_EXPR:
11062 case FLOOR_MOD_EXPR:
11063 case TRUTH_ANDIF_EXPR:
11064 case TRUTH_ORIF_EXPR:
11065 case TRUTH_AND_EXPR:
11066 case TRUTH_OR_EXPR:
11081 return build_x_binary_op
11083 RECUR (TREE_OPERAND (t, 0)),
11084 (TREE_NO_WARNING (TREE_OPERAND (t, 0))
11086 : TREE_CODE (TREE_OPERAND (t, 0))),
11087 RECUR (TREE_OPERAND (t, 1)),
11088 (TREE_NO_WARNING (TREE_OPERAND (t, 1))
11090 : TREE_CODE (TREE_OPERAND (t, 1))),
11091 /*overloaded_p=*/NULL,
11095 return tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
11096 /*address_p=*/false);
11098 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
11099 args, complain, in_decl);
11100 return build_x_binary_op (ARRAY_REF, op1,
11101 (TREE_NO_WARNING (TREE_OPERAND (t, 0))
11103 : TREE_CODE (TREE_OPERAND (t, 0))),
11104 RECUR (TREE_OPERAND (t, 1)),
11105 (TREE_NO_WARNING (TREE_OPERAND (t, 1))
11107 : TREE_CODE (TREE_OPERAND (t, 1))),
11108 /*overloaded_p=*/NULL,
11112 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
11113 return tsubst_copy (t, args, complain, in_decl);
11117 op1 = TREE_OPERAND (t, 0);
11120 /* When there are no ARGS, we are trying to evaluate a
11121 non-dependent expression from the parser. Trying to do
11122 the substitutions may not work. */
11124 op1 = TREE_TYPE (op1);
11129 op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
11130 /*function_p=*/false,
11131 /*integral_constant_expression_p=*/false);
11135 return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t),
11136 complain & tf_error);
11138 return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t),
11139 complain & tf_error);
11143 tree r = build_x_modify_expr
11144 (RECUR (TREE_OPERAND (t, 0)),
11145 TREE_CODE (TREE_OPERAND (t, 1)),
11146 RECUR (TREE_OPERAND (t, 2)),
11148 /* TREE_NO_WARNING must be set if either the expression was
11149 parenthesized or it uses an operator such as >>= rather
11150 than plain assignment. In the former case, it was already
11151 set and must be copied. In the latter case,
11152 build_x_modify_expr sets it and it must not be reset
11154 if (TREE_NO_WARNING (t))
11155 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
11160 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
11161 args, complain, in_decl);
11162 /* Remember that there was a reference to this entity. */
11165 return build_x_arrow (op1);
11169 tree init = RECUR (TREE_OPERAND (t, 3));
11171 if (TREE_OPERAND (t, 3) && !init)
11172 /* If there was an initializer in the original tree, but
11173 it instantiated to an empty list, then we should pass on
11174 VOID_ZERO_NODE to tell build_new that it was an empty
11175 initializer () rather than no initializer. This can only
11176 happen when the initializer is a pack expansion whose
11177 parameter packs are of length zero. */
11178 init = void_zero_node;
11181 (RECUR (TREE_OPERAND (t, 0)),
11182 RECUR (TREE_OPERAND (t, 1)),
11183 RECUR (TREE_OPERAND (t, 2)),
11185 NEW_EXPR_USE_GLOBAL (t),
11190 return delete_sanity
11191 (RECUR (TREE_OPERAND (t, 0)),
11192 RECUR (TREE_OPERAND (t, 1)),
11193 DELETE_EXPR_USE_VEC (t),
11194 DELETE_EXPR_USE_GLOBAL (t));
11196 case COMPOUND_EXPR:
11197 return build_x_compound_expr (RECUR (TREE_OPERAND (t, 0)),
11198 RECUR (TREE_OPERAND (t, 1)),
11208 function = CALL_EXPR_FN (t);
11209 /* When we parsed the expression, we determined whether or
11210 not Koenig lookup should be performed. */
11211 koenig_p = KOENIG_LOOKUP_P (t);
11212 if (TREE_CODE (function) == SCOPE_REF)
11214 qualified_p = true;
11215 function = tsubst_qualified_id (function, args, complain, in_decl,
11217 /*address_p=*/false);
11221 if (TREE_CODE (function) == COMPONENT_REF)
11223 tree op = TREE_OPERAND (function, 1);
11225 qualified_p = (TREE_CODE (op) == SCOPE_REF
11226 || (BASELINK_P (op)
11227 && BASELINK_QUALIFIED_P (op)));
11230 qualified_p = false;
11232 function = tsubst_copy_and_build (function, args, complain,
11235 integral_constant_expression_p);
11237 if (BASELINK_P (function))
11238 qualified_p = true;
11241 /* FIXME: Rewrite this so as not to construct an arglist. */
11242 call_args = RECUR (CALL_EXPR_ARGS (t));
11244 /* We do not perform argument-dependent lookup if normal
11245 lookup finds a non-function, in accordance with the
11246 expected resolution of DR 218. */
11248 && ((is_overloaded_fn (function)
11249 /* If lookup found a member function, the Koenig lookup is
11250 not appropriate, even if an unqualified-name was used
11251 to denote the function. */
11252 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function)))
11253 || TREE_CODE (function) == IDENTIFIER_NODE))
11254 function = perform_koenig_lookup (function, call_args);
11256 if (TREE_CODE (function) == IDENTIFIER_NODE)
11258 unqualified_name_lookup_error (function);
11259 return error_mark_node;
11262 /* Remember that there was a reference to this entity. */
11263 if (DECL_P (function))
11264 mark_used (function);
11266 if (TREE_CODE (function) == OFFSET_REF)
11267 return build_offset_ref_call_from_tree (function, call_args);
11268 if (TREE_CODE (function) == COMPONENT_REF)
11270 if (!BASELINK_P (TREE_OPERAND (function, 1)))
11271 return finish_call_expr (function, call_args,
11272 /*disallow_virtual=*/false,
11273 /*koenig_p=*/false,
11276 return (build_new_method_call
11277 (TREE_OPERAND (function, 0),
11278 TREE_OPERAND (function, 1),
11279 call_args, NULL_TREE,
11280 qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL,
11284 return finish_call_expr (function, call_args,
11285 /*disallow_virtual=*/qualified_p,
11291 return build_x_conditional_expr
11292 (RECUR (TREE_OPERAND (t, 0)),
11293 RECUR (TREE_OPERAND (t, 1)),
11294 RECUR (TREE_OPERAND (t, 2)),
11297 case PSEUDO_DTOR_EXPR:
11298 return finish_pseudo_destructor_expr
11299 (RECUR (TREE_OPERAND (t, 0)),
11300 RECUR (TREE_OPERAND (t, 1)),
11301 RECUR (TREE_OPERAND (t, 2)));
11305 tree purpose, value, chain;
11307 if (t == void_list_node)
11310 if ((TREE_PURPOSE (t) && PACK_EXPANSION_P (TREE_PURPOSE (t)))
11311 || (TREE_VALUE (t) && PACK_EXPANSION_P (TREE_VALUE (t))))
11313 /* We have pack expansions, so expand those and
11314 create a new list out of it. */
11315 tree purposevec = NULL_TREE;
11316 tree valuevec = NULL_TREE;
11320 /* Expand the argument expressions. */
11321 if (TREE_PURPOSE (t))
11322 purposevec = tsubst_pack_expansion (TREE_PURPOSE (t), args,
11323 complain, in_decl);
11324 if (TREE_VALUE (t))
11325 valuevec = tsubst_pack_expansion (TREE_VALUE (t), args,
11326 complain, in_decl);
11328 /* Build the rest of the list. */
11329 chain = TREE_CHAIN (t);
11330 if (chain && chain != void_type_node)
11331 chain = RECUR (chain);
11333 /* Determine the number of arguments. */
11334 if (purposevec && TREE_CODE (purposevec) == TREE_VEC)
11336 len = TREE_VEC_LENGTH (purposevec);
11337 gcc_assert (!valuevec || len == TREE_VEC_LENGTH (valuevec));
11339 else if (TREE_CODE (valuevec) == TREE_VEC)
11340 len = TREE_VEC_LENGTH (valuevec);
11343 /* Since we only performed a partial substitution into
11344 the argument pack, we only return a single list
11346 if (purposevec == TREE_PURPOSE (t)
11347 && valuevec == TREE_VALUE (t)
11348 && chain == TREE_CHAIN (t))
11351 return tree_cons (purposevec, valuevec, chain);
11354 /* Convert the argument vectors into a TREE_LIST */
11358 /* Grab the Ith values. */
11360 purpose = purposevec ? TREE_VEC_ELT (purposevec, i)
11363 = valuevec ? convert_from_reference (TREE_VEC_ELT (valuevec, i))
11366 /* Build the list (backwards). */
11367 chain = tree_cons (purpose, value, chain);
11373 purpose = TREE_PURPOSE (t);
11375 purpose = RECUR (purpose);
11376 value = TREE_VALUE (t);
11378 value = RECUR (value);
11379 chain = TREE_CHAIN (t);
11380 if (chain && chain != void_type_node)
11381 chain = RECUR (chain);
11382 if (purpose == TREE_PURPOSE (t)
11383 && value == TREE_VALUE (t)
11384 && chain == TREE_CHAIN (t))
11386 return tree_cons (purpose, value, chain);
11389 case COMPONENT_REF:
11395 object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
11396 args, complain, in_decl);
11397 /* Remember that there was a reference to this entity. */
11398 if (DECL_P (object))
11399 mark_used (object);
11400 object_type = TREE_TYPE (object);
11402 member = TREE_OPERAND (t, 1);
11403 if (BASELINK_P (member))
11404 member = tsubst_baselink (member,
11405 non_reference (TREE_TYPE (object)),
11406 args, complain, in_decl);
11408 member = tsubst_copy (member, args, complain, in_decl);
11409 if (member == error_mark_node)
11410 return error_mark_node;
11412 if (object_type && !CLASS_TYPE_P (object_type))
11414 if (SCALAR_TYPE_P (object_type))
11416 tree s = NULL_TREE;
11417 tree dtor = member;
11419 if (TREE_CODE (dtor) == SCOPE_REF)
11421 s = TREE_OPERAND (dtor, 0);
11422 dtor = TREE_OPERAND (dtor, 1);
11424 if (TREE_CODE (dtor) == BIT_NOT_EXPR)
11426 dtor = TREE_OPERAND (dtor, 0);
11428 return finish_pseudo_destructor_expr (object, s, dtor);
11432 else if (TREE_CODE (member) == SCOPE_REF
11433 && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
11438 /* Lookup the template functions now that we know what the
11440 tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
11441 args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
11442 member = lookup_qualified_name (TREE_OPERAND (member, 0), tmpl,
11443 /*is_type_p=*/false,
11444 /*complain=*/false);
11445 if (BASELINK_P (member))
11447 BASELINK_FUNCTIONS (member)
11448 = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
11450 member = (adjust_result_of_qualified_name_lookup
11451 (member, BINFO_TYPE (BASELINK_BINFO (member)),
11456 qualified_name_lookup_error (object_type, tmpl, member,
11458 return error_mark_node;
11461 else if (TREE_CODE (member) == SCOPE_REF
11462 && !CLASS_TYPE_P (TREE_OPERAND (member, 0))
11463 && TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL)
11465 if (complain & tf_error)
11467 if (TYPE_P (TREE_OPERAND (member, 0)))
11468 error ("%qT is not a class or namespace",
11469 TREE_OPERAND (member, 0));
11471 error ("%qD is not a class or namespace",
11472 TREE_OPERAND (member, 0));
11474 return error_mark_node;
11476 else if (TREE_CODE (member) == FIELD_DECL)
11477 return finish_non_static_data_member (member, object, NULL_TREE);
11479 return finish_class_member_access_expr (object, member,
11480 /*template_p=*/false,
11486 (RECUR (TREE_OPERAND (t, 0)));
11490 VEC(constructor_elt,gc) *n;
11491 constructor_elt *ce;
11492 unsigned HOST_WIDE_INT idx;
11493 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
11494 bool process_index_p;
11496 bool need_copy_p = false;
11499 if (type == error_mark_node)
11500 return error_mark_node;
11502 /* digest_init will do the wrong thing if we let it. */
11503 if (type && TYPE_PTRMEMFUNC_P (type))
11506 /* We do not want to process the index of aggregate
11507 initializers as they are identifier nodes which will be
11508 looked up by digest_init. */
11509 process_index_p = !(type && MAYBE_CLASS_TYPE_P (type));
11511 n = VEC_copy (constructor_elt, gc, CONSTRUCTOR_ELTS (t));
11512 newlen = VEC_length (constructor_elt, n);
11513 for (idx = 0; VEC_iterate (constructor_elt, n, idx, ce); idx++)
11515 if (ce->index && process_index_p)
11516 ce->index = RECUR (ce->index);
11518 if (PACK_EXPANSION_P (ce->value))
11520 /* Substitute into the pack expansion. */
11521 ce->value = tsubst_pack_expansion (ce->value, args, complain,
11524 if (ce->value == error_mark_node)
11526 else if (TREE_VEC_LENGTH (ce->value) == 1)
11527 /* Just move the argument into place. */
11528 ce->value = TREE_VEC_ELT (ce->value, 0);
11531 /* Update the length of the final CONSTRUCTOR
11532 arguments vector, and note that we will need to
11534 newlen = newlen + TREE_VEC_LENGTH (ce->value) - 1;
11535 need_copy_p = true;
11539 ce->value = RECUR (ce->value);
11544 VEC(constructor_elt,gc) *old_n = n;
11546 n = VEC_alloc (constructor_elt, gc, newlen);
11547 for (idx = 0; VEC_iterate (constructor_elt, old_n, idx, ce);
11550 if (TREE_CODE (ce->value) == TREE_VEC)
11552 int i, len = TREE_VEC_LENGTH (ce->value);
11553 for (i = 0; i < len; ++i)
11554 CONSTRUCTOR_APPEND_ELT (n, 0,
11555 TREE_VEC_ELT (ce->value, i));
11558 CONSTRUCTOR_APPEND_ELT (n, 0, ce->value);
11562 r = build_constructor (init_list_type_node, n);
11564 if (TREE_HAS_CONSTRUCTOR (t))
11565 return finish_compound_literal (type, r);
11572 tree operand_0 = RECUR (TREE_OPERAND (t, 0));
11573 if (TYPE_P (operand_0))
11574 return get_typeid (operand_0);
11575 return build_typeid (operand_0);
11585 tree r = tsubst_copy (t, args, complain, in_decl);
11587 if (TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
11588 /* If the original type was a reference, we'll be wrapped in
11589 the appropriate INDIRECT_REF. */
11590 r = convert_from_reference (r);
11595 return build_x_va_arg (RECUR (TREE_OPERAND (t, 0)),
11596 tsubst_copy (TREE_TYPE (t), args, complain,
11599 case OFFSETOF_EXPR:
11600 return finish_offsetof (RECUR (TREE_OPERAND (t, 0)));
11604 tree type1 = tsubst_copy (TRAIT_EXPR_TYPE1 (t), args,
11605 complain, in_decl);
11607 tree type2 = TRAIT_EXPR_TYPE2 (t);
11609 type2 = tsubst_copy (type2, args, complain, in_decl);
11611 return finish_trait_expr (TRAIT_EXPR_KIND (t), type1, type2);
11616 tree old_stmt_expr = cur_stmt_expr;
11617 tree stmt_expr = begin_stmt_expr ();
11619 cur_stmt_expr = stmt_expr;
11620 tsubst_expr (STMT_EXPR_STMT (t), args, complain, in_decl,
11621 integral_constant_expression_p);
11622 stmt_expr = finish_stmt_expr (stmt_expr, false);
11623 cur_stmt_expr = old_stmt_expr;
11629 t = tsubst_copy (t, args, complain, in_decl);
11630 /* As in finish_id_expression, we resolve enumeration constants
11631 to their underlying values. */
11632 if (TREE_CODE (t) == CONST_DECL)
11634 used_types_insert (TREE_TYPE (t));
11635 return DECL_INITIAL (t);
11640 /* Handle Objective-C++ constructs, if appropriate. */
11643 = objcp_tsubst_copy_and_build (t, args, complain,
11644 in_decl, /*function_p=*/false);
11648 return tsubst_copy (t, args, complain, in_decl);
11654 /* Verify that the instantiated ARGS are valid. For type arguments,
11655 make sure that the type's linkage is ok. For non-type arguments,
11656 make sure they are constants if they are integral or enumerations.
11657 Emit an error under control of COMPLAIN, and return TRUE on error. */
11660 check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain)
11662 int ix, len = DECL_NTPARMS (tmpl);
11663 bool result = false;
11665 for (ix = 0; ix != len; ix++)
11667 tree t = TREE_VEC_ELT (args, ix);
11671 /* [basic.link]: A name with no linkage (notably, the name
11672 of a class or enumeration declared in a local scope)
11673 shall not be used to declare an entity with linkage.
11674 This implies that names with no linkage cannot be used as
11675 template arguments. */
11676 tree nt = no_linkage_check (t, /*relaxed_p=*/false);
11680 /* DR 488 makes use of a type with no linkage cause
11681 type deduction to fail. */
11682 if (complain & tf_error)
11684 if (TYPE_ANONYMOUS_P (nt))
11685 error ("%qT is/uses anonymous type", t);
11687 error ("template argument for %qD uses local type %qT",
11692 /* In order to avoid all sorts of complications, we do not
11693 allow variably-modified types as template arguments. */
11694 else if (variably_modified_type_p (t, NULL_TREE))
11696 if (complain & tf_error)
11697 error ("%qT is a variably modified type", t);
11701 /* A non-type argument of integral or enumerated type must be a
11703 else if (TREE_TYPE (t)
11704 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t))
11705 && !TREE_CONSTANT (t))
11707 if (complain & tf_error)
11708 error ("integral expression %qE is not constant", t);
11712 if (result && (complain & tf_error))
11713 error (" trying to instantiate %qD", tmpl);
11717 /* Instantiate the indicated variable or function template TMPL with
11718 the template arguments in TARG_PTR. */
11721 instantiate_template (tree tmpl, tree targ_ptr, tsubst_flags_t complain)
11726 HOST_WIDE_INT saved_processing_template_decl;
11728 if (tmpl == error_mark_node)
11729 return error_mark_node;
11731 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
11733 /* If this function is a clone, handle it specially. */
11734 if (DECL_CLONED_FUNCTION_P (tmpl))
11739 spec = instantiate_template (DECL_CLONED_FUNCTION (tmpl), targ_ptr,
11741 if (spec == error_mark_node)
11742 return error_mark_node;
11744 /* Look for the clone. */
11745 FOR_EACH_CLONE (clone, spec)
11746 if (DECL_NAME (clone) == DECL_NAME (tmpl))
11748 /* We should always have found the clone by now. */
11749 gcc_unreachable ();
11753 /* Check to see if we already have this specialization. */
11754 spec = retrieve_specialization (tmpl, targ_ptr,
11755 /*class_specializations_p=*/false);
11756 if (spec != NULL_TREE)
11759 gen_tmpl = most_general_template (tmpl);
11760 if (tmpl != gen_tmpl)
11762 /* The TMPL is a partial instantiation. To get a full set of
11763 arguments we must add the arguments used to perform the
11764 partial instantiation. */
11765 targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl),
11768 /* Check to see if we already have this specialization. */
11769 spec = retrieve_specialization (gen_tmpl, targ_ptr,
11770 /*class_specializations_p=*/false);
11771 if (spec != NULL_TREE)
11775 if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr),
11777 return error_mark_node;
11779 /* We are building a FUNCTION_DECL, during which the access of its
11780 parameters and return types have to be checked. However this
11781 FUNCTION_DECL which is the desired context for access checking
11782 is not built yet. We solve this chicken-and-egg problem by
11783 deferring all checks until we have the FUNCTION_DECL. */
11784 push_deferring_access_checks (dk_deferred);
11786 /* Although PROCESSING_TEMPLATE_DECL may be true at this point
11787 (because, for example, we have encountered a non-dependent
11788 function call in the body of a template function and must now
11789 determine which of several overloaded functions will be called),
11790 within the instantiation itself we are not processing a
11792 saved_processing_template_decl = processing_template_decl;
11793 processing_template_decl = 0;
11794 /* Substitute template parameters to obtain the specialization. */
11795 fndecl = tsubst (DECL_TEMPLATE_RESULT (gen_tmpl),
11796 targ_ptr, complain, gen_tmpl);
11797 processing_template_decl = saved_processing_template_decl;
11798 if (fndecl == error_mark_node)
11799 return error_mark_node;
11801 /* Now we know the specialization, compute access previously
11803 push_access_scope (fndecl);
11804 perform_deferred_access_checks ();
11805 pop_access_scope (fndecl);
11806 pop_deferring_access_checks ();
11808 /* The DECL_TI_TEMPLATE should always be the immediate parent
11809 template, not the most general template. */
11810 DECL_TI_TEMPLATE (fndecl) = tmpl;
11812 /* If we've just instantiated the main entry point for a function,
11813 instantiate all the alternate entry points as well. We do this
11814 by cloning the instantiation of the main entry point, not by
11815 instantiating the template clones. */
11816 if (TREE_CHAIN (gen_tmpl) && DECL_CLONED_FUNCTION_P (TREE_CHAIN (gen_tmpl)))
11817 clone_function_decl (fndecl, /*update_method_vec_p=*/0);
11822 /* The FN is a TEMPLATE_DECL for a function. The ARGS are the
11823 arguments that are being used when calling it. TARGS is a vector
11824 into which the deduced template arguments are placed.
11826 Return zero for success, 2 for an incomplete match that doesn't resolve
11827 all the types, and 1 for complete failure. An error message will be
11828 printed only for an incomplete match.
11830 If FN is a conversion operator, or we are trying to produce a specific
11831 specialization, RETURN_TYPE is the return type desired.
11833 The EXPLICIT_TARGS are explicit template arguments provided via a
11836 The parameter STRICT is one of:
11839 We are deducing arguments for a function call, as in
11840 [temp.deduct.call].
11843 We are deducing arguments for a conversion function, as in
11844 [temp.deduct.conv].
11847 We are deducing arguments when doing an explicit instantiation
11848 as in [temp.explicit], when determining an explicit specialization
11849 as in [temp.expl.spec], or when taking the address of a function
11850 template, as in [temp.deduct.funcaddr]. */
11853 fn_type_unification (tree fn,
11854 tree explicit_targs,
11858 unification_kind_t strict,
11864 bool incomplete_argument_packs_p = false;
11866 gcc_assert (TREE_CODE (fn) == TEMPLATE_DECL);
11868 fntype = TREE_TYPE (fn);
11869 if (explicit_targs)
11873 The specified template arguments must match the template
11874 parameters in kind (i.e., type, nontype, template), and there
11875 must not be more arguments than there are parameters;
11876 otherwise type deduction fails.
11878 Nontype arguments must match the types of the corresponding
11879 nontype template parameters, or must be convertible to the
11880 types of the corresponding nontype parameters as specified in
11881 _temp.arg.nontype_, otherwise type deduction fails.
11883 All references in the function type of the function template
11884 to the corresponding template parameters are replaced by the
11885 specified template argument values. If a substitution in a
11886 template parameter or in the function type of the function
11887 template results in an invalid type, type deduction fails. */
11888 tree tparms = DECL_INNERMOST_TEMPLATE_PARMS (fn);
11889 int i, len = TREE_VEC_LENGTH (tparms);
11890 tree converted_args;
11891 bool incomplete = false;
11893 if (explicit_targs == error_mark_node)
11897 = (coerce_template_parms (tparms, explicit_targs, NULL_TREE, tf_none,
11898 /*require_all_args=*/false,
11899 /*use_default_args=*/false));
11900 if (converted_args == error_mark_node)
11903 /* Substitute the explicit args into the function type. This is
11904 necessary so that, for instance, explicitly declared function
11905 arguments can match null pointed constants. If we were given
11906 an incomplete set of explicit args, we must not do semantic
11907 processing during substitution as we could create partial
11909 for (i = 0; i < len; i++)
11911 tree parm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
11912 bool parameter_pack = false;
11914 /* Dig out the actual parm. */
11915 if (TREE_CODE (parm) == TYPE_DECL
11916 || TREE_CODE (parm) == TEMPLATE_DECL)
11918 parm = TREE_TYPE (parm);
11919 parameter_pack = TEMPLATE_TYPE_PARAMETER_PACK (parm);
11921 else if (TREE_CODE (parm) == PARM_DECL)
11923 parm = DECL_INITIAL (parm);
11924 parameter_pack = TEMPLATE_PARM_PARAMETER_PACK (parm);
11927 if (parameter_pack)
11931 template_parm_level_and_index (parm, &level, &idx);
11933 /* Mark the argument pack as "incomplete". We could
11934 still deduce more arguments during unification. */
11935 targ = TMPL_ARG (converted_args, level, idx);
11938 ARGUMENT_PACK_INCOMPLETE_P(targ) = 1;
11939 ARGUMENT_PACK_EXPLICIT_ARGS (targ)
11940 = ARGUMENT_PACK_ARGS (targ);
11943 /* We have some incomplete argument packs. */
11944 incomplete_argument_packs_p = true;
11948 if (incomplete_argument_packs_p)
11949 /* Any substitution is guaranteed to be incomplete if there
11950 are incomplete argument packs, because we can still deduce
11954 incomplete = NUM_TMPL_ARGS (explicit_targs) != NUM_TMPL_ARGS (targs);
11956 processing_template_decl += incomplete;
11957 fntype = tsubst (fntype, converted_args, tf_none, NULL_TREE);
11958 processing_template_decl -= incomplete;
11960 if (fntype == error_mark_node)
11963 /* Place the explicitly specified arguments in TARGS. */
11964 for (i = NUM_TMPL_ARGS (converted_args); i--;)
11965 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i);
11968 /* Never do unification on the 'this' parameter. */
11969 parms = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (fntype));
11973 parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms);
11974 args = tree_cons (NULL_TREE, return_type, args);
11977 /* We allow incomplete unification without an error message here
11978 because the standard doesn't seem to explicitly prohibit it. Our
11979 callers must be ready to deal with unification failures in any
11981 result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
11982 targs, parms, args, /*subr=*/0,
11985 if (result == 0 && incomplete_argument_packs_p)
11987 int i, len = NUM_TMPL_ARGS (targs);
11989 /* Clear the "incomplete" flags on all argument packs. */
11990 for (i = 0; i < len; i++)
11992 tree arg = TREE_VEC_ELT (targs, i);
11993 if (ARGUMENT_PACK_P (arg))
11995 ARGUMENT_PACK_INCOMPLETE_P (arg) = 0;
11996 ARGUMENT_PACK_EXPLICIT_ARGS (arg) = NULL_TREE;
12001 /* Now that we have bindings for all of the template arguments,
12002 ensure that the arguments deduced for the template template
12003 parameters have compatible template parameter lists. We cannot
12004 check this property before we have deduced all template
12005 arguments, because the template parameter types of a template
12006 template parameter might depend on prior template parameters
12007 deduced after the template template parameter. The following
12008 ill-formed example illustrates this issue:
12010 template<typename T, template<T> class C> void f(C<5>, T);
12012 template<int N> struct X {};
12015 f(X<5>(), 5l); // error: template argument deduction fails
12018 The template parameter list of 'C' depends on the template type
12019 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
12020 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
12021 time that we deduce 'C'. */
12023 && !template_template_parm_bindings_ok_p
12024 (DECL_INNERMOST_TEMPLATE_PARMS (fn), targs))
12028 /* All is well so far. Now, check:
12032 When all template arguments have been deduced, all uses of
12033 template parameters in nondeduced contexts are replaced with
12034 the corresponding deduced argument values. If the
12035 substitution results in an invalid type, as described above,
12036 type deduction fails. */
12037 if (tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE)
12038 == error_mark_node)
12044 /* Adjust types before performing type deduction, as described in
12045 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
12046 sections are symmetric. PARM is the type of a function parameter
12047 or the return type of the conversion function. ARG is the type of
12048 the argument passed to the call, or the type of the value
12049 initialized with the result of the conversion function.
12050 ARG_EXPR is the original argument expression, which may be null. */
12053 maybe_adjust_types_for_deduction (unification_kind_t strict,
12067 /* Swap PARM and ARG throughout the remainder of this
12068 function; the handling is precisely symmetric since PARM
12069 will initialize ARG rather than vice versa. */
12077 /* There is nothing to do in this case. */
12081 gcc_unreachable ();
12084 if (TREE_CODE (*parm) != REFERENCE_TYPE)
12086 /* [temp.deduct.call]
12088 If P is not a reference type:
12090 --If A is an array type, the pointer type produced by the
12091 array-to-pointer standard conversion (_conv.array_) is
12092 used in place of A for type deduction; otherwise,
12094 --If A is a function type, the pointer type produced by
12095 the function-to-pointer standard conversion
12096 (_conv.func_) is used in place of A for type deduction;
12099 --If A is a cv-qualified type, the top level
12100 cv-qualifiers of A's type are ignored for type
12102 if (TREE_CODE (*arg) == ARRAY_TYPE)
12103 *arg = build_pointer_type (TREE_TYPE (*arg));
12104 else if (TREE_CODE (*arg) == FUNCTION_TYPE)
12105 *arg = build_pointer_type (*arg);
12107 *arg = TYPE_MAIN_VARIANT (*arg);
12110 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
12111 of the form T&&, where T is a template parameter, and the argument
12112 is an lvalue, T is deduced as A& */
12113 if (TREE_CODE (*parm) == REFERENCE_TYPE
12114 && TYPE_REF_IS_RVALUE (*parm)
12115 && TREE_CODE (TREE_TYPE (*parm)) == TEMPLATE_TYPE_PARM
12116 && cp_type_quals (TREE_TYPE (*parm)) == TYPE_UNQUALIFIED
12117 && arg_expr && real_lvalue_p (arg_expr))
12118 *arg = build_reference_type (*arg);
12120 /* [temp.deduct.call]
12122 If P is a cv-qualified type, the top level cv-qualifiers
12123 of P's type are ignored for type deduction. If P is a
12124 reference type, the type referred to by P is used for
12126 *parm = TYPE_MAIN_VARIANT (*parm);
12127 if (TREE_CODE (*parm) == REFERENCE_TYPE)
12129 *parm = TREE_TYPE (*parm);
12130 result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
12133 /* DR 322. For conversion deduction, remove a reference type on parm
12134 too (which has been swapped into ARG). */
12135 if (strict == DEDUCE_CONV && TREE_CODE (*arg) == REFERENCE_TYPE)
12136 *arg = TREE_TYPE (*arg);
12141 /* Most parms like fn_type_unification.
12143 If SUBR is 1, we're being called recursively (to unify the
12144 arguments of a function or method parameter of a function
12148 type_unification_real (tree tparms,
12153 unification_kind_t strict,
12156 tree parm, arg, arg_expr;
12158 int ntparms = TREE_VEC_LENGTH (tparms);
12160 int saw_undeduced = 0;
12163 gcc_assert (TREE_CODE (tparms) == TREE_VEC);
12164 gcc_assert (xparms == NULL_TREE || TREE_CODE (xparms) == TREE_LIST);
12165 gcc_assert (!xargs || TREE_CODE (xargs) == TREE_LIST);
12166 gcc_assert (ntparms > 0);
12171 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL | UNIFY_ALLOW_MORE_CV_QUAL
12172 | UNIFY_ALLOW_DERIVED);
12176 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
12180 sub_strict = UNIFY_ALLOW_NONE;
12184 gcc_unreachable ();
12191 while (parms && parms != void_list_node
12192 && args && args != void_list_node)
12194 if (TREE_CODE (TREE_VALUE (parms)) == TYPE_PACK_EXPANSION)
12197 parm = TREE_VALUE (parms);
12198 parms = TREE_CHAIN (parms);
12199 arg = TREE_VALUE (args);
12200 args = TREE_CHAIN (args);
12203 if (arg == error_mark_node)
12205 if (arg == unknown_type_node)
12206 /* We can't deduce anything from this, but we might get all the
12207 template args from other function args. */
12210 /* Conversions will be performed on a function argument that
12211 corresponds with a function parameter that contains only
12212 non-deducible template parameters and explicitly specified
12213 template parameters. */
12214 if (!uses_template_parms (parm))
12219 type = TREE_TYPE (arg);
12223 if (same_type_p (parm, type))
12225 if (strict != DEDUCE_EXACT
12226 && can_convert_arg (parm, type, TYPE_P (arg) ? NULL_TREE : arg,
12235 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
12236 if (type_unknown_p (arg))
12238 /* [temp.deduct.type]
12240 A template-argument can be deduced from a pointer to
12241 function or pointer to member function argument if
12242 the set of overloaded functions does not contain
12243 function templates and at most one of a set of
12244 overloaded functions provides a unique match. */
12245 if (resolve_overloaded_unification
12246 (tparms, targs, parm, arg, strict, sub_strict))
12252 arg = unlowered_expr_type (arg);
12253 if (arg == error_mark_node)
12258 int arg_strict = sub_strict;
12261 arg_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg,
12264 if (arg == init_list_type_node && arg_expr)
12266 if (unify (tparms, targs, parm, arg, arg_strict))
12273 && parms != void_list_node
12274 && TREE_CODE (TREE_VALUE (parms)) == TYPE_PACK_EXPANSION)
12276 /* Unify the remaining arguments with the pack expansion type. */
12278 tree parmvec = make_tree_vec (1);
12282 /* Count the number of arguments that remain. */
12283 for (t = args; t && t != void_list_node; t = TREE_CHAIN (t))
12286 /* Allocate a TREE_VEC and copy in all of the arguments */
12287 argvec = make_tree_vec (len);
12288 for (i = 0; args && args != void_list_node; args = TREE_CHAIN (args))
12290 TREE_VEC_ELT (argvec, i) = TREE_VALUE (args);
12294 /* Copy the parameter into parmvec. */
12295 TREE_VEC_ELT (parmvec, 0) = TREE_VALUE (parms);
12296 if (unify_pack_expansion (tparms, targs, parmvec, argvec, strict,
12297 /*call_args_p=*/true, /*subr=*/subr))
12300 /* Advance to the end of the list of parameters. */
12301 parms = TREE_CHAIN (parms);
12304 /* Fail if we've reached the end of the parm list, and more args
12305 are present, and the parm list isn't variadic. */
12306 if (args && args != void_list_node && parms == void_list_node)
12308 /* Fail if parms are left and they don't have default values. */
12309 if (parms && parms != void_list_node
12310 && TREE_PURPOSE (parms) == NULL_TREE)
12314 for (i = 0; i < ntparms; i++)
12315 if (!TREE_VEC_ELT (targs, i))
12319 if (TREE_VEC_ELT (tparms, i) == error_mark_node)
12322 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
12324 /* If this is an undeduced nontype parameter that depends on
12325 a type parameter, try another pass; its type may have been
12326 deduced from a later argument than the one from which
12327 this parameter can be deduced. */
12328 if (TREE_CODE (tparm) == PARM_DECL
12329 && uses_template_parms (TREE_TYPE (tparm))
12330 && !saw_undeduced++)
12333 /* Core issue #226 (C++0x) [temp.deduct]:
12335 If a template argument has not been deduced, its
12336 default template argument, if any, is used.
12338 When we are in C++98 mode, TREE_PURPOSE will either
12339 be NULL_TREE or ERROR_MARK_NODE, so we do not need
12340 to explicitly check cxx_dialect here. */
12341 if (TREE_PURPOSE (TREE_VEC_ELT (tparms, i)))
12343 tree arg = tsubst (TREE_PURPOSE (TREE_VEC_ELT (tparms, i)),
12344 targs, tf_none, NULL_TREE);
12345 if (arg == error_mark_node)
12349 TREE_VEC_ELT (targs, i) = arg;
12354 /* If the type parameter is a parameter pack, then it will
12355 be deduced to an empty parameter pack. */
12356 if (template_parameter_pack_p (tparm))
12360 if (TREE_CODE (tparm) == TEMPLATE_PARM_INDEX)
12362 arg = make_node (NONTYPE_ARGUMENT_PACK);
12363 TREE_TYPE (arg) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm));
12364 TREE_CONSTANT (arg) = 1;
12367 arg = make_node (TYPE_ARGUMENT_PACK);
12369 SET_ARGUMENT_PACK_ARGS (arg, make_tree_vec (0));
12371 TREE_VEC_ELT (targs, i) = arg;
12381 /* Subroutine of type_unification_real. Args are like the variables
12382 at the call site. ARG is an overloaded function (or template-id);
12383 we try deducing template args from each of the overloads, and if
12384 only one succeeds, we go with that. Modifies TARGS and returns
12385 true on success. */
12388 resolve_overloaded_unification (tree tparms,
12392 unification_kind_t strict,
12395 tree tempargs = copy_node (targs);
12399 if (TREE_CODE (arg) == ADDR_EXPR)
12401 arg = TREE_OPERAND (arg, 0);
12407 if (TREE_CODE (arg) == COMPONENT_REF)
12408 /* Handle `&x' where `x' is some static or non-static member
12410 arg = TREE_OPERAND (arg, 1);
12412 if (TREE_CODE (arg) == OFFSET_REF)
12413 arg = TREE_OPERAND (arg, 1);
12415 /* Strip baselink information. */
12416 if (BASELINK_P (arg))
12417 arg = BASELINK_FUNCTIONS (arg);
12419 if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
12421 /* If we got some explicit template args, we need to plug them into
12422 the affected templates before we try to unify, in case the
12423 explicit args will completely resolve the templates in question. */
12425 tree expl_subargs = TREE_OPERAND (arg, 1);
12426 arg = TREE_OPERAND (arg, 0);
12428 for (; arg; arg = OVL_NEXT (arg))
12430 tree fn = OVL_CURRENT (arg);
12431 tree subargs, elem;
12433 if (TREE_CODE (fn) != TEMPLATE_DECL)
12436 ++processing_template_decl;
12437 subargs = get_bindings (fn, DECL_TEMPLATE_RESULT (fn),
12438 expl_subargs, /*check_ret=*/false);
12441 elem = tsubst (TREE_TYPE (fn), subargs, tf_none, NULL_TREE);
12442 good += try_one_overload (tparms, targs, tempargs, parm,
12443 elem, strict, sub_strict, addr_p);
12445 --processing_template_decl;
12448 else if (TREE_CODE (arg) != OVERLOAD
12449 && TREE_CODE (arg) != FUNCTION_DECL)
12450 /* If ARG is, for example, "(0, &f)" then its type will be unknown
12451 -- but the deduction does not succeed because the expression is
12452 not just the function on its own. */
12455 for (; arg; arg = OVL_NEXT (arg))
12456 good += try_one_overload (tparms, targs, tempargs, parm,
12457 TREE_TYPE (OVL_CURRENT (arg)),
12458 strict, sub_strict, addr_p);
12460 /* [temp.deduct.type] A template-argument can be deduced from a pointer
12461 to function or pointer to member function argument if the set of
12462 overloaded functions does not contain function templates and at most
12463 one of a set of overloaded functions provides a unique match.
12465 So if we found multiple possibilities, we return success but don't
12466 deduce anything. */
12470 int i = TREE_VEC_LENGTH (targs);
12472 if (TREE_VEC_ELT (tempargs, i))
12473 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i);
12481 /* Subroutine of resolve_overloaded_unification; does deduction for a single
12482 overload. Fills TARGS with any deduced arguments, or error_mark_node if
12483 different overloads deduce different arguments for a given parm.
12484 ADDR_P is true if the expression for which deduction is being
12485 performed was of the form "& fn" rather than simply "fn".
12487 Returns 1 on success. */
12490 try_one_overload (tree tparms,
12495 unification_kind_t strict,
12503 /* [temp.deduct.type] A template-argument can be deduced from a pointer
12504 to function or pointer to member function argument if the set of
12505 overloaded functions does not contain function templates and at most
12506 one of a set of overloaded functions provides a unique match.
12508 So if this is a template, just return success. */
12510 if (uses_template_parms (arg))
12513 if (TREE_CODE (arg) == METHOD_TYPE)
12514 arg = build_ptrmemfunc_type (build_pointer_type (arg));
12516 arg = build_pointer_type (arg);
12518 sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg, NULL);
12520 /* We don't copy orig_targs for this because if we have already deduced
12521 some template args from previous args, unify would complain when we
12522 try to deduce a template parameter for the same argument, even though
12523 there isn't really a conflict. */
12524 nargs = TREE_VEC_LENGTH (targs);
12525 tempargs = make_tree_vec (nargs);
12527 if (unify (tparms, tempargs, parm, arg, sub_strict) != 0)
12530 /* First make sure we didn't deduce anything that conflicts with
12531 explicitly specified args. */
12532 for (i = nargs; i--; )
12534 tree elt = TREE_VEC_ELT (tempargs, i);
12535 tree oldelt = TREE_VEC_ELT (orig_targs, i);
12539 else if (uses_template_parms (elt))
12540 /* Since we're unifying against ourselves, we will fill in
12541 template args used in the function parm list with our own
12542 template parms. Discard them. */
12543 TREE_VEC_ELT (tempargs, i) = NULL_TREE;
12544 else if (oldelt && !template_args_equal (oldelt, elt))
12548 for (i = nargs; i--; )
12550 tree elt = TREE_VEC_ELT (tempargs, i);
12553 TREE_VEC_ELT (targs, i) = elt;
12559 /* PARM is a template class (perhaps with unbound template
12560 parameters). ARG is a fully instantiated type. If ARG can be
12561 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
12562 TARGS are as for unify. */
12565 try_class_unification (tree tparms, tree targs, tree parm, tree arg)
12567 tree copy_of_targs;
12569 if (!CLASSTYPE_TEMPLATE_INFO (arg)
12570 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg))
12571 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm))))
12574 /* We need to make a new template argument vector for the call to
12575 unify. If we used TARGS, we'd clutter it up with the result of
12576 the attempted unification, even if this class didn't work out.
12577 We also don't want to commit ourselves to all the unifications
12578 we've already done, since unification is supposed to be done on
12579 an argument-by-argument basis. In other words, consider the
12580 following pathological case:
12582 template <int I, int J, int K>
12585 template <int I, int J>
12586 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
12588 template <int I, int J, int K>
12589 void f(S<I, J, K>, S<I, I, I>);
12598 Now, by the time we consider the unification involving `s2', we
12599 already know that we must have `f<0, 0, 0>'. But, even though
12600 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
12601 because there are two ways to unify base classes of S<0, 1, 2>
12602 with S<I, I, I>. If we kept the already deduced knowledge, we
12603 would reject the possibility I=1. */
12604 copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs));
12606 /* If unification failed, we're done. */
12607 if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm),
12608 CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE))
12614 /* Given a template type PARM and a class type ARG, find the unique
12615 base type in ARG that is an instance of PARM. We do not examine
12616 ARG itself; only its base-classes. If there is not exactly one
12617 appropriate base class, return NULL_TREE. PARM may be the type of
12618 a partial specialization, as well as a plain template type. Used
12622 get_template_base (tree tparms, tree targs, tree parm, tree arg)
12624 tree rval = NULL_TREE;
12627 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg)));
12629 binfo = TYPE_BINFO (complete_type (arg));
12631 /* The type could not be completed. */
12634 /* Walk in inheritance graph order. The search order is not
12635 important, and this avoids multiple walks of virtual bases. */
12636 for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo))
12638 tree r = try_class_unification (tparms, targs, parm, BINFO_TYPE (binfo));
12642 /* If there is more than one satisfactory baseclass, then:
12646 If they yield more than one possible deduced A, the type
12650 if (rval && !same_type_p (r, rval))
12660 /* Returns the level of DECL, which declares a template parameter. */
12663 template_decl_level (tree decl)
12665 switch (TREE_CODE (decl))
12668 case TEMPLATE_DECL:
12669 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl));
12672 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
12675 gcc_unreachable ();
12680 /* Decide whether ARG can be unified with PARM, considering only the
12681 cv-qualifiers of each type, given STRICT as documented for unify.
12682 Returns nonzero iff the unification is OK on that basis. */
12685 check_cv_quals_for_unify (int strict, tree arg, tree parm)
12687 int arg_quals = cp_type_quals (arg);
12688 int parm_quals = cp_type_quals (parm);
12690 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
12691 && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
12693 /* Although a CVR qualifier is ignored when being applied to a
12694 substituted template parameter ([8.3.2]/1 for example), that
12695 does not apply during deduction [14.8.2.4]/1, (even though
12696 that is not explicitly mentioned, [14.8.2.4]/9 indicates
12697 this). Except when we're allowing additional CV qualifiers
12698 at the outer level [14.8.2.1]/3,1st bullet. */
12699 if ((TREE_CODE (arg) == REFERENCE_TYPE
12700 || TREE_CODE (arg) == FUNCTION_TYPE
12701 || TREE_CODE (arg) == METHOD_TYPE)
12702 && (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)))
12705 if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
12706 && (parm_quals & TYPE_QUAL_RESTRICT))
12710 if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
12711 && (arg_quals & parm_quals) != parm_quals)
12714 if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL))
12715 && (parm_quals & arg_quals) != arg_quals)
12721 /* Determines the LEVEL and INDEX for the template parameter PARM. */
12723 template_parm_level_and_index (tree parm, int* level, int* index)
12725 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
12726 || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
12727 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
12729 *index = TEMPLATE_TYPE_IDX (parm);
12730 *level = TEMPLATE_TYPE_LEVEL (parm);
12734 *index = TEMPLATE_PARM_IDX (parm);
12735 *level = TEMPLATE_PARM_LEVEL (parm);
12739 /* Unifies the remaining arguments in PACKED_ARGS with the pack
12740 expansion at the end of PACKED_PARMS. Returns 0 if the type
12741 deduction succeeds, 1 otherwise. STRICT is the same as in
12742 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
12743 call argument list. We'll need to adjust the arguments to make them
12744 types. SUBR tells us if this is from a recursive call to
12745 type_unification_real. */
12747 unify_pack_expansion (tree tparms, tree targs, tree packed_parms,
12748 tree packed_args, int strict, bool call_args_p,
12752 = TREE_VEC_ELT (packed_parms, TREE_VEC_LENGTH (packed_parms) - 1);
12753 tree pattern = PACK_EXPANSION_PATTERN (parm);
12754 tree pack, packs = NULL_TREE;
12755 int i, start = TREE_VEC_LENGTH (packed_parms) - 1;
12756 int len = TREE_VEC_LENGTH (packed_args);
12758 /* Determine the parameter packs we will be deducing from the
12759 pattern, and record their current deductions. */
12760 for (pack = PACK_EXPANSION_PARAMETER_PACKS (parm);
12761 pack; pack = TREE_CHAIN (pack))
12763 tree parm_pack = TREE_VALUE (pack);
12766 /* Determine the index and level of this parameter pack. */
12767 template_parm_level_and_index (parm_pack, &level, &idx);
12769 /* Keep track of the parameter packs and their corresponding
12771 packs = tree_cons (parm_pack, TMPL_ARG (targs, level, idx), packs);
12772 TREE_TYPE (packs) = make_tree_vec (len - start);
12775 /* Loop through all of the arguments that have not yet been
12776 unified and unify each with the pattern. */
12777 for (i = start; i < len; i++)
12779 tree parm = pattern;
12781 /* For each parameter pack, clear out the deduced value so that
12782 we can deduce it again. */
12783 for (pack = packs; pack; pack = TREE_CHAIN (pack))
12786 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12788 TMPL_ARG (targs, level, idx) = NULL_TREE;
12791 /* Unify the pattern with the current argument. */
12793 tree arg = TREE_VEC_ELT (packed_args, i);
12794 tree arg_expr = NULL_TREE;
12795 int arg_strict = strict;
12796 bool skip_arg_p = false;
12802 /* This mirrors what we do in type_unification_real. */
12806 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL
12807 | UNIFY_ALLOW_MORE_CV_QUAL
12808 | UNIFY_ALLOW_DERIVED);
12812 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
12816 sub_strict = UNIFY_ALLOW_NONE;
12820 gcc_unreachable ();
12825 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
12826 if (type_unknown_p (arg))
12828 /* [temp.deduct.type] A template-argument can be
12829 deduced from a pointer to function or pointer
12830 to member function argument if the set of
12831 overloaded functions does not contain function
12832 templates and at most one of a set of
12833 overloaded functions provides a unique
12836 if (resolve_overloaded_unification
12837 (tparms, targs, parm, arg, strict, sub_strict)
12846 arg = unlowered_expr_type (arg);
12847 if (arg == error_mark_node)
12852 arg_strict = sub_strict;
12856 maybe_adjust_types_for_deduction (strict, &parm, &arg,
12862 if (unify (tparms, targs, parm, arg, arg_strict))
12867 /* For each parameter pack, collect the deduced value. */
12868 for (pack = packs; pack; pack = TREE_CHAIN (pack))
12871 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12873 TREE_VEC_ELT (TREE_TYPE (pack), i - start) =
12874 TMPL_ARG (targs, level, idx);
12878 /* Verify that the results of unification with the parameter packs
12879 produce results consistent with what we've seen before, and make
12880 the deduced argument packs available. */
12881 for (pack = packs; pack; pack = TREE_CHAIN (pack))
12883 tree old_pack = TREE_VALUE (pack);
12884 tree new_args = TREE_TYPE (pack);
12885 int i, len = TREE_VEC_LENGTH (new_args);
12886 bool nondeduced_p = false;
12888 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
12889 actually deduce anything. */
12890 for (i = 0; i < len && !nondeduced_p; ++i)
12891 if (TREE_VEC_ELT (new_args, i) == NULL_TREE)
12892 nondeduced_p = true;
12896 if (old_pack && ARGUMENT_PACK_INCOMPLETE_P (old_pack))
12898 /* Prepend the explicit arguments onto NEW_ARGS. */
12899 tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
12900 tree old_args = new_args;
12901 int i, explicit_len = TREE_VEC_LENGTH (explicit_args);
12902 int len = explicit_len + TREE_VEC_LENGTH (old_args);
12904 /* Copy the explicit arguments. */
12905 new_args = make_tree_vec (len);
12906 for (i = 0; i < explicit_len; i++)
12907 TREE_VEC_ELT (new_args, i) = TREE_VEC_ELT (explicit_args, i);
12909 /* Copy the deduced arguments. */
12910 for (; i < len; i++)
12911 TREE_VEC_ELT (new_args, i) =
12912 TREE_VEC_ELT (old_args, i - explicit_len);
12920 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12922 /* Build the deduced *_ARGUMENT_PACK. */
12923 if (TREE_CODE (TREE_PURPOSE (pack)) == TEMPLATE_PARM_INDEX)
12925 result = make_node (NONTYPE_ARGUMENT_PACK);
12926 TREE_TYPE (result) =
12927 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack)));
12928 TREE_CONSTANT (result) = 1;
12931 result = make_node (TYPE_ARGUMENT_PACK);
12933 SET_ARGUMENT_PACK_ARGS (result, new_args);
12935 /* Note the deduced argument packs for this parameter
12937 TMPL_ARG (targs, level, idx) = result;
12939 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack)
12940 && (ARGUMENT_PACK_ARGS (old_pack)
12941 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack)))
12943 /* We only had the explicitly-provided arguments before, but
12944 now we have a complete set of arguments. */
12946 tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
12947 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12949 /* Keep the original deduced argument pack. */
12950 TMPL_ARG (targs, level, idx) = old_pack;
12952 SET_ARGUMENT_PACK_ARGS (old_pack, new_args);
12953 ARGUMENT_PACK_INCOMPLETE_P (old_pack) = 1;
12954 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack) = explicit_args;
12956 else if (!comp_template_args (ARGUMENT_PACK_ARGS (old_pack),
12958 /* Inconsistent unification of this parameter pack. */
12964 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12966 /* Keep the original deduced argument pack. */
12967 TMPL_ARG (targs, level, idx) = old_pack;
12974 /* Deduce the value of template parameters. TPARMS is the (innermost)
12975 set of template parameters to a template. TARGS is the bindings
12976 for those template parameters, as determined thus far; TARGS may
12977 include template arguments for outer levels of template parameters
12978 as well. PARM is a parameter to a template function, or a
12979 subcomponent of that parameter; ARG is the corresponding argument.
12980 This function attempts to match PARM with ARG in a manner
12981 consistent with the existing assignments in TARGS. If more values
12982 are deduced, then TARGS is updated.
12984 Returns 0 if the type deduction succeeds, 1 otherwise. The
12985 parameter STRICT is a bitwise or of the following flags:
12988 Require an exact match between PARM and ARG.
12989 UNIFY_ALLOW_MORE_CV_QUAL:
12990 Allow the deduced ARG to be more cv-qualified (by qualification
12991 conversion) than ARG.
12992 UNIFY_ALLOW_LESS_CV_QUAL:
12993 Allow the deduced ARG to be less cv-qualified than ARG.
12994 UNIFY_ALLOW_DERIVED:
12995 Allow the deduced ARG to be a template base class of ARG,
12996 or a pointer to a template base class of the type pointed to by
12998 UNIFY_ALLOW_INTEGER:
12999 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
13000 case for more information.
13001 UNIFY_ALLOW_OUTER_LEVEL:
13002 This is the outermost level of a deduction. Used to determine validity
13003 of qualification conversions. A valid qualification conversion must
13004 have const qualified pointers leading up to the inner type which
13005 requires additional CV quals, except at the outer level, where const
13006 is not required [conv.qual]. It would be normal to set this flag in
13007 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
13008 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
13009 This is the outermost level of a deduction, and PARM can be more CV
13010 qualified at this point.
13011 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
13012 This is the outermost level of a deduction, and PARM can be less CV
13013 qualified at this point. */
13016 unify (tree tparms, tree targs, tree parm, tree arg, int strict)
13021 int strict_in = strict;
13023 /* I don't think this will do the right thing with respect to types.
13024 But the only case I've seen it in so far has been array bounds, where
13025 signedness is the only information lost, and I think that will be
13027 while (TREE_CODE (parm) == NOP_EXPR)
13028 parm = TREE_OPERAND (parm, 0);
13030 if (arg == error_mark_node)
13032 if (arg == unknown_type_node
13033 || arg == init_list_type_node)
13034 /* We can't deduce anything from this, but we might get all the
13035 template args from other function args. */
13038 /* If PARM uses template parameters, then we can't bail out here,
13039 even if ARG == PARM, since we won't record unifications for the
13040 template parameters. We might need them if we're trying to
13041 figure out which of two things is more specialized. */
13042 if (arg == parm && !uses_template_parms (parm))
13045 /* Handle init lists early, so the rest of the function can assume
13046 we're dealing with a type. */
13047 if (BRACE_ENCLOSED_INITIALIZER_P (arg))
13052 if (!is_std_init_list (parm))
13053 /* We can only deduce from an initializer list argument if the
13054 parameter is std::initializer_list; otherwise this is a
13055 non-deduced context. */
13058 elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm), 0);
13060 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg), i, elt)
13062 if (!BRACE_ENCLOSED_INITIALIZER_P (elt))
13063 elt = TREE_TYPE (elt);
13064 if (unify (tparms, targs, elttype, elt, UNIFY_ALLOW_NONE))
13070 /* Immediately reject some pairs that won't unify because of
13071 cv-qualification mismatches. */
13072 if (TREE_CODE (arg) == TREE_CODE (parm)
13074 /* It is the elements of the array which hold the cv quals of an array
13075 type, and the elements might be template type parms. We'll check
13076 when we recurse. */
13077 && TREE_CODE (arg) != ARRAY_TYPE
13078 /* We check the cv-qualifiers when unifying with template type
13079 parameters below. We want to allow ARG `const T' to unify with
13080 PARM `T' for example, when computing which of two templates
13081 is more specialized, for example. */
13082 && TREE_CODE (arg) != TEMPLATE_TYPE_PARM
13083 && !check_cv_quals_for_unify (strict_in, arg, parm))
13086 if (!(strict & UNIFY_ALLOW_OUTER_LEVEL)
13087 && TYPE_P (parm) && !CP_TYPE_CONST_P (parm))
13088 strict &= ~UNIFY_ALLOW_MORE_CV_QUAL;
13089 strict &= ~UNIFY_ALLOW_OUTER_LEVEL;
13090 strict &= ~UNIFY_ALLOW_DERIVED;
13091 strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
13092 strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL;
13094 switch (TREE_CODE (parm))
13096 case TYPENAME_TYPE:
13098 case UNBOUND_CLASS_TEMPLATE:
13099 /* In a type which contains a nested-name-specifier, template
13100 argument values cannot be deduced for template parameters used
13101 within the nested-name-specifier. */
13104 case TEMPLATE_TYPE_PARM:
13105 case TEMPLATE_TEMPLATE_PARM:
13106 case BOUND_TEMPLATE_TEMPLATE_PARM:
13107 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
13108 if (tparm == error_mark_node)
13111 if (TEMPLATE_TYPE_LEVEL (parm)
13112 != template_decl_level (tparm))
13113 /* The PARM is not one we're trying to unify. Just check
13114 to see if it matches ARG. */
13115 return (TREE_CODE (arg) == TREE_CODE (parm)
13116 && same_type_p (parm, arg)) ? 0 : 1;
13117 idx = TEMPLATE_TYPE_IDX (parm);
13118 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
13119 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx));
13121 /* Check for mixed types and values. */
13122 if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
13123 && TREE_CODE (tparm) != TYPE_DECL)
13124 || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
13125 && TREE_CODE (tparm) != TEMPLATE_DECL))
13128 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
13130 /* ARG must be constructed from a template class or a template
13131 template parameter. */
13132 if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM
13133 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg))
13137 tree parmvec = TYPE_TI_ARGS (parm);
13138 tree argvec = INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg));
13140 = DECL_INNERMOST_TEMPLATE_PARMS
13141 (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm));
13143 int parm_variadic_p = 0;
13145 /* The resolution to DR150 makes clear that default
13146 arguments for an N-argument may not be used to bind T
13147 to a template template parameter with fewer than N
13148 parameters. It is not safe to permit the binding of
13149 default arguments as an extension, as that may change
13150 the meaning of a conforming program. Consider:
13152 struct Dense { static const unsigned int dim = 1; };
13154 template <template <typename> class View,
13156 void operator+(float, View<Block> const&);
13158 template <typename Block,
13159 unsigned int Dim = Block::dim>
13160 struct Lvalue_proxy { operator float() const; };
13164 Lvalue_proxy<Dense> p;
13169 Here, if Lvalue_proxy is permitted to bind to View, then
13170 the global operator+ will be used; if they are not, the
13171 Lvalue_proxy will be converted to float. */
13172 if (coerce_template_parms (parm_parms,
13174 TYPE_TI_TEMPLATE (parm),
13176 /*require_all_args=*/true,
13177 /*use_default_args=*/false)
13178 == error_mark_node)
13181 /* Deduce arguments T, i from TT<T> or TT<i>.
13182 We check each element of PARMVEC and ARGVEC individually
13183 rather than the whole TREE_VEC since they can have
13184 different number of elements. */
13186 parmvec = expand_template_argument_pack (parmvec);
13187 argvec = expand_template_argument_pack (argvec);
13189 len = TREE_VEC_LENGTH (parmvec);
13191 /* Check if the parameters end in a pack, making them
13194 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec, len - 1)))
13195 parm_variadic_p = 1;
13197 if (TREE_VEC_LENGTH (argvec) < len - parm_variadic_p)
13200 for (i = 0; i < len - parm_variadic_p; ++i)
13202 if (unify (tparms, targs,
13203 TREE_VEC_ELT (parmvec, i),
13204 TREE_VEC_ELT (argvec, i),
13209 if (parm_variadic_p
13210 && unify_pack_expansion (tparms, targs,
13213 /*call_args_p=*/false,
13217 arg = TYPE_TI_TEMPLATE (arg);
13219 /* Fall through to deduce template name. */
13222 if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
13223 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
13225 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
13227 /* Simple cases: Value already set, does match or doesn't. */
13228 if (targ != NULL_TREE && template_args_equal (targ, arg))
13235 /* If PARM is `const T' and ARG is only `int', we don't have
13236 a match unless we are allowing additional qualification.
13237 If ARG is `const int' and PARM is just `T' that's OK;
13238 that binds `const int' to `T'. */
13239 if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL,
13243 /* Consider the case where ARG is `const volatile int' and
13244 PARM is `const T'. Then, T should be `volatile int'. */
13245 arg = cp_build_qualified_type_real
13246 (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
13247 if (arg == error_mark_node)
13250 /* Simple cases: Value already set, does match or doesn't. */
13251 if (targ != NULL_TREE && same_type_p (targ, arg))
13256 /* Make sure that ARG is not a variable-sized array. (Note
13257 that were talking about variable-sized arrays (like
13258 `int[n]'), rather than arrays of unknown size (like
13259 `int[]').) We'll get very confused by such a type since
13260 the bound of the array will not be computable in an
13261 instantiation. Besides, such types are not allowed in
13262 ISO C++, so we can do as we please here. */
13263 if (variably_modified_type_p (arg, NULL_TREE))
13267 /* If ARG is a parameter pack or an expansion, we cannot unify
13268 against it unless PARM is also a parameter pack. */
13269 if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
13270 && !template_parameter_pack_p (parm))
13273 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
13276 case TEMPLATE_PARM_INDEX:
13277 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
13278 if (tparm == error_mark_node)
13281 if (TEMPLATE_PARM_LEVEL (parm)
13282 != template_decl_level (tparm))
13283 /* The PARM is not one we're trying to unify. Just check
13284 to see if it matches ARG. */
13285 return !(TREE_CODE (arg) == TREE_CODE (parm)
13286 && cp_tree_equal (parm, arg));
13288 idx = TEMPLATE_PARM_IDX (parm);
13289 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
13292 return !cp_tree_equal (targ, arg);
13294 /* [temp.deduct.type] If, in the declaration of a function template
13295 with a non-type template-parameter, the non-type
13296 template-parameter is used in an expression in the function
13297 parameter-list and, if the corresponding template-argument is
13298 deduced, the template-argument type shall match the type of the
13299 template-parameter exactly, except that a template-argument
13300 deduced from an array bound may be of any integral type.
13301 The non-type parameter might use already deduced type parameters. */
13302 tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE);
13303 if (!TREE_TYPE (arg))
13304 /* Template-parameter dependent expression. Just accept it for now.
13305 It will later be processed in convert_template_argument. */
13307 else if (same_type_p (TREE_TYPE (arg), tparm))
13309 else if ((strict & UNIFY_ALLOW_INTEGER)
13310 && (TREE_CODE (tparm) == INTEGER_TYPE
13311 || TREE_CODE (tparm) == BOOLEAN_TYPE))
13312 /* Convert the ARG to the type of PARM; the deduced non-type
13313 template argument must exactly match the types of the
13314 corresponding parameter. */
13315 arg = fold (build_nop (TREE_TYPE (parm), arg));
13316 else if (uses_template_parms (tparm))
13317 /* We haven't deduced the type of this parameter yet. Try again
13323 /* If ARG is a parameter pack or an expansion, we cannot unify
13324 against it unless PARM is also a parameter pack. */
13325 if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
13326 && !TEMPLATE_PARM_PARAMETER_PACK (parm))
13329 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
13334 /* A pointer-to-member constant can be unified only with
13335 another constant. */
13336 if (TREE_CODE (arg) != PTRMEM_CST)
13339 /* Just unify the class member. It would be useless (and possibly
13340 wrong, depending on the strict flags) to unify also
13341 PTRMEM_CST_CLASS, because we want to be sure that both parm and
13342 arg refer to the same variable, even if through different
13343 classes. For instance:
13345 struct A { int x; };
13348 Unification of &A::x and &B::x must succeed. */
13349 return unify (tparms, targs, PTRMEM_CST_MEMBER (parm),
13350 PTRMEM_CST_MEMBER (arg), strict);
13355 if (TREE_CODE (arg) != POINTER_TYPE)
13358 /* [temp.deduct.call]
13360 A can be another pointer or pointer to member type that can
13361 be converted to the deduced A via a qualification
13362 conversion (_conv.qual_).
13364 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
13365 This will allow for additional cv-qualification of the
13366 pointed-to types if appropriate. */
13368 if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
13369 /* The derived-to-base conversion only persists through one
13370 level of pointers. */
13371 strict |= (strict_in & UNIFY_ALLOW_DERIVED);
13373 return unify (tparms, targs, TREE_TYPE (parm),
13374 TREE_TYPE (arg), strict);
13377 case REFERENCE_TYPE:
13378 if (TREE_CODE (arg) != REFERENCE_TYPE)
13380 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
13381 strict & UNIFY_ALLOW_MORE_CV_QUAL);
13384 if (TREE_CODE (arg) != ARRAY_TYPE)
13386 if ((TYPE_DOMAIN (parm) == NULL_TREE)
13387 != (TYPE_DOMAIN (arg) == NULL_TREE))
13389 if (TYPE_DOMAIN (parm) != NULL_TREE)
13396 /* Our representation of array types uses "N - 1" as the
13397 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
13398 not an integer constant. We cannot unify arbitrarily
13399 complex expressions, so we eliminate the MINUS_EXPRs
13401 parm_max = TYPE_MAX_VALUE (TYPE_DOMAIN (parm));
13402 parm_cst = TREE_CODE (parm_max) == INTEGER_CST;
13405 gcc_assert (TREE_CODE (parm_max) == MINUS_EXPR);
13406 parm_max = TREE_OPERAND (parm_max, 0);
13408 arg_max = TYPE_MAX_VALUE (TYPE_DOMAIN (arg));
13409 arg_cst = TREE_CODE (arg_max) == INTEGER_CST;
13412 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
13413 trying to unify the type of a variable with the type
13414 of a template parameter. For example:
13416 template <unsigned int N>
13417 void f (char (&) [N]);
13424 Here, the type of the ARG will be "int [g(i)]", and
13425 may be a SAVE_EXPR, etc. */
13426 if (TREE_CODE (arg_max) != MINUS_EXPR)
13428 arg_max = TREE_OPERAND (arg_max, 0);
13431 /* If only one of the bounds used a MINUS_EXPR, compensate
13432 by adding one to the other bound. */
13433 if (parm_cst && !arg_cst)
13434 parm_max = fold_build2 (PLUS_EXPR,
13438 else if (arg_cst && !parm_cst)
13439 arg_max = fold_build2 (PLUS_EXPR,
13444 if (unify (tparms, targs, parm_max, arg_max, UNIFY_ALLOW_INTEGER))
13447 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
13448 strict & UNIFY_ALLOW_MORE_CV_QUAL);
13455 case ENUMERAL_TYPE:
13457 if (TREE_CODE (arg) != TREE_CODE (parm))
13460 /* We have already checked cv-qualification at the top of the
13462 if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
13465 /* As far as unification is concerned, this wins. Later checks
13466 will invalidate it if necessary. */
13469 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
13470 /* Type INTEGER_CST can come from ordinary constant template args. */
13472 while (TREE_CODE (arg) == NOP_EXPR)
13473 arg = TREE_OPERAND (arg, 0);
13475 if (TREE_CODE (arg) != INTEGER_CST)
13477 return !tree_int_cst_equal (parm, arg);
13482 if (TREE_CODE (arg) != TREE_VEC)
13484 if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
13486 for (i = 0; i < TREE_VEC_LENGTH (parm); ++i)
13487 if (unify (tparms, targs,
13488 TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
13496 if (TREE_CODE (arg) != TREE_CODE (parm))
13499 if (TYPE_PTRMEMFUNC_P (parm))
13501 if (!TYPE_PTRMEMFUNC_P (arg))
13504 return unify (tparms, targs,
13505 TYPE_PTRMEMFUNC_FN_TYPE (parm),
13506 TYPE_PTRMEMFUNC_FN_TYPE (arg),
13510 if (CLASSTYPE_TEMPLATE_INFO (parm))
13512 tree t = NULL_TREE;
13514 if (strict_in & UNIFY_ALLOW_DERIVED)
13516 /* First, we try to unify the PARM and ARG directly. */
13517 t = try_class_unification (tparms, targs,
13522 /* Fallback to the special case allowed in
13523 [temp.deduct.call]:
13525 If P is a class, and P has the form
13526 template-id, then A can be a derived class of
13527 the deduced A. Likewise, if P is a pointer to
13528 a class of the form template-id, A can be a
13529 pointer to a derived class pointed to by the
13531 t = get_template_base (tparms, targs, parm, arg);
13537 else if (CLASSTYPE_TEMPLATE_INFO (arg)
13538 && (CLASSTYPE_TI_TEMPLATE (parm)
13539 == CLASSTYPE_TI_TEMPLATE (arg)))
13540 /* Perhaps PARM is something like S<U> and ARG is S<int>.
13541 Then, we should unify `int' and `U'. */
13544 /* There's no chance of unification succeeding. */
13547 return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
13548 CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE);
13550 else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
13555 case FUNCTION_TYPE:
13556 if (TREE_CODE (arg) != TREE_CODE (parm))
13559 /* CV qualifications for methods can never be deduced, they must
13560 match exactly. We need to check them explicitly here,
13561 because type_unification_real treats them as any other
13562 cv-qualified parameter. */
13563 if (TREE_CODE (parm) == METHOD_TYPE
13564 && (!check_cv_quals_for_unify
13566 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (arg))),
13567 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (parm))))))
13570 if (unify (tparms, targs, TREE_TYPE (parm),
13571 TREE_TYPE (arg), UNIFY_ALLOW_NONE))
13573 return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
13574 TYPE_ARG_TYPES (arg), 1, DEDUCE_EXACT,
13578 /* Unify a pointer to member with a pointer to member function, which
13579 deduces the type of the member as a function type. */
13580 if (TYPE_PTRMEMFUNC_P (arg))
13584 cp_cv_quals cv_quals;
13586 /* Check top-level cv qualifiers */
13587 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE, arg, parm))
13590 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
13591 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg), UNIFY_ALLOW_NONE))
13594 /* Determine the type of the function we are unifying against. */
13595 method_type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (arg));
13597 build_function_type (TREE_TYPE (method_type),
13598 TREE_CHAIN (TYPE_ARG_TYPES (method_type)));
13600 /* Extract the cv-qualifiers of the member function from the
13601 implicit object parameter and place them on the function
13602 type to be restored later. */
13604 cp_type_quals(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (method_type))));
13605 fntype = build_qualified_type (fntype, cv_quals);
13606 return unify (tparms, targs, TREE_TYPE (parm), fntype, strict);
13609 if (TREE_CODE (arg) != OFFSET_TYPE)
13611 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
13612 TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE))
13614 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
13618 if (DECL_TEMPLATE_PARM_P (parm))
13619 return unify (tparms, targs, DECL_INITIAL (parm), arg, strict);
13620 if (arg != integral_constant_value (parm))
13625 case TEMPLATE_DECL:
13626 /* Matched cases are handled by the ARG == PARM test above. */
13629 case TYPE_ARGUMENT_PACK:
13630 case NONTYPE_ARGUMENT_PACK:
13632 tree packed_parms = ARGUMENT_PACK_ARGS (parm);
13633 tree packed_args = ARGUMENT_PACK_ARGS (arg);
13634 int i, len = TREE_VEC_LENGTH (packed_parms);
13635 int argslen = TREE_VEC_LENGTH (packed_args);
13636 int parm_variadic_p = 0;
13638 for (i = 0; i < len; ++i)
13640 if (PACK_EXPANSION_P (TREE_VEC_ELT (packed_parms, i)))
13643 /* We can unify against something with a trailing
13645 parm_variadic_p = 1;
13647 /* Since there is something following the pack
13648 expansion, we cannot unify this template argument
13655 /* If we don't have enough arguments to satisfy the parameters
13656 (not counting the pack expression at the end), or we have
13657 too many arguments for a parameter list that doesn't end in
13658 a pack expression, we can't unify. */
13659 if (argslen < (len - parm_variadic_p)
13660 || (argslen > len && !parm_variadic_p))
13663 /* Unify all of the parameters that precede the (optional)
13664 pack expression. */
13665 for (i = 0; i < len - parm_variadic_p; ++i)
13667 if (unify (tparms, targs, TREE_VEC_ELT (packed_parms, i),
13668 TREE_VEC_ELT (packed_args, i), strict))
13672 if (parm_variadic_p)
13673 return unify_pack_expansion (tparms, targs,
13674 packed_parms, packed_args,
13675 strict, /*call_args_p=*/false,
13683 case DECLTYPE_TYPE:
13684 /* Cannot deduce anything from TYPEOF_TYPE or DECLTYPE_TYPE
13689 /* Unification fails if we hit an error node. */
13693 gcc_assert (EXPR_P (parm));
13695 /* We must be looking at an expression. This can happen with
13699 void foo(S<I>, S<I + 2>);
13701 This is a "nondeduced context":
13705 The nondeduced contexts are:
13707 --A type that is a template-id in which one or more of
13708 the template-arguments is an expression that references
13709 a template-parameter.
13711 In these cases, we assume deduction succeeded, but don't
13712 actually infer any unifications. */
13714 if (!uses_template_parms (parm)
13715 && !template_args_equal (parm, arg))
13722 /* Note that DECL can be defined in this translation unit, if
13726 mark_definable (tree decl)
13729 DECL_NOT_REALLY_EXTERN (decl) = 1;
13730 FOR_EACH_CLONE (clone, decl)
13731 DECL_NOT_REALLY_EXTERN (clone) = 1;
13734 /* Called if RESULT is explicitly instantiated, or is a member of an
13735 explicitly instantiated class. */
13738 mark_decl_instantiated (tree result, int extern_p)
13740 SET_DECL_EXPLICIT_INSTANTIATION (result);
13742 /* If this entity has already been written out, it's too late to
13743 make any modifications. */
13744 if (TREE_ASM_WRITTEN (result))
13747 if (TREE_CODE (result) != FUNCTION_DECL)
13748 /* The TREE_PUBLIC flag for function declarations will have been
13749 set correctly by tsubst. */
13750 TREE_PUBLIC (result) = 1;
13752 /* This might have been set by an earlier implicit instantiation. */
13753 DECL_COMDAT (result) = 0;
13756 DECL_NOT_REALLY_EXTERN (result) = 0;
13759 mark_definable (result);
13760 /* Always make artificials weak. */
13761 if (DECL_ARTIFICIAL (result) && flag_weak)
13762 comdat_linkage (result);
13763 /* For WIN32 we also want to put explicit instantiations in
13764 linkonce sections. */
13765 else if (TREE_PUBLIC (result))
13766 maybe_make_one_only (result);
13769 /* If EXTERN_P, then this function will not be emitted -- unless
13770 followed by an explicit instantiation, at which point its linkage
13771 will be adjusted. If !EXTERN_P, then this function will be
13772 emitted here. In neither circumstance do we want
13773 import_export_decl to adjust the linkage. */
13774 DECL_INTERFACE_KNOWN (result) = 1;
13777 /* Given two function templates PAT1 and PAT2, return:
13779 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
13780 -1 if PAT2 is more specialized than PAT1.
13781 0 if neither is more specialized.
13783 LEN indicates the number of parameters we should consider
13784 (defaulted parameters should not be considered).
13786 The 1998 std underspecified function template partial ordering, and
13787 DR214 addresses the issue. We take pairs of arguments, one from
13788 each of the templates, and deduce them against each other. One of
13789 the templates will be more specialized if all the *other*
13790 template's arguments deduce against its arguments and at least one
13791 of its arguments *does* *not* deduce against the other template's
13792 corresponding argument. Deduction is done as for class templates.
13793 The arguments used in deduction have reference and top level cv
13794 qualifiers removed. Iff both arguments were originally reference
13795 types *and* deduction succeeds in both directions, the template
13796 with the more cv-qualified argument wins for that pairing (if
13797 neither is more cv-qualified, they both are equal). Unlike regular
13798 deduction, after all the arguments have been deduced in this way,
13799 we do *not* verify the deduced template argument values can be
13800 substituted into non-deduced contexts, nor do we have to verify
13801 that all template arguments have been deduced. */
13804 more_specialized_fn (tree pat1, tree pat2, int len)
13806 tree decl1 = DECL_TEMPLATE_RESULT (pat1);
13807 tree decl2 = DECL_TEMPLATE_RESULT (pat2);
13808 tree targs1 = make_tree_vec (DECL_NTPARMS (pat1));
13809 tree targs2 = make_tree_vec (DECL_NTPARMS (pat2));
13810 tree tparms1 = DECL_INNERMOST_TEMPLATE_PARMS (pat1);
13811 tree tparms2 = DECL_INNERMOST_TEMPLATE_PARMS (pat2);
13812 tree args1 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
13813 tree args2 = TYPE_ARG_TYPES (TREE_TYPE (decl2));
13817 /* Remove the this parameter from non-static member functions. If
13818 one is a non-static member function and the other is not a static
13819 member function, remove the first parameter from that function
13820 also. This situation occurs for operator functions where we
13821 locate both a member function (with this pointer) and non-member
13822 operator (with explicit first operand). */
13823 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1))
13825 len--; /* LEN is the number of significant arguments for DECL1 */
13826 args1 = TREE_CHAIN (args1);
13827 if (!DECL_STATIC_FUNCTION_P (decl2))
13828 args2 = TREE_CHAIN (args2);
13830 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2))
13832 args2 = TREE_CHAIN (args2);
13833 if (!DECL_STATIC_FUNCTION_P (decl1))
13836 args1 = TREE_CHAIN (args1);
13840 /* If only one is a conversion operator, they are unordered. */
13841 if (DECL_CONV_FN_P (decl1) != DECL_CONV_FN_P (decl2))
13844 /* Consider the return type for a conversion function */
13845 if (DECL_CONV_FN_P (decl1))
13847 args1 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl1)), args1);
13848 args2 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl2)), args2);
13852 processing_template_decl++;
13855 /* Stop when an ellipsis is seen. */
13856 && args1 != NULL_TREE && args2 != NULL_TREE)
13858 tree arg1 = TREE_VALUE (args1);
13859 tree arg2 = TREE_VALUE (args2);
13860 int deduce1, deduce2;
13864 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
13865 && TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
13867 /* When both arguments are pack expansions, we need only
13868 unify the patterns themselves. */
13869 arg1 = PACK_EXPANSION_PATTERN (arg1);
13870 arg2 = PACK_EXPANSION_PATTERN (arg2);
13872 /* This is the last comparison we need to do. */
13876 if (TREE_CODE (arg1) == REFERENCE_TYPE)
13878 arg1 = TREE_TYPE (arg1);
13879 quals1 = cp_type_quals (arg1);
13882 if (TREE_CODE (arg2) == REFERENCE_TYPE)
13884 arg2 = TREE_TYPE (arg2);
13885 quals2 = cp_type_quals (arg2);
13888 if ((quals1 < 0) != (quals2 < 0))
13890 /* Only of the args is a reference, see if we should apply
13891 array/function pointer decay to it. This is not part of
13892 DR214, but is, IMHO, consistent with the deduction rules
13893 for the function call itself, and with our earlier
13894 implementation of the underspecified partial ordering
13895 rules. (nathan). */
13898 switch (TREE_CODE (arg1))
13901 arg1 = TREE_TYPE (arg1);
13903 case FUNCTION_TYPE:
13904 arg1 = build_pointer_type (arg1);
13913 switch (TREE_CODE (arg2))
13916 arg2 = TREE_TYPE (arg2);
13918 case FUNCTION_TYPE:
13919 arg2 = build_pointer_type (arg2);
13928 arg1 = TYPE_MAIN_VARIANT (arg1);
13929 arg2 = TYPE_MAIN_VARIANT (arg2);
13931 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION)
13933 int i, len2 = list_length (args2);
13934 tree parmvec = make_tree_vec (1);
13935 tree argvec = make_tree_vec (len2);
13938 /* Setup the parameter vector, which contains only ARG1. */
13939 TREE_VEC_ELT (parmvec, 0) = arg1;
13941 /* Setup the argument vector, which contains the remaining
13943 for (i = 0; i < len2; i++, ta = TREE_CHAIN (ta))
13944 TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
13946 deduce1 = !unify_pack_expansion (tparms1, targs1, parmvec,
13947 argvec, UNIFY_ALLOW_NONE,
13948 /*call_args_p=*/false,
13951 /* We cannot deduce in the other direction, because ARG1 is
13952 a pack expansion but ARG2 is not. */
13955 else if (TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
13957 int i, len1 = list_length (args1);
13958 tree parmvec = make_tree_vec (1);
13959 tree argvec = make_tree_vec (len1);
13962 /* Setup the parameter vector, which contains only ARG1. */
13963 TREE_VEC_ELT (parmvec, 0) = arg2;
13965 /* Setup the argument vector, which contains the remaining
13967 for (i = 0; i < len1; i++, ta = TREE_CHAIN (ta))
13968 TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
13970 deduce2 = !unify_pack_expansion (tparms2, targs2, parmvec,
13971 argvec, UNIFY_ALLOW_NONE,
13972 /*call_args_p=*/false,
13975 /* We cannot deduce in the other direction, because ARG2 is
13976 a pack expansion but ARG1 is not.*/
13982 /* The normal case, where neither argument is a pack
13984 deduce1 = !unify (tparms1, targs1, arg1, arg2, UNIFY_ALLOW_NONE);
13985 deduce2 = !unify (tparms2, targs2, arg2, arg1, UNIFY_ALLOW_NONE);
13992 if (better1 < 0 && better2 < 0)
13993 /* We've failed to deduce something in either direction.
13994 These must be unordered. */
13997 if (deduce1 && deduce2 && quals1 >= 0 && quals2 >= 0)
13999 /* Deduces in both directions, see if quals can
14000 disambiguate. Pretend the worse one failed to deduce. */
14001 if ((quals1 & quals2) == quals2)
14003 if ((quals1 & quals2) == quals1)
14006 if (deduce1 && !deduce2 && !better2)
14008 if (deduce2 && !deduce1 && !better1)
14011 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
14012 || TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
14013 /* We have already processed all of the arguments in our
14014 handing of the pack expansion type. */
14017 args1 = TREE_CHAIN (args1);
14018 args2 = TREE_CHAIN (args2);
14021 processing_template_decl--;
14023 /* All things being equal, if the next argument is a pack expansion
14024 for one function but not for the other, prefer the
14025 non-variadic function. */
14026 if ((better1 > 0) - (better2 > 0) == 0
14027 && args1 && TREE_VALUE (args1)
14028 && args2 && TREE_VALUE (args2))
14030 if (TREE_CODE (TREE_VALUE (args1)) == TYPE_PACK_EXPANSION)
14031 return TREE_CODE (TREE_VALUE (args2)) == TYPE_PACK_EXPANSION ? 0 : -1;
14032 else if (TREE_CODE (TREE_VALUE (args2)) == TYPE_PACK_EXPANSION)
14036 return (better1 > 0) - (better2 > 0);
14039 /* Determine which of two partial specializations is more specialized.
14041 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
14042 to the first partial specialization. The TREE_VALUE is the
14043 innermost set of template parameters for the partial
14044 specialization. PAT2 is similar, but for the second template.
14046 Return 1 if the first partial specialization is more specialized;
14047 -1 if the second is more specialized; 0 if neither is more
14050 See [temp.class.order] for information about determining which of
14051 two templates is more specialized. */
14054 more_specialized_class (tree pat1, tree pat2)
14059 bool any_deductions = false;
14061 tmpl1 = TREE_TYPE (pat1);
14062 tmpl2 = TREE_TYPE (pat2);
14064 /* Just like what happens for functions, if we are ordering between
14065 different class template specializations, we may encounter dependent
14066 types in the arguments, and we need our dependency check functions
14067 to behave correctly. */
14068 ++processing_template_decl;
14069 targs = get_class_bindings (TREE_VALUE (pat1),
14070 CLASSTYPE_TI_ARGS (tmpl1),
14071 CLASSTYPE_TI_ARGS (tmpl2));
14075 any_deductions = true;
14078 targs = get_class_bindings (TREE_VALUE (pat2),
14079 CLASSTYPE_TI_ARGS (tmpl2),
14080 CLASSTYPE_TI_ARGS (tmpl1));
14084 any_deductions = true;
14086 --processing_template_decl;
14088 /* In the case of a tie where at least one of the class templates
14089 has a parameter pack at the end, the template with the most
14090 non-packed parameters wins. */
14093 && (template_args_variadic_p (TREE_PURPOSE (pat1))
14094 || template_args_variadic_p (TREE_PURPOSE (pat2))))
14096 tree args1 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1));
14097 tree args2 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2));
14098 int len1 = TREE_VEC_LENGTH (args1);
14099 int len2 = TREE_VEC_LENGTH (args2);
14101 /* We don't count the pack expansion at the end. */
14102 if (template_args_variadic_p (TREE_PURPOSE (pat1)))
14104 if (template_args_variadic_p (TREE_PURPOSE (pat2)))
14109 else if (len1 < len2)
14116 /* Return the template arguments that will produce the function signature
14117 DECL from the function template FN, with the explicit template
14118 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
14119 also match. Return NULL_TREE if no satisfactory arguments could be
14123 get_bindings (tree fn, tree decl, tree explicit_args, bool check_rettype)
14125 int ntparms = DECL_NTPARMS (fn);
14126 tree targs = make_tree_vec (ntparms);
14128 tree decl_arg_types;
14130 /* Substitute the explicit template arguments into the type of DECL.
14131 The call to fn_type_unification will handle substitution into the
14133 decl_type = TREE_TYPE (decl);
14134 if (explicit_args && uses_template_parms (decl_type))
14137 tree converted_args;
14139 if (DECL_TEMPLATE_INFO (decl))
14140 tmpl = DECL_TI_TEMPLATE (decl);
14142 /* We can get here for some invalid specializations. */
14146 = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
14147 explicit_args, NULL_TREE,
14149 /*require_all_args=*/false,
14150 /*use_default_args=*/false);
14151 if (converted_args == error_mark_node)
14154 decl_type = tsubst (decl_type, converted_args, tf_none, NULL_TREE);
14155 if (decl_type == error_mark_node)
14159 /* Never do unification on the 'this' parameter. */
14160 decl_arg_types = skip_artificial_parms_for (decl,
14161 TYPE_ARG_TYPES (decl_type));
14163 if (fn_type_unification (fn, explicit_args, targs,
14165 (check_rettype || DECL_CONV_FN_P (fn)
14166 ? TREE_TYPE (decl_type) : NULL_TREE),
14167 DEDUCE_EXACT, LOOKUP_NORMAL))
14173 /* Return the innermost template arguments that, when applied to a
14174 template specialization whose innermost template parameters are
14175 TPARMS, and whose specialization arguments are PARMS, yield the
14178 For example, suppose we have:
14180 template <class T, class U> struct S {};
14181 template <class T> struct S<T*, int> {};
14183 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
14184 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
14185 int}. The resulting vector will be {double}, indicating that `T'
14186 is bound to `double'. */
14189 get_class_bindings (tree tparms, tree spec_args, tree args)
14191 int i, ntparms = TREE_VEC_LENGTH (tparms);
14193 tree innermost_deduced_args;
14195 innermost_deduced_args = make_tree_vec (ntparms);
14196 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
14198 deduced_args = copy_node (args);
14199 SET_TMPL_ARGS_LEVEL (deduced_args,
14200 TMPL_ARGS_DEPTH (deduced_args),
14201 innermost_deduced_args);
14204 deduced_args = innermost_deduced_args;
14206 if (unify (tparms, deduced_args,
14207 INNERMOST_TEMPLATE_ARGS (spec_args),
14208 INNERMOST_TEMPLATE_ARGS (args),
14212 for (i = 0; i < ntparms; ++i)
14213 if (! TREE_VEC_ELT (innermost_deduced_args, i))
14216 /* Verify that nondeduced template arguments agree with the type
14217 obtained from argument deduction.
14221 struct A { typedef int X; };
14222 template <class T, class U> struct C {};
14223 template <class T> struct C<T, typename T::X> {};
14225 Then with the instantiation `C<A, int>', we can deduce that
14226 `T' is `A' but unify () does not check whether `typename T::X'
14228 spec_args = tsubst (spec_args, deduced_args, tf_none, NULL_TREE);
14229 if (spec_args == error_mark_node
14230 /* We only need to check the innermost arguments; the other
14231 arguments will always agree. */
14232 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args),
14233 INNERMOST_TEMPLATE_ARGS (args)))
14236 /* Now that we have bindings for all of the template arguments,
14237 ensure that the arguments deduced for the template template
14238 parameters have compatible template parameter lists. See the use
14239 of template_template_parm_bindings_ok_p in fn_type_unification
14240 for more information. */
14241 if (!template_template_parm_bindings_ok_p (tparms, deduced_args))
14244 return deduced_args;
14247 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
14248 Return the TREE_LIST node with the most specialized template, if
14249 any. If there is no most specialized template, the error_mark_node
14252 Note that this function does not look at, or modify, the
14253 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
14254 returned is one of the elements of INSTANTIATIONS, callers may
14255 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
14256 and retrieve it from the value returned. */
14259 most_specialized_instantiation (tree templates)
14263 ++processing_template_decl;
14266 for (fn = TREE_CHAIN (templates); fn; fn = TREE_CHAIN (fn))
14270 if (get_bindings (TREE_VALUE (champ),
14271 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
14272 NULL_TREE, /*check_ret=*/false))
14275 if (get_bindings (TREE_VALUE (fn),
14276 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
14277 NULL_TREE, /*check_ret=*/false))
14284 /* Equally specialized, move to next function. If there
14285 is no next function, nothing's most specialized. */
14286 fn = TREE_CHAIN (fn);
14294 /* Now verify that champ is better than everything earlier in the
14295 instantiation list. */
14296 for (fn = templates; fn != champ; fn = TREE_CHAIN (fn))
14297 if (get_bindings (TREE_VALUE (champ),
14298 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
14299 NULL_TREE, /*check_ret=*/false)
14300 || !get_bindings (TREE_VALUE (fn),
14301 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
14302 NULL_TREE, /*check_ret=*/false))
14308 processing_template_decl--;
14311 return error_mark_node;
14316 /* If DECL is a specialization of some template, return the most
14317 general such template. Otherwise, returns NULL_TREE.
14319 For example, given:
14321 template <class T> struct S { template <class U> void f(U); };
14323 if TMPL is `template <class U> void S<int>::f(U)' this will return
14324 the full template. This function will not trace past partial
14325 specializations, however. For example, given in addition:
14327 template <class T> struct S<T*> { template <class U> void f(U); };
14329 if TMPL is `template <class U> void S<int*>::f(U)' this will return
14330 `template <class T> template <class U> S<T*>::f(U)'. */
14333 most_general_template (tree decl)
14335 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
14336 an immediate specialization. */
14337 if (TREE_CODE (decl) == FUNCTION_DECL)
14339 if (DECL_TEMPLATE_INFO (decl)) {
14340 decl = DECL_TI_TEMPLATE (decl);
14342 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
14343 template friend. */
14344 if (TREE_CODE (decl) != TEMPLATE_DECL)
14350 /* Look for more and more general templates. */
14351 while (DECL_TEMPLATE_INFO (decl))
14353 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
14354 (See cp-tree.h for details.) */
14355 if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
14358 if (CLASS_TYPE_P (TREE_TYPE (decl))
14359 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
14362 /* Stop if we run into an explicitly specialized class template. */
14363 if (!DECL_NAMESPACE_SCOPE_P (decl)
14364 && DECL_CONTEXT (decl)
14365 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl)))
14368 decl = DECL_TI_TEMPLATE (decl);
14374 /* Return the most specialized of the class template partial
14375 specializations of TMPL which can produce TYPE, a specialization of
14376 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
14377 a _TYPE node corresponding to the partial specialization, while the
14378 TREE_PURPOSE is the set of template arguments that must be
14379 substituted into the TREE_TYPE in order to generate TYPE.
14381 If the choice of partial specialization is ambiguous, a diagnostic
14382 is issued, and the error_mark_node is returned. If there are no
14383 partial specializations of TMPL matching TYPE, then NULL_TREE is
14387 most_specialized_class (tree type, tree tmpl)
14389 tree list = NULL_TREE;
14395 tree outer_args = NULL_TREE;
14397 tmpl = most_general_template (tmpl);
14398 args = CLASSTYPE_TI_ARGS (type);
14400 /* For determining which partial specialization to use, only the
14401 innermost args are interesting. */
14402 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
14404 outer_args = strip_innermost_template_args (args, 1);
14405 args = INNERMOST_TEMPLATE_ARGS (args);
14408 for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t))
14410 tree partial_spec_args;
14412 tree parms = TREE_VALUE (t);
14414 partial_spec_args = CLASSTYPE_TI_ARGS (TREE_TYPE (t));
14419 ++processing_template_decl;
14421 /* Discard the outer levels of args, and then substitute in the
14422 template args from the enclosing class. */
14423 partial_spec_args = INNERMOST_TEMPLATE_ARGS (partial_spec_args);
14424 partial_spec_args = tsubst_template_args
14425 (partial_spec_args, outer_args, tf_none, NULL_TREE);
14427 /* PARMS already refers to just the innermost parms, but the
14428 template parms in partial_spec_args had their levels lowered
14429 by tsubst, so we need to do the same for the parm list. We
14430 can't just tsubst the TREE_VEC itself, as tsubst wants to
14431 treat a TREE_VEC as an argument vector. */
14432 parms = copy_node (parms);
14433 for (i = TREE_VEC_LENGTH (parms) - 1; i >= 0; --i)
14434 TREE_VEC_ELT (parms, i) =
14435 tsubst (TREE_VEC_ELT (parms, i), outer_args, tf_none, NULL_TREE);
14437 --processing_template_decl;
14439 spec_args = get_class_bindings (parms,
14445 spec_args = add_to_template_args (outer_args, spec_args);
14446 list = tree_cons (spec_args, TREE_VALUE (t), list);
14447 TREE_TYPE (list) = TREE_TYPE (t);
14454 ambiguous_p = false;
14457 t = TREE_CHAIN (t);
14458 for (; t; t = TREE_CHAIN (t))
14460 fate = more_specialized_class (champ, t);
14467 t = TREE_CHAIN (t);
14470 ambiguous_p = true;
14479 for (t = list; t && t != champ; t = TREE_CHAIN (t))
14481 fate = more_specialized_class (champ, t);
14484 ambiguous_p = true;
14491 const char *str = "candidates are:";
14492 error ("ambiguous class template instantiation for %q#T", type);
14493 for (t = list; t; t = TREE_CHAIN (t))
14495 error ("%s %+#T", str, TREE_TYPE (t));
14498 return error_mark_node;
14504 /* Explicitly instantiate DECL. */
14507 do_decl_instantiation (tree decl, tree storage)
14509 tree result = NULL_TREE;
14512 if (!decl || decl == error_mark_node)
14513 /* An error occurred, for which grokdeclarator has already issued
14514 an appropriate message. */
14516 else if (! DECL_LANG_SPECIFIC (decl))
14518 error ("explicit instantiation of non-template %q#D", decl);
14521 else if (TREE_CODE (decl) == VAR_DECL)
14523 /* There is an asymmetry here in the way VAR_DECLs and
14524 FUNCTION_DECLs are handled by grokdeclarator. In the case of
14525 the latter, the DECL we get back will be marked as a
14526 template instantiation, and the appropriate
14527 DECL_TEMPLATE_INFO will be set up. This does not happen for
14528 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
14529 should handle VAR_DECLs as it currently handles
14531 if (!DECL_CLASS_SCOPE_P (decl))
14533 error ("%qD is not a static data member of a class template", decl);
14536 result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false);
14537 if (!result || TREE_CODE (result) != VAR_DECL)
14539 error ("no matching template for %qD found", decl);
14542 if (!same_type_p (TREE_TYPE (result), TREE_TYPE (decl)))
14544 error ("type %qT for explicit instantiation %qD does not match "
14545 "declared type %qT", TREE_TYPE (result), decl,
14550 else if (TREE_CODE (decl) != FUNCTION_DECL)
14552 error ("explicit instantiation of %q#D", decl);
14558 /* Check for various error cases. Note that if the explicit
14559 instantiation is valid the RESULT will currently be marked as an
14560 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
14561 until we get here. */
14563 if (DECL_TEMPLATE_SPECIALIZATION (result))
14565 /* DR 259 [temp.spec].
14567 Both an explicit instantiation and a declaration of an explicit
14568 specialization shall not appear in a program unless the explicit
14569 instantiation follows a declaration of the explicit specialization.
14571 For a given set of template parameters, if an explicit
14572 instantiation of a template appears after a declaration of an
14573 explicit specialization for that template, the explicit
14574 instantiation has no effect. */
14577 else if (DECL_EXPLICIT_INSTANTIATION (result))
14581 No program shall explicitly instantiate any template more
14584 We check DECL_NOT_REALLY_EXTERN so as not to complain when
14585 the first instantiation was `extern' and the second is not,
14586 and EXTERN_P for the opposite case. */
14587 if (DECL_NOT_REALLY_EXTERN (result) && !extern_p)
14588 permerror ("duplicate explicit instantiation of %q#D", result);
14589 /* If an "extern" explicit instantiation follows an ordinary
14590 explicit instantiation, the template is instantiated. */
14594 else if (!DECL_IMPLICIT_INSTANTIATION (result))
14596 error ("no matching template for %qD found", result);
14599 else if (!DECL_TEMPLATE_INFO (result))
14601 permerror ("explicit instantiation of non-template %q#D", result);
14605 if (storage == NULL_TREE)
14607 else if (storage == ridpointers[(int) RID_EXTERN])
14609 if (!in_system_header && (cxx_dialect == cxx98))
14610 pedwarn (OPT_pedantic,
14611 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
14616 error ("storage class %qD applied to template instantiation", storage);
14618 check_explicit_instantiation_namespace (result);
14619 mark_decl_instantiated (result, extern_p);
14621 instantiate_decl (result, /*defer_ok=*/1,
14622 /*expl_inst_class_mem_p=*/false);
14626 mark_class_instantiated (tree t, int extern_p)
14628 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
14629 SET_CLASSTYPE_INTERFACE_KNOWN (t);
14630 CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
14631 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
14634 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
14635 rest_of_type_compilation (t, 1);
14639 /* Called from do_type_instantiation through binding_table_foreach to
14640 do recursive instantiation for the type bound in ENTRY. */
14642 bt_instantiate_type_proc (binding_entry entry, void *data)
14644 tree storage = *(tree *) data;
14646 if (MAYBE_CLASS_TYPE_P (entry->type)
14647 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type)))
14648 do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0);
14651 /* Called from do_type_instantiation to instantiate a member
14652 (a member function or a static member variable) of an
14653 explicitly instantiated class template. */
14655 instantiate_class_member (tree decl, int extern_p)
14657 mark_decl_instantiated (decl, extern_p);
14659 instantiate_decl (decl, /*defer_ok=*/1,
14660 /*expl_inst_class_mem_p=*/true);
14663 /* Perform an explicit instantiation of template class T. STORAGE, if
14664 non-null, is the RID for extern, inline or static. COMPLAIN is
14665 nonzero if this is called from the parser, zero if called recursively,
14666 since the standard is unclear (as detailed below). */
14669 do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
14674 int previous_instantiation_extern_p = 0;
14676 if (TREE_CODE (t) == TYPE_DECL)
14679 if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t))
14681 error ("explicit instantiation of non-template type %qT", t);
14687 if (!COMPLETE_TYPE_P (t))
14689 if (complain & tf_error)
14690 error ("explicit instantiation of %q#T before definition of template",
14695 if (storage != NULL_TREE)
14697 if (!in_system_header)
14699 if (storage == ridpointers[(int) RID_EXTERN])
14701 if (cxx_dialect == cxx98)
14702 pedwarn(OPT_pedantic,
14703 "ISO C++ 1998 forbids the use of %<extern%> on "
14704 "explicit instantiations");
14707 pedwarn(OPT_pedantic, "ISO C++ forbids the use of %qE on explicit "
14708 "instantiations", storage);
14711 if (storage == ridpointers[(int) RID_INLINE])
14713 else if (storage == ridpointers[(int) RID_EXTERN])
14715 else if (storage == ridpointers[(int) RID_STATIC])
14719 error ("storage class %qD applied to template instantiation",
14725 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
14727 /* DR 259 [temp.spec].
14729 Both an explicit instantiation and a declaration of an explicit
14730 specialization shall not appear in a program unless the explicit
14731 instantiation follows a declaration of the explicit specialization.
14733 For a given set of template parameters, if an explicit
14734 instantiation of a template appears after a declaration of an
14735 explicit specialization for that template, the explicit
14736 instantiation has no effect. */
14739 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t))
14743 No program shall explicitly instantiate any template more
14746 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
14747 instantiation was `extern'. If EXTERN_P then the second is.
14748 These cases are OK. */
14749 previous_instantiation_extern_p = CLASSTYPE_INTERFACE_ONLY (t);
14751 if (!previous_instantiation_extern_p && !extern_p
14752 && (complain & tf_error))
14753 permerror ("duplicate explicit instantiation of %q#T", t);
14755 /* If we've already instantiated the template, just return now. */
14756 if (!CLASSTYPE_INTERFACE_ONLY (t))
14760 check_explicit_instantiation_namespace (TYPE_NAME (t));
14761 mark_class_instantiated (t, extern_p);
14769 /* In contrast to implicit instantiation, where only the
14770 declarations, and not the definitions, of members are
14771 instantiated, we have here:
14775 The explicit instantiation of a class template specialization
14776 implies the instantiation of all of its members not
14777 previously explicitly specialized in the translation unit
14778 containing the explicit instantiation.
14780 Of course, we can't instantiate member template classes, since
14781 we don't have any arguments for them. Note that the standard
14782 is unclear on whether the instantiation of the members are
14783 *explicit* instantiations or not. However, the most natural
14784 interpretation is that it should be an explicit instantiation. */
14787 for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp))
14788 if (TREE_CODE (tmp) == FUNCTION_DECL
14789 && DECL_TEMPLATE_INSTANTIATION (tmp))
14790 instantiate_class_member (tmp, extern_p);
14792 for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp))
14793 if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp))
14794 instantiate_class_member (tmp, extern_p);
14796 if (CLASSTYPE_NESTED_UTDS (t))
14797 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t),
14798 bt_instantiate_type_proc, &storage);
14802 /* Given a function DECL, which is a specialization of TMPL, modify
14803 DECL to be a re-instantiation of TMPL with the same template
14804 arguments. TMPL should be the template into which tsubst'ing
14805 should occur for DECL, not the most general template.
14807 One reason for doing this is a scenario like this:
14810 void f(const T&, int i);
14812 void g() { f(3, 7); }
14815 void f(const T& t, const int i) { }
14817 Note that when the template is first instantiated, with
14818 instantiate_template, the resulting DECL will have no name for the
14819 first parameter, and the wrong type for the second. So, when we go
14820 to instantiate the DECL, we regenerate it. */
14823 regenerate_decl_from_template (tree decl, tree tmpl)
14825 /* The arguments used to instantiate DECL, from the most general
14830 args = DECL_TI_ARGS (decl);
14831 code_pattern = DECL_TEMPLATE_RESULT (tmpl);
14833 /* Make sure that we can see identifiers, and compute access
14835 push_access_scope (decl);
14837 if (TREE_CODE (decl) == FUNCTION_DECL)
14845 args_depth = TMPL_ARGS_DEPTH (args);
14846 parms_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
14847 if (args_depth > parms_depth)
14848 args = get_innermost_template_args (args, parms_depth);
14850 specs = tsubst_exception_specification (TREE_TYPE (code_pattern),
14851 args, tf_error, NULL_TREE);
14853 TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl),
14856 /* Merge parameter declarations. */
14857 decl_parm = skip_artificial_parms_for (decl,
14858 DECL_ARGUMENTS (decl));
14860 = skip_artificial_parms_for (code_pattern,
14861 DECL_ARGUMENTS (code_pattern));
14862 while (decl_parm && !FUNCTION_PARAMETER_PACK_P (pattern_parm))
14867 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
14868 DECL_NAME (decl_parm) = DECL_NAME (pattern_parm);
14869 parm_type = tsubst (TREE_TYPE (pattern_parm), args, tf_error,
14871 parm_type = type_decays_to (parm_type);
14872 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
14873 TREE_TYPE (decl_parm) = parm_type;
14874 attributes = DECL_ATTRIBUTES (pattern_parm);
14875 if (DECL_ATTRIBUTES (decl_parm) != attributes)
14877 DECL_ATTRIBUTES (decl_parm) = attributes;
14878 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
14880 decl_parm = TREE_CHAIN (decl_parm);
14881 pattern_parm = TREE_CHAIN (pattern_parm);
14883 /* Merge any parameters that match with the function parameter
14885 if (pattern_parm && FUNCTION_PARAMETER_PACK_P (pattern_parm))
14888 tree expanded_types;
14889 /* Expand the TYPE_PACK_EXPANSION that provides the types for
14890 the parameters in this function parameter pack. */
14891 expanded_types = tsubst_pack_expansion (TREE_TYPE (pattern_parm),
14892 args, tf_error, NULL_TREE);
14893 len = TREE_VEC_LENGTH (expanded_types);
14894 for (i = 0; i < len; i++)
14899 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
14900 /* Rename the parameter to include the index. */
14901 DECL_NAME (decl_parm) =
14902 make_ith_pack_parameter_name (DECL_NAME (pattern_parm), i);
14903 parm_type = TREE_VEC_ELT (expanded_types, i);
14904 parm_type = type_decays_to (parm_type);
14905 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
14906 TREE_TYPE (decl_parm) = parm_type;
14907 attributes = DECL_ATTRIBUTES (pattern_parm);
14908 if (DECL_ATTRIBUTES (decl_parm) != attributes)
14910 DECL_ATTRIBUTES (decl_parm) = attributes;
14911 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
14913 decl_parm = TREE_CHAIN (decl_parm);
14916 /* Merge additional specifiers from the CODE_PATTERN. */
14917 if (DECL_DECLARED_INLINE_P (code_pattern)
14918 && !DECL_DECLARED_INLINE_P (decl))
14919 DECL_DECLARED_INLINE_P (decl) = 1;
14921 else if (TREE_CODE (decl) == VAR_DECL)
14922 DECL_INITIAL (decl) =
14923 tsubst_expr (DECL_INITIAL (code_pattern), args,
14924 tf_error, DECL_TI_TEMPLATE (decl),
14925 /*integral_constant_expression_p=*/false);
14927 gcc_unreachable ();
14929 pop_access_scope (decl);
14932 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
14933 substituted to get DECL. */
14936 template_for_substitution (tree decl)
14938 tree tmpl = DECL_TI_TEMPLATE (decl);
14940 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
14941 for the instantiation. This is not always the most general
14942 template. Consider, for example:
14945 struct S { template <class U> void f();
14946 template <> void f<int>(); };
14948 and an instantiation of S<double>::f<int>. We want TD to be the
14949 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
14950 while (/* An instantiation cannot have a definition, so we need a
14951 more general template. */
14952 DECL_TEMPLATE_INSTANTIATION (tmpl)
14953 /* We must also deal with friend templates. Given:
14955 template <class T> struct S {
14956 template <class U> friend void f() {};
14959 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
14960 so far as the language is concerned, but that's still
14961 where we get the pattern for the instantiation from. On
14962 other hand, if the definition comes outside the class, say:
14964 template <class T> struct S {
14965 template <class U> friend void f();
14967 template <class U> friend void f() {}
14969 we don't need to look any further. That's what the check for
14970 DECL_INITIAL is for. */
14971 || (TREE_CODE (decl) == FUNCTION_DECL
14972 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl)
14973 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl))))
14975 /* The present template, TD, should not be a definition. If it
14976 were a definition, we should be using it! Note that we
14977 cannot restructure the loop to just keep going until we find
14978 a template with a definition, since that might go too far if
14979 a specialization was declared, but not defined. */
14980 gcc_assert (TREE_CODE (decl) != VAR_DECL
14981 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl)));
14983 /* Fetch the more general template. */
14984 tmpl = DECL_TI_TEMPLATE (tmpl);
14990 /* Produce the definition of D, a _DECL generated from a template. If
14991 DEFER_OK is nonzero, then we don't have to actually do the
14992 instantiation now; we just have to do it sometime. Normally it is
14993 an error if this is an explicit instantiation but D is undefined.
14994 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
14995 explicitly instantiated class template. */
14998 instantiate_decl (tree d, int defer_ok,
14999 bool expl_inst_class_mem_p)
15001 tree tmpl = DECL_TI_TEMPLATE (d);
15008 bool pattern_defined;
15010 location_t saved_loc = input_location;
15013 /* This function should only be used to instantiate templates for
15014 functions and static member variables. */
15015 gcc_assert (TREE_CODE (d) == FUNCTION_DECL
15016 || TREE_CODE (d) == VAR_DECL);
15018 /* Variables are never deferred; if instantiation is required, they
15019 are instantiated right away. That allows for better code in the
15020 case that an expression refers to the value of the variable --
15021 if the variable has a constant value the referring expression can
15022 take advantage of that fact. */
15023 if (TREE_CODE (d) == VAR_DECL)
15026 /* Don't instantiate cloned functions. Instead, instantiate the
15027 functions they cloned. */
15028 if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d))
15029 d = DECL_CLONED_FUNCTION (d);
15031 if (DECL_TEMPLATE_INSTANTIATED (d))
15032 /* D has already been instantiated. It might seem reasonable to
15033 check whether or not D is an explicit instantiation, and, if so,
15034 stop here. But when an explicit instantiation is deferred
15035 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
15036 is set, even though we still need to do the instantiation. */
15039 /* If we already have a specialization of this declaration, then
15040 there's no reason to instantiate it. Note that
15041 retrieve_specialization gives us both instantiations and
15042 specializations, so we must explicitly check
15043 DECL_TEMPLATE_SPECIALIZATION. */
15044 gen_tmpl = most_general_template (tmpl);
15045 gen_args = DECL_TI_ARGS (d);
15046 spec = retrieve_specialization (gen_tmpl, gen_args,
15047 /*class_specializations_p=*/false);
15048 if (spec != NULL_TREE && DECL_TEMPLATE_SPECIALIZATION (spec))
15051 /* This needs to happen before any tsubsting. */
15052 if (! push_tinst_level (d))
15055 timevar_push (TV_PARSE);
15057 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
15058 for the instantiation. */
15059 td = template_for_substitution (d);
15060 code_pattern = DECL_TEMPLATE_RESULT (td);
15062 /* We should never be trying to instantiate a member of a class
15063 template or partial specialization. */
15064 gcc_assert (d != code_pattern);
15066 if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d))
15067 || DECL_TEMPLATE_SPECIALIZATION (td))
15068 /* In the case of a friend template whose definition is provided
15069 outside the class, we may have too many arguments. Drop the
15070 ones we don't need. The same is true for specializations. */
15071 args = get_innermost_template_args
15072 (gen_args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td)));
15076 if (TREE_CODE (d) == FUNCTION_DECL)
15077 pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE);
15079 pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
15081 /* We may be in the middle of deferred access check. Disable it now. */
15082 push_deferring_access_checks (dk_no_deferred);
15084 /* Unless an explicit instantiation directive has already determined
15085 the linkage of D, remember that a definition is available for
15087 if (pattern_defined
15088 && !DECL_INTERFACE_KNOWN (d)
15089 && !DECL_NOT_REALLY_EXTERN (d))
15090 mark_definable (d);
15092 input_location = DECL_SOURCE_LOCATION (d);
15094 /* If D is a member of an explicitly instantiated class template,
15095 and no definition is available, treat it like an implicit
15097 if (!pattern_defined && expl_inst_class_mem_p
15098 && DECL_EXPLICIT_INSTANTIATION (d))
15100 DECL_NOT_REALLY_EXTERN (d) = 0;
15101 DECL_INTERFACE_KNOWN (d) = 0;
15102 SET_DECL_IMPLICIT_INSTANTIATION (d);
15107 /* Recheck the substitutions to obtain any warning messages
15108 about ignoring cv qualifiers. */
15109 tree gen = DECL_TEMPLATE_RESULT (gen_tmpl);
15110 tree type = TREE_TYPE (gen);
15112 /* Make sure that we can see identifiers, and compute access
15113 correctly. D is already the target FUNCTION_DECL with the
15115 push_access_scope (d);
15117 if (TREE_CODE (gen) == FUNCTION_DECL)
15119 tsubst (DECL_ARGUMENTS (gen), gen_args, tf_warning_or_error, d);
15120 tsubst_exception_specification (type, gen_args, tf_warning_or_error,
15122 /* Don't simply tsubst the function type, as that will give
15123 duplicate warnings about poor parameter qualifications.
15124 The function arguments are the same as the decl_arguments
15125 without the top level cv qualifiers. */
15126 type = TREE_TYPE (type);
15128 tsubst (type, gen_args, tf_warning_or_error, d);
15130 pop_access_scope (d);
15133 /* Check to see whether we know that this template will be
15134 instantiated in some other file, as with "extern template"
15136 external_p = (DECL_INTERFACE_KNOWN (d) && DECL_REALLY_EXTERN (d));
15137 /* In general, we do not instantiate such templates... */
15139 /* ... but we instantiate inline functions so that we can inline
15141 && ! (TREE_CODE (d) == FUNCTION_DECL
15142 && possibly_inlined_p (d))
15143 /* ... we instantiate static data members whose values are
15144 needed in integral constant expressions. */
15145 && ! (TREE_CODE (d) == VAR_DECL
15146 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (d)))
15148 /* Defer all other templates, unless we have been explicitly
15149 forbidden from doing so. */
15150 if (/* If there is no definition, we cannot instantiate the
15153 /* If it's OK to postpone instantiation, do so. */
15155 /* If this is a static data member that will be defined
15156 elsewhere, we don't want to instantiate the entire data
15157 member, but we do want to instantiate the initializer so that
15158 we can substitute that elsewhere. */
15159 || (external_p && TREE_CODE (d) == VAR_DECL))
15161 /* The definition of the static data member is now required so
15162 we must substitute the initializer. */
15163 if (TREE_CODE (d) == VAR_DECL
15164 && !DECL_INITIAL (d)
15165 && DECL_INITIAL (code_pattern))
15170 ns = decl_namespace_context (d);
15171 push_nested_namespace (ns);
15172 push_nested_class (DECL_CONTEXT (d));
15173 init = tsubst_expr (DECL_INITIAL (code_pattern),
15175 tf_warning_or_error, NULL_TREE,
15176 /*integral_constant_expression_p=*/false);
15177 cp_finish_decl (d, init, /*init_const_expr_p=*/false,
15178 /*asmspec_tree=*/NULL_TREE,
15179 LOOKUP_ONLYCONVERTING);
15180 pop_nested_class ();
15181 pop_nested_namespace (ns);
15184 /* We restore the source position here because it's used by
15185 add_pending_template. */
15186 input_location = saved_loc;
15188 if (at_eof && !pattern_defined
15189 && DECL_EXPLICIT_INSTANTIATION (d))
15192 The definition of a non-exported function template, a
15193 non-exported member function template, or a non-exported
15194 member function or static data member of a class template
15195 shall be present in every translation unit in which it is
15196 explicitly instantiated. */
15198 ("explicit instantiation of %qD but no definition available", d);
15200 /* ??? Historically, we have instantiated inline functions, even
15201 when marked as "extern template". */
15202 if (!(external_p && TREE_CODE (d) == VAR_DECL))
15203 add_pending_template (d);
15206 /* Tell the repository that D is available in this translation unit
15207 -- and see if it is supposed to be instantiated here. */
15208 if (TREE_PUBLIC (d) && !DECL_REALLY_EXTERN (d) && !repo_emit_p (d))
15210 /* In a PCH file, despite the fact that the repository hasn't
15211 requested instantiation in the PCH it is still possible that
15212 an instantiation will be required in a file that includes the
15215 add_pending_template (d);
15216 /* Instantiate inline functions so that the inliner can do its
15217 job, even though we'll not be emitting a copy of this
15219 if (!(TREE_CODE (d) == FUNCTION_DECL && possibly_inlined_p (d)))
15223 need_push = !cfun || !global_bindings_p ();
15225 push_to_top_level ();
15227 /* Mark D as instantiated so that recursive calls to
15228 instantiate_decl do not try to instantiate it again. */
15229 DECL_TEMPLATE_INSTANTIATED (d) = 1;
15231 /* Regenerate the declaration in case the template has been modified
15232 by a subsequent redeclaration. */
15233 regenerate_decl_from_template (d, td);
15235 /* We already set the file and line above. Reset them now in case
15236 they changed as a result of calling regenerate_decl_from_template. */
15237 input_location = DECL_SOURCE_LOCATION (d);
15239 if (TREE_CODE (d) == VAR_DECL)
15243 /* Clear out DECL_RTL; whatever was there before may not be right
15244 since we've reset the type of the declaration. */
15245 SET_DECL_RTL (d, NULL_RTX);
15246 DECL_IN_AGGR_P (d) = 0;
15248 /* The initializer is placed in DECL_INITIAL by
15249 regenerate_decl_from_template. Pull it out so that
15250 finish_decl can process it. */
15251 init = DECL_INITIAL (d);
15252 DECL_INITIAL (d) = NULL_TREE;
15253 DECL_INITIALIZED_P (d) = 0;
15255 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
15256 initializer. That function will defer actual emission until
15257 we have a chance to determine linkage. */
15258 DECL_EXTERNAL (d) = 0;
15260 /* Enter the scope of D so that access-checking works correctly. */
15261 push_nested_class (DECL_CONTEXT (d));
15262 finish_decl (d, init, NULL_TREE);
15263 pop_nested_class ();
15265 else if (TREE_CODE (d) == FUNCTION_DECL)
15267 htab_t saved_local_specializations;
15272 /* Save away the current list, in case we are instantiating one
15273 template from within the body of another. */
15274 saved_local_specializations = local_specializations;
15276 /* Set up the list of local specializations. */
15277 local_specializations = htab_create (37,
15278 hash_local_specialization,
15279 eq_local_specializations,
15282 /* Set up context. */
15283 start_preparsed_function (d, NULL_TREE, SF_PRE_PARSED);
15285 /* Create substitution entries for the parameters. */
15286 subst_decl = DECL_TEMPLATE_RESULT (template_for_substitution (d));
15287 tmpl_parm = DECL_ARGUMENTS (subst_decl);
15288 spec_parm = DECL_ARGUMENTS (d);
15289 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d))
15291 register_local_specialization (spec_parm, tmpl_parm);
15292 spec_parm = skip_artificial_parms_for (d, spec_parm);
15293 tmpl_parm = skip_artificial_parms_for (subst_decl, tmpl_parm);
15295 while (tmpl_parm && !FUNCTION_PARAMETER_PACK_P (tmpl_parm))
15297 register_local_specialization (spec_parm, tmpl_parm);
15298 tmpl_parm = TREE_CHAIN (tmpl_parm);
15299 spec_parm = TREE_CHAIN (spec_parm);
15301 if (tmpl_parm && FUNCTION_PARAMETER_PACK_P (tmpl_parm))
15303 /* Collect all of the extra "packed" parameters into an
15307 tree argpack = make_node (NONTYPE_ARGUMENT_PACK);
15308 tree argtypepack = make_node (TYPE_ARGUMENT_PACK);
15312 /* Count how many parameters remain. */
15313 for (t = spec_parm; t; t = TREE_CHAIN (t))
15316 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
15317 parmvec = make_tree_vec (len);
15318 parmtypevec = make_tree_vec (len);
15319 for(i = 0; i < len; i++, spec_parm = TREE_CHAIN (spec_parm))
15321 TREE_VEC_ELT (parmvec, i) = spec_parm;
15322 TREE_VEC_ELT (parmtypevec, i) = TREE_TYPE (spec_parm);
15325 /* Build the argument packs. */
15326 SET_ARGUMENT_PACK_ARGS (argpack, parmvec);
15327 SET_ARGUMENT_PACK_ARGS (argtypepack, parmtypevec);
15328 TREE_TYPE (argpack) = argtypepack;
15330 /* Register the (value) argument pack as a specialization of
15331 TMPL_PARM, then move on. */
15332 register_local_specialization (argpack, tmpl_parm);
15333 tmpl_parm = TREE_CHAIN (tmpl_parm);
15335 gcc_assert (!spec_parm);
15337 /* Substitute into the body of the function. */
15338 tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
15339 tf_warning_or_error, tmpl,
15340 /*integral_constant_expression_p=*/false);
15342 /* Set the current input_location to the end of the function
15343 so that finish_function knows where we are. */
15344 input_location = DECL_STRUCT_FUNCTION (code_pattern)->function_end_locus;
15346 /* We don't need the local specializations any more. */
15347 htab_delete (local_specializations);
15348 local_specializations = saved_local_specializations;
15350 /* Finish the function. */
15351 d = finish_function (0);
15352 expand_or_defer_fn (d);
15355 /* We're not deferring instantiation any more. */
15356 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
15359 pop_from_top_level ();
15362 input_location = saved_loc;
15363 pop_deferring_access_checks ();
15364 pop_tinst_level ();
15366 timevar_pop (TV_PARSE);
15371 /* Run through the list of templates that we wish we could
15372 instantiate, and instantiate any we can. RETRIES is the
15373 number of times we retry pending template instantiation. */
15376 instantiate_pending_templates (int retries)
15379 location_t saved_loc = input_location;
15381 /* Instantiating templates may trigger vtable generation. This in turn
15382 may require further template instantiations. We place a limit here
15383 to avoid infinite loop. */
15384 if (pending_templates && retries >= max_tinst_depth)
15386 tree decl = pending_templates->tinst->decl;
15388 error ("template instantiation depth exceeds maximum of %d"
15389 " instantiating %q+D, possibly from virtual table generation"
15390 " (use -ftemplate-depth-NN to increase the maximum)",
15391 max_tinst_depth, decl);
15392 if (TREE_CODE (decl) == FUNCTION_DECL)
15393 /* Pretend that we defined it. */
15394 DECL_INITIAL (decl) = error_mark_node;
15400 struct pending_template **t = &pending_templates;
15401 struct pending_template *last = NULL;
15405 tree instantiation = reopen_tinst_level ((*t)->tinst);
15406 bool complete = false;
15408 if (TYPE_P (instantiation))
15412 if (!COMPLETE_TYPE_P (instantiation))
15414 instantiate_class_template (instantiation);
15415 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
15416 for (fn = TYPE_METHODS (instantiation);
15418 fn = TREE_CHAIN (fn))
15419 if (! DECL_ARTIFICIAL (fn))
15420 instantiate_decl (fn,
15422 /*expl_inst_class_mem_p=*/false);
15423 if (COMPLETE_TYPE_P (instantiation))
15427 complete = COMPLETE_TYPE_P (instantiation);
15431 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation)
15432 && !DECL_TEMPLATE_INSTANTIATED (instantiation))
15435 = instantiate_decl (instantiation,
15437 /*expl_inst_class_mem_p=*/false);
15438 if (DECL_TEMPLATE_INSTANTIATED (instantiation))
15442 complete = (DECL_TEMPLATE_SPECIALIZATION (instantiation)
15443 || DECL_TEMPLATE_INSTANTIATED (instantiation));
15447 /* If INSTANTIATION has been instantiated, then we don't
15448 need to consider it again in the future. */
15456 current_tinst_level = NULL;
15458 last_pending_template = last;
15460 while (reconsider);
15462 input_location = saved_loc;
15465 /* Substitute ARGVEC into T, which is a list of initializers for
15466 either base class or a non-static data member. The TREE_PURPOSEs
15467 are DECLs, and the TREE_VALUEs are the initializer values. Used by
15468 instantiate_decl. */
15471 tsubst_initializer_list (tree t, tree argvec)
15473 tree inits = NULL_TREE;
15475 for (; t; t = TREE_CHAIN (t))
15479 tree expanded_bases = NULL_TREE;
15480 tree expanded_arguments = NULL_TREE;
15483 if (TREE_CODE (TREE_PURPOSE (t)) == TYPE_PACK_EXPANSION)
15488 /* Expand the base class expansion type into separate base
15490 expanded_bases = tsubst_pack_expansion (TREE_PURPOSE (t), argvec,
15491 tf_warning_or_error,
15493 if (expanded_bases == error_mark_node)
15496 /* We'll be building separate TREE_LISTs of arguments for
15498 len = TREE_VEC_LENGTH (expanded_bases);
15499 expanded_arguments = make_tree_vec (len);
15500 for (i = 0; i < len; i++)
15501 TREE_VEC_ELT (expanded_arguments, i) = NULL_TREE;
15503 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
15504 expand each argument in the TREE_VALUE of t. */
15505 expr = make_node (EXPR_PACK_EXPANSION);
15506 PACK_EXPANSION_PARAMETER_PACKS (expr) =
15507 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t));
15509 if (TREE_VALUE (t) == void_type_node)
15510 /* VOID_TYPE_NODE is used to indicate
15511 value-initialization. */
15513 for (i = 0; i < len; i++)
15514 TREE_VEC_ELT (expanded_arguments, i) = void_type_node;
15518 /* Substitute parameter packs into each argument in the
15520 in_base_initializer = 1;
15521 for (arg = TREE_VALUE (t); arg; arg = TREE_CHAIN (arg))
15523 tree expanded_exprs;
15525 /* Expand the argument. */
15526 SET_PACK_EXPANSION_PATTERN (expr, TREE_VALUE (arg));
15528 = tsubst_pack_expansion (expr, argvec,
15529 tf_warning_or_error,
15531 if (expanded_exprs == error_mark_node)
15534 /* Prepend each of the expanded expressions to the
15535 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
15536 for (i = 0; i < len; i++)
15538 TREE_VEC_ELT (expanded_arguments, i) =
15539 tree_cons (NULL_TREE,
15540 TREE_VEC_ELT (expanded_exprs, i),
15541 TREE_VEC_ELT (expanded_arguments, i));
15544 in_base_initializer = 0;
15546 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
15547 since we built them backwards. */
15548 for (i = 0; i < len; i++)
15550 TREE_VEC_ELT (expanded_arguments, i) =
15551 nreverse (TREE_VEC_ELT (expanded_arguments, i));
15556 for (i = 0; i < len; ++i)
15558 if (expanded_bases)
15560 decl = TREE_VEC_ELT (expanded_bases, i);
15561 decl = expand_member_init (decl);
15562 init = TREE_VEC_ELT (expanded_arguments, i);
15566 decl = tsubst_copy (TREE_PURPOSE (t), argvec,
15567 tf_warning_or_error, NULL_TREE);
15569 decl = expand_member_init (decl);
15570 if (decl && !DECL_P (decl))
15571 in_base_initializer = 1;
15573 init = tsubst_expr (TREE_VALUE (t), argvec,
15574 tf_warning_or_error, NULL_TREE,
15575 /*integral_constant_expression_p=*/false);
15576 in_base_initializer = 0;
15581 init = build_tree_list (decl, init);
15582 TREE_CHAIN (init) = inits;
15590 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
15593 set_current_access_from_decl (tree decl)
15595 if (TREE_PRIVATE (decl))
15596 current_access_specifier = access_private_node;
15597 else if (TREE_PROTECTED (decl))
15598 current_access_specifier = access_protected_node;
15600 current_access_specifier = access_public_node;
15603 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
15604 is the instantiation (which should have been created with
15605 start_enum) and ARGS are the template arguments to use. */
15608 tsubst_enum (tree tag, tree newtag, tree args)
15612 for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
15617 decl = TREE_VALUE (e);
15618 /* Note that in a template enum, the TREE_VALUE is the
15619 CONST_DECL, not the corresponding INTEGER_CST. */
15620 value = tsubst_expr (DECL_INITIAL (decl),
15621 args, tf_warning_or_error, NULL_TREE,
15622 /*integral_constant_expression_p=*/true);
15624 /* Give this enumeration constant the correct access. */
15625 set_current_access_from_decl (decl);
15627 /* Actually build the enumerator itself. */
15628 build_enumerator (DECL_NAME (decl), value, newtag);
15631 finish_enum (newtag);
15632 DECL_SOURCE_LOCATION (TYPE_NAME (newtag))
15633 = DECL_SOURCE_LOCATION (TYPE_NAME (tag));
15636 /* DECL is a FUNCTION_DECL that is a template specialization. Return
15637 its type -- but without substituting the innermost set of template
15638 arguments. So, innermost set of template parameters will appear in
15642 get_mostly_instantiated_function_type (tree decl)
15650 tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
15651 targs = DECL_TI_ARGS (decl);
15652 tparms = DECL_TEMPLATE_PARMS (tmpl);
15653 parm_depth = TMPL_PARMS_DEPTH (tparms);
15655 /* There should be as many levels of arguments as there are levels
15657 gcc_assert (parm_depth == TMPL_ARGS_DEPTH (targs));
15659 fn_type = TREE_TYPE (tmpl);
15661 if (parm_depth == 1)
15662 /* No substitution is necessary. */
15666 int i, save_access_control;
15669 /* Replace the innermost level of the TARGS with NULL_TREEs to
15670 let tsubst know not to substitute for those parameters. */
15671 partial_args = make_tree_vec (TREE_VEC_LENGTH (targs));
15672 for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i)
15673 SET_TMPL_ARGS_LEVEL (partial_args, i,
15674 TMPL_ARGS_LEVEL (targs, i));
15675 SET_TMPL_ARGS_LEVEL (partial_args,
15676 TMPL_ARGS_DEPTH (targs),
15677 make_tree_vec (DECL_NTPARMS (tmpl)));
15679 /* Disable access control as this function is used only during
15681 save_access_control = flag_access_control;
15682 flag_access_control = 0;
15684 ++processing_template_decl;
15685 /* Now, do the (partial) substitution to figure out the
15686 appropriate function type. */
15687 fn_type = tsubst (fn_type, partial_args, tf_error, NULL_TREE);
15688 --processing_template_decl;
15690 /* Substitute into the template parameters to obtain the real
15691 innermost set of parameters. This step is important if the
15692 innermost set of template parameters contains value
15693 parameters whose types depend on outer template parameters. */
15694 TREE_VEC_LENGTH (partial_args)--;
15695 tparms = tsubst_template_parms (tparms, partial_args, tf_error);
15697 flag_access_control = save_access_control;
15703 /* Return truthvalue if we're processing a template different from
15704 the last one involved in diagnostics. */
15706 problematic_instantiation_changed (void)
15708 return last_template_error_tick != tinst_level_tick;
15711 /* Remember current template involved in diagnostics. */
15713 record_last_problematic_instantiation (void)
15715 last_template_error_tick = tinst_level_tick;
15718 struct tinst_level *
15719 current_instantiation (void)
15721 return current_tinst_level;
15724 /* [temp.param] Check that template non-type parm TYPE is of an allowable
15725 type. Return zero for ok, nonzero for disallowed. Issue error and
15726 warning messages under control of COMPLAIN. */
15729 invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain)
15731 if (INTEGRAL_TYPE_P (type))
15733 else if (POINTER_TYPE_P (type))
15735 else if (TYPE_PTR_TO_MEMBER_P (type))
15737 else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
15739 else if (TREE_CODE (type) == TYPENAME_TYPE)
15742 if (complain & tf_error)
15743 error ("%q#T is not a valid type for a template constant parameter", type);
15747 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
15748 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
15751 dependent_type_p_r (tree type)
15757 A type is dependent if it is:
15759 -- a template parameter. Template template parameters are types
15760 for us (since TYPE_P holds true for them) so we handle
15762 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
15763 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
15765 /* -- a qualified-id with a nested-name-specifier which contains a
15766 class-name that names a dependent type or whose unqualified-id
15767 names a dependent type. */
15768 if (TREE_CODE (type) == TYPENAME_TYPE)
15770 /* -- a cv-qualified type where the cv-unqualified type is
15772 type = TYPE_MAIN_VARIANT (type);
15773 /* -- a compound type constructed from any dependent type. */
15774 if (TYPE_PTR_TO_MEMBER_P (type))
15775 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type))
15776 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
15778 else if (TREE_CODE (type) == POINTER_TYPE
15779 || TREE_CODE (type) == REFERENCE_TYPE)
15780 return dependent_type_p (TREE_TYPE (type));
15781 else if (TREE_CODE (type) == FUNCTION_TYPE
15782 || TREE_CODE (type) == METHOD_TYPE)
15786 if (dependent_type_p (TREE_TYPE (type)))
15788 for (arg_type = TYPE_ARG_TYPES (type);
15790 arg_type = TREE_CHAIN (arg_type))
15791 if (dependent_type_p (TREE_VALUE (arg_type)))
15795 /* -- an array type constructed from any dependent type or whose
15796 size is specified by a constant expression that is
15797 value-dependent. */
15798 if (TREE_CODE (type) == ARRAY_TYPE)
15800 if (TYPE_DOMAIN (type)
15801 && dependent_type_p (TYPE_DOMAIN (type)))
15803 return dependent_type_p (TREE_TYPE (type));
15805 else if (TREE_CODE (type) == INTEGER_TYPE
15806 && !TREE_CONSTANT (TYPE_MAX_VALUE (type)))
15808 /* If this is the TYPE_DOMAIN of an array type, consider it
15810 return (value_dependent_expression_p (TYPE_MAX_VALUE (type))
15811 || type_dependent_expression_p (TYPE_MAX_VALUE (type)));
15814 /* -- a template-id in which either the template name is a template
15816 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
15818 /* ... or any of the template arguments is a dependent type or
15819 an expression that is type-dependent or value-dependent. */
15820 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
15821 && (any_dependent_template_arguments_p
15822 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
15825 /* All TYPEOF_TYPEs and DECLTYPE_TYPEs are dependent; if the
15826 argument of the `typeof' expression is not type-dependent, then
15827 it should already been have resolved. */
15828 if (TREE_CODE (type) == TYPEOF_TYPE
15829 || TREE_CODE (type) == DECLTYPE_TYPE)
15832 /* A template argument pack is dependent if any of its packed
15834 if (TREE_CODE (type) == TYPE_ARGUMENT_PACK)
15836 tree args = ARGUMENT_PACK_ARGS (type);
15837 int i, len = TREE_VEC_LENGTH (args);
15838 for (i = 0; i < len; ++i)
15839 if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
15843 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
15844 be template parameters. */
15845 if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
15848 /* The standard does not specifically mention types that are local
15849 to template functions or local classes, but they should be
15850 considered dependent too. For example:
15852 template <int I> void f() {
15857 The size of `E' cannot be known until the value of `I' has been
15858 determined. Therefore, `E' must be considered dependent. */
15859 scope = TYPE_CONTEXT (type);
15860 if (scope && TYPE_P (scope))
15861 return dependent_type_p (scope);
15862 else if (scope && TREE_CODE (scope) == FUNCTION_DECL)
15863 return type_dependent_expression_p (scope);
15865 /* Other types are non-dependent. */
15869 /* Returns TRUE if TYPE is dependent, in the sense of
15870 [temp.dep.type]. */
15873 dependent_type_p (tree type)
15875 /* If there are no template parameters in scope, then there can't be
15876 any dependent types. */
15877 if (!processing_template_decl)
15879 /* If we are not processing a template, then nobody should be
15880 providing us with a dependent type. */
15882 gcc_assert (TREE_CODE (type) != TEMPLATE_TYPE_PARM);
15886 /* If the type is NULL, we have not computed a type for the entity
15887 in question; in that case, the type is dependent. */
15891 /* Erroneous types can be considered non-dependent. */
15892 if (type == error_mark_node)
15895 /* If we have not already computed the appropriate value for TYPE,
15897 if (!TYPE_DEPENDENT_P_VALID (type))
15899 TYPE_DEPENDENT_P (type) = dependent_type_p_r (type);
15900 TYPE_DEPENDENT_P_VALID (type) = 1;
15903 return TYPE_DEPENDENT_P (type);
15906 /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
15909 dependent_scope_ref_p (tree expression, bool criterion (tree))
15914 gcc_assert (TREE_CODE (expression) == SCOPE_REF);
15916 if (!TYPE_P (TREE_OPERAND (expression, 0)))
15919 scope = TREE_OPERAND (expression, 0);
15920 name = TREE_OPERAND (expression, 1);
15924 An id-expression is type-dependent if it contains a
15925 nested-name-specifier that contains a class-name that names a
15927 /* The suggested resolution to Core Issue 2 implies that if the
15928 qualifying type is the current class, then we must peek
15931 && currently_open_class (scope)
15932 && !criterion (name))
15934 if (dependent_type_p (scope))
15940 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
15941 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
15945 value_dependent_expression_p (tree expression)
15947 if (!processing_template_decl)
15950 /* A name declared with a dependent type. */
15951 if (DECL_P (expression) && type_dependent_expression_p (expression))
15954 switch (TREE_CODE (expression))
15956 case IDENTIFIER_NODE:
15957 /* A name that has not been looked up -- must be dependent. */
15960 case TEMPLATE_PARM_INDEX:
15961 /* A non-type template parm. */
15965 /* A non-type template parm. */
15966 if (DECL_TEMPLATE_PARM_P (expression))
15968 return value_dependent_expression_p (DECL_INITIAL (expression));
15971 /* A constant with integral or enumeration type and is initialized
15972 with an expression that is value-dependent. */
15973 if (DECL_INITIAL (expression)
15974 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression))
15975 && value_dependent_expression_p (DECL_INITIAL (expression)))
15979 case DYNAMIC_CAST_EXPR:
15980 case STATIC_CAST_EXPR:
15981 case CONST_CAST_EXPR:
15982 case REINTERPRET_CAST_EXPR:
15984 /* These expressions are value-dependent if the type to which
15985 the cast occurs is dependent or the expression being casted
15986 is value-dependent. */
15988 tree type = TREE_TYPE (expression);
15990 if (dependent_type_p (type))
15993 /* A functional cast has a list of operands. */
15994 expression = TREE_OPERAND (expression, 0);
15997 /* If there are no operands, it must be an expression such
15998 as "int()". This should not happen for aggregate types
15999 because it would form non-constant expressions. */
16000 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
16005 if (TREE_CODE (expression) == TREE_LIST)
16006 return any_value_dependent_elements_p (expression);
16008 return value_dependent_expression_p (expression);
16013 /* A `sizeof' expression is value-dependent if the operand is
16014 type-dependent or is a pack expansion. */
16015 expression = TREE_OPERAND (expression, 0);
16016 if (PACK_EXPANSION_P (expression))
16018 else if (TYPE_P (expression))
16019 return dependent_type_p (expression);
16020 return type_dependent_expression_p (expression);
16023 return dependent_scope_ref_p (expression, value_dependent_expression_p);
16025 case COMPONENT_REF:
16026 return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
16027 || value_dependent_expression_p (TREE_OPERAND (expression, 1)));
16030 /* A CALL_EXPR may appear in a constant expression if it is a
16031 call to a builtin function, e.g., __builtin_constant_p. All
16032 such calls are value-dependent. */
16035 case NONTYPE_ARGUMENT_PACK:
16036 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
16037 is value-dependent. */
16039 tree values = ARGUMENT_PACK_ARGS (expression);
16040 int i, len = TREE_VEC_LENGTH (values);
16042 for (i = 0; i < len; ++i)
16043 if (value_dependent_expression_p (TREE_VEC_ELT (values, i)))
16051 tree type2 = TRAIT_EXPR_TYPE2 (expression);
16052 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression))
16053 || (type2 ? dependent_type_p (type2) : false));
16057 return ((value_dependent_expression_p (TREE_OPERAND (expression, 0)))
16058 || (value_dependent_expression_p (TREE_OPERAND (expression, 2))));
16061 /* A constant expression is value-dependent if any subexpression is
16062 value-dependent. */
16063 switch (TREE_CODE_CLASS (TREE_CODE (expression)))
16065 case tcc_reference:
16067 return (value_dependent_expression_p
16068 (TREE_OPERAND (expression, 0)));
16070 case tcc_comparison:
16072 return ((value_dependent_expression_p
16073 (TREE_OPERAND (expression, 0)))
16074 || (value_dependent_expression_p
16075 (TREE_OPERAND (expression, 1))));
16077 case tcc_expression:
16081 for (i = 0; i < TREE_OPERAND_LENGTH (expression); ++i)
16082 /* In some cases, some of the operands may be missing.
16083 (For example, in the case of PREDECREMENT_EXPR, the
16084 amount to increment by may be missing.) That doesn't
16085 make the expression dependent. */
16086 if (TREE_OPERAND (expression, i)
16087 && (value_dependent_expression_p
16088 (TREE_OPERAND (expression, i))))
16098 /* The expression is not value-dependent. */
16102 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
16103 [temp.dep.expr]. */
16106 type_dependent_expression_p (tree expression)
16108 if (!processing_template_decl)
16111 if (expression == error_mark_node)
16114 /* An unresolved name is always dependent. */
16115 if (TREE_CODE (expression) == IDENTIFIER_NODE
16116 || TREE_CODE (expression) == USING_DECL)
16119 /* Some expression forms are never type-dependent. */
16120 if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR
16121 || TREE_CODE (expression) == SIZEOF_EXPR
16122 || TREE_CODE (expression) == ALIGNOF_EXPR
16123 || TREE_CODE (expression) == TRAIT_EXPR
16124 || TREE_CODE (expression) == TYPEID_EXPR
16125 || TREE_CODE (expression) == DELETE_EXPR
16126 || TREE_CODE (expression) == VEC_DELETE_EXPR
16127 || TREE_CODE (expression) == THROW_EXPR)
16130 /* The types of these expressions depends only on the type to which
16131 the cast occurs. */
16132 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
16133 || TREE_CODE (expression) == STATIC_CAST_EXPR
16134 || TREE_CODE (expression) == CONST_CAST_EXPR
16135 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
16136 || TREE_CODE (expression) == CAST_EXPR)
16137 return dependent_type_p (TREE_TYPE (expression));
16139 /* The types of these expressions depends only on the type created
16140 by the expression. */
16141 if (TREE_CODE (expression) == NEW_EXPR
16142 || TREE_CODE (expression) == VEC_NEW_EXPR)
16144 /* For NEW_EXPR tree nodes created inside a template, either
16145 the object type itself or a TREE_LIST may appear as the
16147 tree type = TREE_OPERAND (expression, 1);
16148 if (TREE_CODE (type) == TREE_LIST)
16149 /* This is an array type. We need to check array dimensions
16151 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type)))
16152 || value_dependent_expression_p
16153 (TREE_OPERAND (TREE_VALUE (type), 1));
16155 return dependent_type_p (type);
16158 if (TREE_CODE (expression) == SCOPE_REF
16159 && dependent_scope_ref_p (expression,
16160 type_dependent_expression_p))
16163 if (TREE_CODE (expression) == FUNCTION_DECL
16164 && DECL_LANG_SPECIFIC (expression)
16165 && DECL_TEMPLATE_INFO (expression)
16166 && (any_dependent_template_arguments_p
16167 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
16170 if (TREE_CODE (expression) == TEMPLATE_DECL
16171 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression))
16174 if (TREE_CODE (expression) == STMT_EXPR)
16175 expression = stmt_expr_value_expr (expression);
16177 if (TREE_TYPE (expression) == unknown_type_node)
16179 if (TREE_CODE (expression) == ADDR_EXPR)
16180 return type_dependent_expression_p (TREE_OPERAND (expression, 0));
16181 if (TREE_CODE (expression) == COMPONENT_REF
16182 || TREE_CODE (expression) == OFFSET_REF)
16184 if (type_dependent_expression_p (TREE_OPERAND (expression, 0)))
16186 expression = TREE_OPERAND (expression, 1);
16187 if (TREE_CODE (expression) == IDENTIFIER_NODE)
16190 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
16191 if (TREE_CODE (expression) == SCOPE_REF)
16194 if (TREE_CODE (expression) == BASELINK)
16195 expression = BASELINK_FUNCTIONS (expression);
16197 if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
16199 if (any_dependent_template_arguments_p
16200 (TREE_OPERAND (expression, 1)))
16202 expression = TREE_OPERAND (expression, 0);
16204 gcc_assert (TREE_CODE (expression) == OVERLOAD
16205 || TREE_CODE (expression) == FUNCTION_DECL);
16209 if (type_dependent_expression_p (OVL_CURRENT (expression)))
16211 expression = OVL_NEXT (expression);
16216 gcc_assert (TREE_CODE (expression) != TYPE_DECL);
16218 return (dependent_type_p (TREE_TYPE (expression)));
16221 /* Returns TRUE if ARGS (a TREE_LIST of arguments to a function call)
16222 contains a type-dependent expression. */
16225 any_type_dependent_arguments_p (const_tree args)
16229 tree arg = TREE_VALUE (args);
16231 if (type_dependent_expression_p (arg))
16233 args = TREE_CHAIN (args);
16238 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
16239 expressions) contains any value-dependent expressions. */
16242 any_value_dependent_elements_p (const_tree list)
16244 for (; list; list = TREE_CHAIN (list))
16245 if (value_dependent_expression_p (TREE_VALUE (list)))
16251 /* Returns TRUE if the ARG (a template argument) is dependent. */
16254 dependent_template_arg_p (tree arg)
16256 if (!processing_template_decl)
16259 if (TREE_CODE (arg) == TEMPLATE_DECL
16260 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
16261 return dependent_template_p (arg);
16262 else if (ARGUMENT_PACK_P (arg))
16264 tree args = ARGUMENT_PACK_ARGS (arg);
16265 int i, len = TREE_VEC_LENGTH (args);
16266 for (i = 0; i < len; ++i)
16268 if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
16274 else if (TYPE_P (arg))
16275 return dependent_type_p (arg);
16277 return (type_dependent_expression_p (arg)
16278 || value_dependent_expression_p (arg));
16281 /* Returns true if ARGS (a collection of template arguments) contains
16282 any types that require structural equality testing. */
16285 any_template_arguments_need_structural_equality_p (tree args)
16292 if (args == error_mark_node)
16295 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
16297 tree level = TMPL_ARGS_LEVEL (args, i + 1);
16298 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
16300 tree arg = TREE_VEC_ELT (level, j);
16301 tree packed_args = NULL_TREE;
16304 if (ARGUMENT_PACK_P (arg))
16306 /* Look inside the argument pack. */
16307 packed_args = ARGUMENT_PACK_ARGS (arg);
16308 len = TREE_VEC_LENGTH (packed_args);
16311 for (k = 0; k < len; ++k)
16314 arg = TREE_VEC_ELT (packed_args, k);
16316 if (error_operand_p (arg))
16318 else if (TREE_CODE (arg) == TEMPLATE_DECL
16319 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
16321 else if (TYPE_P (arg) && TYPE_STRUCTURAL_EQUALITY_P (arg))
16323 else if (!TYPE_P (arg) && TREE_TYPE (arg)
16324 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg)))
16333 /* Returns true if ARGS (a collection of template arguments) contains
16334 any dependent arguments. */
16337 any_dependent_template_arguments_p (const_tree args)
16344 if (args == error_mark_node)
16347 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
16349 const_tree level = TMPL_ARGS_LEVEL (args, i + 1);
16350 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
16351 if (dependent_template_arg_p (TREE_VEC_ELT (level, j)))
16358 /* Returns TRUE if the template TMPL is dependent. */
16361 dependent_template_p (tree tmpl)
16363 if (TREE_CODE (tmpl) == OVERLOAD)
16367 if (dependent_template_p (OVL_FUNCTION (tmpl)))
16369 tmpl = OVL_CHAIN (tmpl);
16374 /* Template template parameters are dependent. */
16375 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
16376 || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
16378 /* So are names that have not been looked up. */
16379 if (TREE_CODE (tmpl) == SCOPE_REF
16380 || TREE_CODE (tmpl) == IDENTIFIER_NODE)
16382 /* So are member templates of dependent classes. */
16383 if (TYPE_P (CP_DECL_CONTEXT (tmpl)))
16384 return dependent_type_p (DECL_CONTEXT (tmpl));
16388 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
16391 dependent_template_id_p (tree tmpl, tree args)
16393 return (dependent_template_p (tmpl)
16394 || any_dependent_template_arguments_p (args));
16397 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
16401 dependent_omp_for_p (tree declv, tree initv, tree condv, tree incrv)
16405 if (!processing_template_decl)
16408 for (i = 0; i < TREE_VEC_LENGTH (declv); i++)
16410 tree decl = TREE_VEC_ELT (declv, i);
16411 tree init = TREE_VEC_ELT (initv, i);
16412 tree cond = TREE_VEC_ELT (condv, i);
16413 tree incr = TREE_VEC_ELT (incrv, i);
16415 if (type_dependent_expression_p (decl))
16418 if (init && type_dependent_expression_p (init))
16421 if (type_dependent_expression_p (cond))
16424 if (COMPARISON_CLASS_P (cond)
16425 && (type_dependent_expression_p (TREE_OPERAND (cond, 0))
16426 || type_dependent_expression_p (TREE_OPERAND (cond, 1))))
16429 if (TREE_CODE (incr) == MODOP_EXPR)
16431 if (type_dependent_expression_p (TREE_OPERAND (incr, 0))
16432 || type_dependent_expression_p (TREE_OPERAND (incr, 2)))
16435 else if (type_dependent_expression_p (incr))
16437 else if (TREE_CODE (incr) == MODIFY_EXPR)
16439 if (type_dependent_expression_p (TREE_OPERAND (incr, 0)))
16441 else if (BINARY_CLASS_P (TREE_OPERAND (incr, 1)))
16443 tree t = TREE_OPERAND (incr, 1);
16444 if (type_dependent_expression_p (TREE_OPERAND (t, 0))
16445 || type_dependent_expression_p (TREE_OPERAND (t, 1)))
16454 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
16455 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
16456 no such TYPE can be found. Note that this function peers inside
16457 uninstantiated templates and therefore should be used only in
16458 extremely limited situations. ONLY_CURRENT_P restricts this
16459 peering to the currently open classes hierarchy (which is required
16460 when comparing types). */
16463 resolve_typename_type (tree type, bool only_current_p)
16472 gcc_assert (TREE_CODE (type) == TYPENAME_TYPE);
16474 scope = TYPE_CONTEXT (type);
16475 name = TYPE_IDENTIFIER (type);
16477 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
16478 it first before we can figure out what NAME refers to. */
16479 if (TREE_CODE (scope) == TYPENAME_TYPE)
16480 scope = resolve_typename_type (scope, only_current_p);
16481 /* If we don't know what SCOPE refers to, then we cannot resolve the
16483 if (TREE_CODE (scope) == TYPENAME_TYPE)
16485 /* If the SCOPE is a template type parameter, we have no way of
16486 resolving the name. */
16487 if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
16489 /* If the SCOPE is not the current instantiation, there's no reason
16490 to look inside it. */
16491 if (only_current_p && !currently_open_class (scope))
16493 /* If SCOPE isn't the template itself, it will not have a valid
16494 TYPE_FIELDS list. */
16495 if (same_type_p (scope, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope)))
16496 /* scope is either the template itself or a compatible instantiation
16497 like X<T>, so look up the name in the original template. */
16498 scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope);
16500 /* scope is a partial instantiation, so we can't do the lookup or we
16501 will lose the template arguments. */
16503 /* Enter the SCOPE so that name lookup will be resolved as if we
16504 were in the class definition. In particular, SCOPE will no
16505 longer be considered a dependent type. */
16506 pushed_scope = push_scope (scope);
16507 /* Look up the declaration. */
16508 decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true);
16510 result = NULL_TREE;
16512 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
16513 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
16516 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE
16517 && TREE_CODE (decl) == TYPE_DECL)
16519 result = TREE_TYPE (decl);
16520 if (result == error_mark_node)
16521 result = NULL_TREE;
16523 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR
16524 && DECL_CLASS_TEMPLATE_P (decl))
16528 /* Obtain the template and the arguments. */
16529 tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0);
16530 args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1);
16531 /* Instantiate the template. */
16532 result = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE,
16533 /*entering_scope=*/0,
16534 tf_error | tf_user);
16535 if (result == error_mark_node)
16536 result = NULL_TREE;
16539 /* Leave the SCOPE. */
16541 pop_scope (pushed_scope);
16543 /* If we failed to resolve it, return the original typename. */
16547 /* If lookup found a typename type, resolve that too. */
16548 if (TREE_CODE (result) == TYPENAME_TYPE && !TYPENAME_IS_RESOLVING_P (result))
16550 /* Ill-formed programs can cause infinite recursion here, so we
16551 must catch that. */
16552 TYPENAME_IS_RESOLVING_P (type) = 1;
16553 result = resolve_typename_type (result, only_current_p);
16554 TYPENAME_IS_RESOLVING_P (type) = 0;
16557 /* Qualify the resulting type. */
16558 quals = cp_type_quals (type);
16560 result = cp_build_qualified_type (result, cp_type_quals (result) | quals);
16565 /* EXPR is an expression which is not type-dependent. Return a proxy
16566 for EXPR that can be used to compute the types of larger
16567 expressions containing EXPR. */
16570 build_non_dependent_expr (tree expr)
16574 /* Preserve null pointer constants so that the type of things like
16575 "p == 0" where "p" is a pointer can be determined. */
16576 if (null_ptr_cst_p (expr))
16578 /* Preserve OVERLOADs; the functions must be available to resolve
16581 if (TREE_CODE (inner_expr) == STMT_EXPR)
16582 inner_expr = stmt_expr_value_expr (inner_expr);
16583 if (TREE_CODE (inner_expr) == ADDR_EXPR)
16584 inner_expr = TREE_OPERAND (inner_expr, 0);
16585 if (TREE_CODE (inner_expr) == COMPONENT_REF)
16586 inner_expr = TREE_OPERAND (inner_expr, 1);
16587 if (is_overloaded_fn (inner_expr)
16588 || TREE_CODE (inner_expr) == OFFSET_REF)
16590 /* There is no need to return a proxy for a variable. */
16591 if (TREE_CODE (expr) == VAR_DECL)
16593 /* Preserve string constants; conversions from string constants to
16594 "char *" are allowed, even though normally a "const char *"
16595 cannot be used to initialize a "char *". */
16596 if (TREE_CODE (expr) == STRING_CST)
16598 /* Preserve arithmetic constants, as an optimization -- there is no
16599 reason to create a new node. */
16600 if (TREE_CODE (expr) == INTEGER_CST || TREE_CODE (expr) == REAL_CST)
16602 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
16603 There is at least one place where we want to know that a
16604 particular expression is a throw-expression: when checking a ?:
16605 expression, there are special rules if the second or third
16606 argument is a throw-expression. */
16607 if (TREE_CODE (expr) == THROW_EXPR)
16610 if (TREE_CODE (expr) == COND_EXPR)
16611 return build3 (COND_EXPR,
16613 TREE_OPERAND (expr, 0),
16614 (TREE_OPERAND (expr, 1)
16615 ? build_non_dependent_expr (TREE_OPERAND (expr, 1))
16616 : build_non_dependent_expr (TREE_OPERAND (expr, 0))),
16617 build_non_dependent_expr (TREE_OPERAND (expr, 2)));
16618 if (TREE_CODE (expr) == COMPOUND_EXPR
16619 && !COMPOUND_EXPR_OVERLOADED (expr))
16620 return build2 (COMPOUND_EXPR,
16622 TREE_OPERAND (expr, 0),
16623 build_non_dependent_expr (TREE_OPERAND (expr, 1)));
16625 /* If the type is unknown, it can't really be non-dependent */
16626 gcc_assert (TREE_TYPE (expr) != unknown_type_node);
16628 /* Otherwise, build a NON_DEPENDENT_EXPR.
16630 REFERENCE_TYPEs are not stripped for expressions in templates
16631 because doing so would play havoc with mangling. Consider, for
16634 template <typename T> void f<T& g>() { g(); }
16636 In the body of "f", the expression for "g" will have
16637 REFERENCE_TYPE, even though the standard says that it should
16638 not. The reason is that we must preserve the syntactic form of
16639 the expression so that mangling (say) "f<g>" inside the body of
16640 "f" works out correctly. Therefore, the REFERENCE_TYPE is
16642 return build1 (NON_DEPENDENT_EXPR, non_reference (TREE_TYPE (expr)), expr);
16645 /* ARGS is a TREE_LIST of expressions as arguments to a function call.
16646 Return a new TREE_LIST with the various arguments replaced with
16647 equivalent non-dependent expressions. */
16650 build_non_dependent_args (tree args)
16655 new_args = NULL_TREE;
16656 for (a = args; a; a = TREE_CHAIN (a))
16657 new_args = tree_cons (NULL_TREE,
16658 build_non_dependent_expr (TREE_VALUE (a)),
16660 return nreverse (new_args);
16663 #include "gt-cp-pt.h"