1 /* Handle parameterized types (templates) for GNU C++.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
4 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
5 Rewritten by Jason Merrill (jason@cygnus.com).
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 /* Known bugs or deficiencies include:
25 all methods must be provided in header files; can't use a source
26 file that contains only the method templates and "just win". */
30 #include "coretypes.h"
34 #include "pointer-set.h"
38 #include "cp-objcp-common.h"
39 #include "tree-inline.h"
46 #include "tree-iterator.h"
49 /* The type of functions taking a tree, and some additional data, and
51 typedef int (*tree_fn_t) (tree, void*);
53 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
54 instantiations have been deferred, either because their definitions
55 were not yet available, or because we were putting off doing the work. */
56 struct pending_template GTY (()) {
57 struct pending_template *next;
58 struct tinst_level *tinst;
61 static GTY(()) struct pending_template *pending_templates;
62 static GTY(()) struct pending_template *last_pending_template;
64 int processing_template_parmlist;
65 static int template_header_count;
67 static GTY(()) tree saved_trees;
68 static VEC(int,heap) *inline_parm_levels;
70 static GTY(()) struct tinst_level *current_tinst_level;
72 static GTY(()) tree saved_access_scope;
74 /* Live only within one (recursive) call to tsubst_expr. We use
75 this to pass the statement expression node from the STMT_EXPR
76 to the EXPR_STMT that is its result. */
77 static tree cur_stmt_expr;
79 /* A map from local variable declarations in the body of the template
80 presently being instantiated to the corresponding instantiated
82 static htab_t local_specializations;
84 /* Contains canonical template parameter types. The vector is indexed by
85 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
86 TREE_LIST, whose TREE_VALUEs contain the canonical template
87 parameters of various types and levels. */
88 static GTY(()) VEC(tree,gc) *canonical_template_parms;
90 #define UNIFY_ALLOW_NONE 0
91 #define UNIFY_ALLOW_MORE_CV_QUAL 1
92 #define UNIFY_ALLOW_LESS_CV_QUAL 2
93 #define UNIFY_ALLOW_DERIVED 4
94 #define UNIFY_ALLOW_INTEGER 8
95 #define UNIFY_ALLOW_OUTER_LEVEL 16
96 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
97 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
99 static void push_access_scope (tree);
100 static void pop_access_scope (tree);
101 static bool resolve_overloaded_unification (tree, tree, tree, tree,
102 unification_kind_t, int);
103 static int try_one_overload (tree, tree, tree, tree, tree,
104 unification_kind_t, int, bool);
105 static int unify (tree, tree, tree, tree, int);
106 static void add_pending_template (tree);
107 static int push_tinst_level (tree);
108 static void pop_tinst_level (void);
109 static tree reopen_tinst_level (struct tinst_level *);
110 static tree tsubst_initializer_list (tree, tree);
111 static tree get_class_bindings (tree, tree, tree);
112 static tree coerce_template_parms (tree, tree, tree, tsubst_flags_t,
114 static void tsubst_enum (tree, tree, tree);
115 static tree add_to_template_args (tree, tree);
116 static tree add_outermost_template_args (tree, tree);
117 static bool check_instantiated_args (tree, tree, tsubst_flags_t);
118 static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*,
120 static int type_unification_real (tree, tree, tree, tree,
121 int, unification_kind_t, int);
122 static void note_template_header (int);
123 static tree convert_nontype_argument_function (tree, tree);
124 static tree convert_nontype_argument (tree, tree);
125 static tree convert_template_argument (tree, tree, tree,
126 tsubst_flags_t, int, tree);
127 static int for_each_template_parm (tree, tree_fn_t, void*,
128 struct pointer_set_t*, 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 (IS_AGGR_TYPE (type)
240 && CLASSTYPE_TEMPLATE_INFO (type)
241 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
243 tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
244 check_member_template (tmpl);
249 else if (TREE_CODE (decl) == FIELD_DECL)
250 error ("data member %qD cannot be a member template", decl);
251 else if (DECL_TEMPLATE_INFO (decl))
253 if (!DECL_TEMPLATE_SPECIALIZATION (decl))
255 check_member_template (DECL_TI_TEMPLATE (decl));
256 return DECL_TI_TEMPLATE (decl);
262 error ("invalid member template declaration %qD", decl);
264 return error_mark_node;
267 /* Return the template info node corresponding to T, whatever T is. */
270 get_template_info (tree t)
272 tree tinfo = NULL_TREE;
274 if (DECL_P (t) && DECL_LANG_SPECIFIC (t))
275 tinfo = DECL_TEMPLATE_INFO (t);
277 if (!tinfo && TREE_CODE (t) == TYPE_DECL)
280 if (TAGGED_TYPE_P (t))
281 tinfo = TYPE_TEMPLATE_INFO (t);
286 /* Returns the template nesting level of the indicated class TYPE.
296 A<T>::B<U> has depth two, while A<T> has depth one.
297 Both A<T>::B<int> and A<int>::B<U> have depth one, if
298 they are instantiations, not specializations.
300 This function is guaranteed to return 0 if passed NULL_TREE so
301 that, for example, `template_class_depth (current_class_type)' is
305 template_class_depth (tree type)
310 type && TREE_CODE (type) != NAMESPACE_DECL;
311 type = (TREE_CODE (type) == FUNCTION_DECL)
312 ? CP_DECL_CONTEXT (type) : TYPE_CONTEXT (type))
314 tree tinfo = get_template_info (type);
316 if (tinfo && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo))
317 && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo))))
324 /* Subroutine of maybe_begin_member_template_processing.
325 Returns true if processing DECL needs us to push template parms. */
328 inline_needs_template_parms (tree decl)
330 if (! DECL_TEMPLATE_INFO (decl))
333 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl)))
334 > (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl)));
337 /* Subroutine of maybe_begin_member_template_processing.
338 Push the template parms in PARMS, starting from LEVELS steps into the
339 chain, and ending at the beginning, since template parms are listed
343 push_inline_template_parms_recursive (tree parmlist, int levels)
345 tree parms = TREE_VALUE (parmlist);
349 push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1);
351 ++processing_template_decl;
352 current_template_parms
353 = tree_cons (size_int (processing_template_decl),
354 parms, current_template_parms);
355 TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1;
357 begin_scope (TREE_VEC_LENGTH (parms) ? sk_template_parms : sk_template_spec,
359 for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
361 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
363 if (parm == error_mark_node)
366 gcc_assert (DECL_P (parm));
368 switch (TREE_CODE (parm))
377 /* Make a CONST_DECL as is done in process_template_parm.
378 It is ugly that we recreate this here; the original
379 version built in process_template_parm is no longer
381 tree decl = build_decl (CONST_DECL, DECL_NAME (parm),
383 DECL_ARTIFICIAL (decl) = 1;
384 TREE_CONSTANT (decl) = 1;
385 TREE_INVARIANT (decl) = 1;
386 TREE_READONLY (decl) = 1;
387 DECL_INITIAL (decl) = DECL_INITIAL (parm);
388 SET_DECL_TEMPLATE_PARM_P (decl);
399 /* Restore the template parameter context for a member template or
400 a friend template defined in a class definition. */
403 maybe_begin_member_template_processing (tree decl)
408 if (inline_needs_template_parms (decl))
410 parms = DECL_TEMPLATE_PARMS (most_general_template (decl));
411 levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl;
413 if (DECL_TEMPLATE_SPECIALIZATION (decl))
416 parms = TREE_CHAIN (parms);
419 push_inline_template_parms_recursive (parms, levels);
422 /* Remember how many levels of template parameters we pushed so that
423 we can pop them later. */
424 VEC_safe_push (int, heap, inline_parm_levels, levels);
427 /* Undo the effects of maybe_begin_member_template_processing. */
430 maybe_end_member_template_processing (void)
435 if (VEC_length (int, inline_parm_levels) == 0)
438 last = VEC_pop (int, inline_parm_levels);
439 for (i = 0; i < last; ++i)
441 --processing_template_decl;
442 current_template_parms = TREE_CHAIN (current_template_parms);
447 /* Return a new template argument vector which contains all of ARGS,
448 but has as its innermost set of arguments the EXTRA_ARGS. */
451 add_to_template_args (tree args, tree extra_args)
458 extra_depth = TMPL_ARGS_DEPTH (extra_args);
459 new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth);
461 for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i)
462 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));
464 for (j = 1; j <= extra_depth; ++j, ++i)
465 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));
470 /* Like add_to_template_args, but only the outermost ARGS are added to
471 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
472 (EXTRA_ARGS) levels are added. This function is used to combine
473 the template arguments from a partial instantiation with the
474 template arguments used to attain the full instantiation from the
475 partial instantiation. */
478 add_outermost_template_args (tree args, tree extra_args)
482 /* If there are more levels of EXTRA_ARGS than there are ARGS,
483 something very fishy is going on. */
484 gcc_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args));
486 /* If *all* the new arguments will be the EXTRA_ARGS, just return
488 if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
491 /* For the moment, we make ARGS look like it contains fewer levels. */
492 TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);
494 new_args = add_to_template_args (args, extra_args);
496 /* Now, we restore ARGS to its full dimensions. */
497 TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);
502 /* Return the N levels of innermost template arguments from the ARGS. */
505 get_innermost_template_args (tree args, int n)
513 /* If N is 1, just return the innermost set of template arguments. */
515 return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args));
517 /* If we're not removing anything, just return the arguments we were
519 extra_levels = TMPL_ARGS_DEPTH (args) - n;
520 gcc_assert (extra_levels >= 0);
521 if (extra_levels == 0)
524 /* Make a new set of arguments, not containing the outer arguments. */
525 new_args = make_tree_vec (n);
526 for (i = 1; i <= n; ++i)
527 SET_TMPL_ARGS_LEVEL (new_args, i,
528 TMPL_ARGS_LEVEL (args, i + extra_levels));
533 /* The inverse of get_innermost_template_args: Return all but the innermost
534 EXTRA_LEVELS levels of template arguments from the ARGS. */
537 strip_innermost_template_args (tree args, int extra_levels)
540 int n = TMPL_ARGS_DEPTH (args) - extra_levels;
545 /* If N is 1, just return the outermost set of template arguments. */
547 return TMPL_ARGS_LEVEL (args, 1);
549 /* If we're not removing anything, just return the arguments we were
551 gcc_assert (extra_levels >= 0);
552 if (extra_levels == 0)
555 /* Make a new set of arguments, not containing the inner arguments. */
556 new_args = make_tree_vec (n);
557 for (i = 1; i <= n; ++i)
558 SET_TMPL_ARGS_LEVEL (new_args, i,
559 TMPL_ARGS_LEVEL (args, i));
564 /* We've got a template header coming up; push to a new level for storing
568 begin_template_parm_list (void)
570 /* We use a non-tag-transparent scope here, which causes pushtag to
571 put tags in this scope, rather than in the enclosing class or
572 namespace scope. This is the right thing, since we want
573 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
574 global template class, push_template_decl handles putting the
575 TEMPLATE_DECL into top-level scope. For a nested template class,
578 template <class T> struct S1 {
579 template <class T> struct S2 {};
582 pushtag contains special code to call pushdecl_with_scope on the
583 TEMPLATE_DECL for S2. */
584 begin_scope (sk_template_parms, NULL);
585 ++processing_template_decl;
586 ++processing_template_parmlist;
587 note_template_header (0);
590 /* This routine is called when a specialization is declared. If it is
591 invalid to declare a specialization here, an error is reported and
592 false is returned, otherwise this routine will return true. */
595 check_specialization_scope (void)
597 tree scope = current_scope ();
601 An explicit specialization shall be declared in the namespace of
602 which the template is a member, or, for member templates, in the
603 namespace of which the enclosing class or enclosing class
604 template is a member. An explicit specialization of a member
605 function, member class or static data member of a class template
606 shall be declared in the namespace of which the class template
608 if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
610 error ("explicit specialization in non-namespace scope %qD", scope);
616 In an explicit specialization declaration for a member of a class
617 template or a member template that appears in namespace scope,
618 the member template and some of its enclosing class templates may
619 remain unspecialized, except that the declaration shall not
620 explicitly specialize a class member template if its enclosing
621 class templates are not explicitly specialized as well. */
622 if (current_template_parms)
624 error ("enclosing class templates are not explicitly specialized");
631 /* We've just seen template <>. */
634 begin_specialization (void)
636 begin_scope (sk_template_spec, NULL);
637 note_template_header (1);
638 return check_specialization_scope ();
641 /* Called at then end of processing a declaration preceded by
645 end_specialization (void)
648 reset_specialization ();
651 /* Any template <>'s that we have seen thus far are not referring to a
652 function specialization. */
655 reset_specialization (void)
657 processing_specialization = 0;
658 template_header_count = 0;
661 /* We've just seen a template header. If SPECIALIZATION is nonzero,
662 it was of the form template <>. */
665 note_template_header (int specialization)
667 processing_specialization = specialization;
668 template_header_count++;
671 /* We're beginning an explicit instantiation. */
674 begin_explicit_instantiation (void)
676 gcc_assert (!processing_explicit_instantiation);
677 processing_explicit_instantiation = true;
682 end_explicit_instantiation (void)
684 gcc_assert (processing_explicit_instantiation);
685 processing_explicit_instantiation = false;
688 /* An explicit specialization or partial specialization TMPL is being
689 declared. Check that the namespace in which the specialization is
690 occurring is permissible. Returns false iff it is invalid to
691 specialize TMPL in the current namespace. */
694 check_specialization_namespace (tree tmpl)
696 tree tpl_ns = decl_namespace_context (tmpl);
700 An explicit specialization shall be declared in the namespace of
701 which the template is a member, or, for member templates, in the
702 namespace of which the enclosing class or enclosing class
703 template is a member. An explicit specialization of a member
704 function, member class or static data member of a class template
705 shall be declared in the namespace of which the class template is
707 if (is_associated_namespace (current_namespace, tpl_ns))
708 /* Same or super-using namespace. */
712 pedwarn ("specialization of %qD in different namespace", tmpl);
713 pedwarn (" from definition of %q+#D", tmpl);
718 /* SPEC is an explicit instantiation. Check that it is valid to
719 perform this explicit instantiation in the current namespace. */
722 check_explicit_instantiation_namespace (tree spec)
726 /* DR 275: An explicit instantiation shall appear in an enclosing
727 namespace of its template. */
728 ns = decl_namespace_context (spec);
729 if (!is_ancestor (current_namespace, ns))
730 pedwarn ("explicit instantiation of %qD in namespace %qD "
731 "(which does not enclose namespace %qD)",
732 spec, current_namespace, ns);
735 /* The TYPE is being declared. If it is a template type, that means it
736 is a partial specialization. Do appropriate error-checking. */
739 maybe_process_partial_specialization (tree type)
743 if (type == error_mark_node)
744 return error_mark_node;
746 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
748 error ("name of class shadows template template parameter %qD",
750 return error_mark_node;
753 context = TYPE_CONTEXT (type);
755 if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type))
757 /* This is for ordinary explicit specialization and partial
758 specialization of a template class such as:
760 template <> class C<int>;
764 template <class T> class C<T*>;
766 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
768 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
769 && !COMPLETE_TYPE_P (type))
771 check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type));
772 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
773 if (processing_template_decl)
774 push_template_decl (TYPE_MAIN_DECL (type));
776 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
777 error ("specialization of %qT after instantiation", type);
779 else if (CLASS_TYPE_P (type)
780 && !CLASSTYPE_USE_TEMPLATE (type)
781 && CLASSTYPE_TEMPLATE_INFO (type)
782 && context && CLASS_TYPE_P (context)
783 && CLASSTYPE_TEMPLATE_INFO (context))
785 /* This is for an explicit specialization of member class
786 template according to [temp.expl.spec/18]:
788 template <> template <class U> class C<int>::D;
790 The context `C<int>' must be an implicit instantiation.
791 Otherwise this is just a member class template declared
794 template <> class C<int> { template <class U> class D; };
795 template <> template <class U> class C<int>::D;
797 In the first case, `C<int>::D' is a specialization of `C<T>::D'
798 while in the second case, `C<int>::D' is a primary template
799 and `C<T>::D' may not exist. */
801 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context)
802 && !COMPLETE_TYPE_P (type))
806 if (current_namespace
807 != decl_namespace_context (CLASSTYPE_TI_TEMPLATE (type)))
809 pedwarn ("specializing %q#T in different namespace", type);
810 pedwarn (" from definition of %q+#D",
811 CLASSTYPE_TI_TEMPLATE (type));
814 /* Check for invalid specialization after instantiation:
816 template <> template <> class C<int>::D<int>;
817 template <> template <class U> class C<int>::D; */
819 for (t = DECL_TEMPLATE_INSTANTIATIONS
820 (most_general_template (CLASSTYPE_TI_TEMPLATE (type)));
821 t; t = TREE_CHAIN (t))
822 if (TREE_VALUE (t) != type
823 && TYPE_CONTEXT (TREE_VALUE (t)) == context)
824 error ("specialization %qT after instantiation %qT",
825 type, TREE_VALUE (t));
827 /* Mark TYPE as a specialization. And as a result, we only
828 have one level of template argument for the innermost
830 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
831 CLASSTYPE_TI_ARGS (type)
832 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
835 else if (processing_specialization)
837 error ("explicit specialization of non-template %qT", type);
838 return error_mark_node;
844 /* Returns nonzero if we can optimize the retrieval of specializations
845 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
846 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
849 optimize_specialization_lookup_p (tree tmpl)
851 return (DECL_FUNCTION_TEMPLATE_P (tmpl)
852 && DECL_CLASS_SCOPE_P (tmpl)
853 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
855 && CLASS_TYPE_P (DECL_CONTEXT (tmpl))
856 /* The optimized lookup depends on the fact that the
857 template arguments for the member function template apply
858 purely to the containing class, which is not true if the
859 containing class is an explicit or partial
861 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl))
862 && !DECL_MEMBER_TEMPLATE_P (tmpl)
863 && !DECL_CONV_FN_P (tmpl)
864 /* It is possible to have a template that is not a member
865 template and is not a member of a template class:
867 template <typename T>
868 struct S { friend A::f(); };
870 Here, the friend function is a template, but the context does
871 not have template information. The optimized lookup relies
872 on having ARGS be the template arguments for both the class
873 and the function template. */
874 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl)));
877 /* Retrieve the specialization (in the sense of [temp.spec] - a
878 specialization is either an instantiation or an explicit
879 specialization) of TMPL for the given template ARGS. If there is
880 no such specialization, return NULL_TREE. The ARGS are a vector of
881 arguments, or a vector of vectors of arguments, in the case of
882 templates with more than one level of parameters.
884 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
885 then we search for a partial specialization matching ARGS. This
886 parameter is ignored if TMPL is not a class template. */
889 retrieve_specialization (tree tmpl, tree args,
890 bool class_specializations_p)
892 if (args == error_mark_node)
895 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
897 /* There should be as many levels of arguments as there are
898 levels of parameters. */
899 gcc_assert (TMPL_ARGS_DEPTH (args)
900 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)));
902 if (optimize_specialization_lookup_p (tmpl))
905 tree class_specialization;
906 VEC(tree,gc) *methods;
910 /* The template arguments actually apply to the containing
911 class. Find the class specialization with those
913 class_template = CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl));
915 = retrieve_specialization (class_template, args,
916 /*class_specializations_p=*/false);
917 if (!class_specialization)
919 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
920 for the specialization. */
921 idx = class_method_index_for_fn (class_specialization, tmpl);
924 /* Iterate through the methods with the indicated name, looking
925 for the one that has an instance of TMPL. */
926 methods = CLASSTYPE_METHOD_VEC (class_specialization);
927 for (fns = VEC_index (tree, methods, idx); fns; fns = OVL_NEXT (fns))
929 tree fn = OVL_CURRENT (fns);
930 if (DECL_TEMPLATE_INFO (fn) && DECL_TI_TEMPLATE (fn) == tmpl)
940 /* Class templates store their instantiations on the
941 DECL_TEMPLATE_INSTANTIATIONS list; other templates use the
942 DECL_TEMPLATE_SPECIALIZATIONS list. */
943 if (!class_specializations_p
944 && TREE_CODE (DECL_TEMPLATE_RESULT (tmpl)) == TYPE_DECL
945 && TAGGED_TYPE_P (TREE_TYPE (tmpl)))
946 sp = &DECL_TEMPLATE_INSTANTIATIONS (tmpl);
948 sp = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
950 /* Iterate through the list until we find a matching template. */
951 while (*sp != NULL_TREE)
955 if (comp_template_args (TREE_PURPOSE (spec), args))
957 /* Use the move-to-front heuristic to speed up future
961 *sp = TREE_CHAIN (*sp);
962 TREE_CHAIN (spec) = *head;
965 return TREE_VALUE (spec);
967 sp = &TREE_CHAIN (spec);
974 /* Like retrieve_specialization, but for local declarations. */
977 retrieve_local_specialization (tree tmpl)
979 tree spec = (tree) htab_find_with_hash (local_specializations, tmpl,
980 htab_hash_pointer (tmpl));
981 return spec ? TREE_PURPOSE (spec) : NULL_TREE;
984 /* Returns nonzero iff DECL is a specialization of TMPL. */
987 is_specialization_of (tree decl, tree tmpl)
991 if (TREE_CODE (decl) == FUNCTION_DECL)
995 t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
1001 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
1003 for (t = TREE_TYPE (decl);
1005 t = CLASSTYPE_USE_TEMPLATE (t)
1006 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
1007 if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl)))
1014 /* Returns nonzero iff DECL is a specialization of friend declaration
1015 FRIEND according to [temp.friend]. */
1018 is_specialization_of_friend (tree decl, tree friend)
1020 bool need_template = true;
1023 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
1024 || TREE_CODE (decl) == TYPE_DECL);
1026 /* For [temp.friend/6] when FRIEND is an ordinary member function
1027 of a template class, we want to check if DECL is a specialization
1029 if (TREE_CODE (friend) == FUNCTION_DECL
1030 && DECL_TEMPLATE_INFO (friend)
1031 && !DECL_USE_TEMPLATE (friend))
1033 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1034 friend = DECL_TI_TEMPLATE (friend);
1035 need_template = false;
1037 else if (TREE_CODE (friend) == TEMPLATE_DECL
1038 && !PRIMARY_TEMPLATE_P (friend))
1039 need_template = false;
1041 /* There is nothing to do if this is not a template friend. */
1042 if (TREE_CODE (friend) != TEMPLATE_DECL)
1045 if (is_specialization_of (decl, friend))
1049 A member of a class template may be declared to be a friend of a
1050 non-template class. In this case, the corresponding member of
1051 every specialization of the class template is a friend of the
1052 class granting friendship.
1054 For example, given a template friend declaration
1056 template <class T> friend void A<T>::f();
1058 the member function below is considered a friend
1060 template <> struct A<int> {
1064 For this type of template friend, TEMPLATE_DEPTH below will be
1065 nonzero. To determine if DECL is a friend of FRIEND, we first
1066 check if the enclosing class is a specialization of another. */
1068 template_depth = template_class_depth (DECL_CONTEXT (friend));
1070 && DECL_CLASS_SCOPE_P (decl)
1071 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)),
1072 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend))))
1074 /* Next, we check the members themselves. In order to handle
1075 a few tricky cases, such as when FRIEND's are
1077 template <class T> friend void A<T>::g(T t);
1078 template <class T> template <T t> friend void A<T>::h();
1082 void A<int>::g(int);
1083 template <int> void A<int>::h();
1085 we need to figure out ARGS, the template arguments from
1086 the context of DECL. This is required for template substitution
1087 of `T' in the function parameter of `g' and template parameter
1088 of `h' in the above examples. Here ARGS corresponds to `int'. */
1090 tree context = DECL_CONTEXT (decl);
1091 tree args = NULL_TREE;
1092 int current_depth = 0;
1094 while (current_depth < template_depth)
1096 if (CLASSTYPE_TEMPLATE_INFO (context))
1098 if (current_depth == 0)
1099 args = TYPE_TI_ARGS (context);
1101 args = add_to_template_args (TYPE_TI_ARGS (context), args);
1104 context = TYPE_CONTEXT (context);
1107 if (TREE_CODE (decl) == FUNCTION_DECL)
1112 tree friend_args_type;
1113 tree decl_args_type;
1115 /* Make sure that both DECL and FRIEND are templates or
1117 is_template = DECL_TEMPLATE_INFO (decl)
1118 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl));
1119 if (need_template ^ is_template)
1121 else if (is_template)
1123 /* If both are templates, check template parameter list. */
1125 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
1127 if (!comp_template_parms
1128 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)),
1132 decl_type = TREE_TYPE (DECL_TI_TEMPLATE (decl));
1135 decl_type = TREE_TYPE (decl);
1137 friend_type = tsubst_function_type (TREE_TYPE (friend), args,
1138 tf_none, NULL_TREE);
1139 if (friend_type == error_mark_node)
1142 /* Check if return types match. */
1143 if (!same_type_p (TREE_TYPE (decl_type), TREE_TYPE (friend_type)))
1146 /* Check if function parameter types match, ignoring the
1147 `this' parameter. */
1148 friend_args_type = TYPE_ARG_TYPES (friend_type);
1149 decl_args_type = TYPE_ARG_TYPES (decl_type);
1150 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend))
1151 friend_args_type = TREE_CHAIN (friend_args_type);
1152 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1153 decl_args_type = TREE_CHAIN (decl_args_type);
1155 return compparms (decl_args_type, friend_args_type);
1159 /* DECL is a TYPE_DECL */
1161 tree decl_type = TREE_TYPE (decl);
1163 /* Make sure that both DECL and FRIEND are templates or
1166 = CLASSTYPE_TEMPLATE_INFO (decl_type)
1167 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type));
1169 if (need_template ^ is_template)
1171 else if (is_template)
1174 /* If both are templates, check the name of the two
1175 TEMPLATE_DECL's first because is_friend didn't. */
1176 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type))
1177 != DECL_NAME (friend))
1180 /* Now check template parameter list. */
1182 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
1184 return comp_template_parms
1185 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type)),
1189 return (DECL_NAME (decl)
1190 == DECL_NAME (friend));
1196 /* Register the specialization SPEC as a specialization of TMPL with
1197 the indicated ARGS. IS_FRIEND indicates whether the specialization
1198 is actually just a friend declaration. Returns SPEC, or an
1199 equivalent prior declaration, if available. */
1202 register_specialization (tree spec, tree tmpl, tree args, bool is_friend)
1206 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
1208 if (TREE_CODE (spec) == FUNCTION_DECL
1209 && uses_template_parms (DECL_TI_ARGS (spec)))
1210 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1211 register it; we want the corresponding TEMPLATE_DECL instead.
1212 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1213 the more obvious `uses_template_parms (spec)' to avoid problems
1214 with default function arguments. In particular, given
1215 something like this:
1217 template <class T> void f(T t1, T t = T())
1219 the default argument expression is not substituted for in an
1220 instantiation unless and until it is actually needed. */
1223 fn = retrieve_specialization (tmpl, args,
1224 /*class_specializations_p=*/false);
1225 /* We can sometimes try to re-register a specialization that we've
1226 already got. In particular, regenerate_decl_from_template calls
1227 duplicate_decls which will update the specialization list. But,
1228 we'll still get called again here anyhow. It's more convenient
1229 to simply allow this than to try to prevent it. */
1232 else if (fn && DECL_TEMPLATE_SPECIALIZATION (spec))
1234 if (DECL_TEMPLATE_INSTANTIATION (fn))
1237 || DECL_EXPLICIT_INSTANTIATION (fn))
1239 error ("specialization of %qD after instantiation",
1241 return error_mark_node;
1246 /* This situation should occur only if the first
1247 specialization is an implicit instantiation, the
1248 second is an explicit specialization, and the
1249 implicit instantiation has not yet been used. That
1250 situation can occur if we have implicitly
1251 instantiated a member function and then specialized
1254 We can also wind up here if a friend declaration that
1255 looked like an instantiation turns out to be a
1258 template <class T> void foo(T);
1259 class S { friend void foo<>(int) };
1260 template <> void foo(int);
1262 We transform the existing DECL in place so that any
1263 pointers to it become pointers to the updated
1266 If there was a definition for the template, but not
1267 for the specialization, we want this to look as if
1268 there were no definition, and vice versa. */
1269 DECL_INITIAL (fn) = NULL_TREE;
1270 duplicate_decls (spec, fn, is_friend);
1271 /* The call to duplicate_decls will have applied
1274 An explicit specialization of a function template
1275 is inline only if it is explicitly declared to be,
1276 and independently of whether its function template
1279 to the primary function; now copy the inline bits to
1280 the various clones. */
1281 FOR_EACH_CLONE (clone, fn)
1283 DECL_DECLARED_INLINE_P (clone)
1284 = DECL_DECLARED_INLINE_P (fn);
1288 check_specialization_namespace (fn);
1293 else if (DECL_TEMPLATE_SPECIALIZATION (fn))
1295 if (!duplicate_decls (spec, fn, is_friend) && DECL_INITIAL (spec))
1296 /* Dup decl failed, but this is a new definition. Set the
1297 line number so any errors match this new
1299 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec);
1305 /* A specialization must be declared in the same namespace as the
1306 template it is specializing. */
1307 if (DECL_TEMPLATE_SPECIALIZATION (spec)
1308 && !check_specialization_namespace (tmpl))
1309 DECL_CONTEXT (spec) = FROB_CONTEXT (decl_namespace_context (tmpl));
1311 if (!optimize_specialization_lookup_p (tmpl))
1312 DECL_TEMPLATE_SPECIALIZATIONS (tmpl)
1313 = tree_cons (args, spec, DECL_TEMPLATE_SPECIALIZATIONS (tmpl));
1318 /* Unregister the specialization SPEC as a specialization of TMPL.
1319 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1320 if the SPEC was listed as a specialization of TMPL. */
1323 reregister_specialization (tree spec, tree tmpl, tree new_spec)
1327 for (s = &DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
1329 s = &TREE_CHAIN (*s))
1330 if (TREE_VALUE (*s) == spec)
1333 *s = TREE_CHAIN (*s);
1335 TREE_VALUE (*s) = new_spec;
1342 /* Compare an entry in the local specializations hash table P1 (which
1343 is really a pointer to a TREE_LIST) with P2 (which is really a
1347 eq_local_specializations (const void *p1, const void *p2)
1349 return TREE_VALUE ((const_tree) p1) == (const_tree) p2;
1352 /* Hash P1, an entry in the local specializations table. */
1355 hash_local_specialization (const void* p1)
1357 return htab_hash_pointer (TREE_VALUE ((const_tree) p1));
1360 /* Like register_specialization, but for local declarations. We are
1361 registering SPEC, an instantiation of TMPL. */
1364 register_local_specialization (tree spec, tree tmpl)
1368 slot = htab_find_slot_with_hash (local_specializations, tmpl,
1369 htab_hash_pointer (tmpl), INSERT);
1370 *slot = build_tree_list (spec, tmpl);
1373 /* TYPE is a class type. Returns true if TYPE is an explicitly
1374 specialized class. */
1377 explicit_class_specialization_p (tree type)
1379 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
1381 return !uses_template_parms (CLASSTYPE_TI_ARGS (type));
1384 /* Print the list of candidate FNS in an error message. */
1387 print_candidates (tree fns)
1391 const char *str = "candidates are:";
1393 for (fn = fns; fn != NULL_TREE; fn = TREE_CHAIN (fn))
1397 for (f = TREE_VALUE (fn); f; f = OVL_NEXT (f))
1398 error ("%s %+#D", str, OVL_CURRENT (f));
1403 /* Returns the template (one of the functions given by TEMPLATE_ID)
1404 which can be specialized to match the indicated DECL with the
1405 explicit template args given in TEMPLATE_ID. The DECL may be
1406 NULL_TREE if none is available. In that case, the functions in
1407 TEMPLATE_ID are non-members.
1409 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1410 specialization of a member template.
1412 The TEMPLATE_COUNT is the number of references to qualifying
1413 template classes that appeared in the name of the function. See
1414 check_explicit_specialization for a more accurate description.
1416 TSK indicates what kind of template declaration (if any) is being
1417 declared. TSK_TEMPLATE indicates that the declaration given by
1418 DECL, though a FUNCTION_DECL, has template parameters, and is
1419 therefore a template function.
1421 The template args (those explicitly specified and those deduced)
1422 are output in a newly created vector *TARGS_OUT.
1424 If it is impossible to determine the result, an error message is
1425 issued. The error_mark_node is returned to indicate failure. */
1428 determine_specialization (tree template_id,
1431 int need_member_template,
1437 tree explicit_targs;
1438 tree candidates = NULL_TREE;
1439 /* A TREE_LIST of templates of which DECL may be a specialization.
1440 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1441 corresponding TREE_PURPOSE is the set of template arguments that,
1442 when used to instantiate the template, would produce a function
1443 with the signature of DECL. */
1444 tree templates = NULL_TREE;
1446 struct cp_binding_level *b;
1448 *targs_out = NULL_TREE;
1450 if (template_id == error_mark_node || decl == error_mark_node)
1451 return error_mark_node;
1453 fns = TREE_OPERAND (template_id, 0);
1454 explicit_targs = TREE_OPERAND (template_id, 1);
1456 if (fns == error_mark_node)
1457 return error_mark_node;
1459 /* Check for baselinks. */
1460 if (BASELINK_P (fns))
1461 fns = BASELINK_FUNCTIONS (fns);
1463 if (!is_overloaded_fn (fns))
1465 error ("%qD is not a function template", fns);
1466 return error_mark_node;
1469 /* Count the number of template headers specified for this
1472 for (b = current_binding_level;
1473 b->kind == sk_template_parms;
1477 for (; fns; fns = OVL_NEXT (fns))
1479 tree fn = OVL_CURRENT (fns);
1481 if (TREE_CODE (fn) == TEMPLATE_DECL)
1483 tree decl_arg_types;
1486 /* In case of explicit specialization, we need to check if
1487 the number of template headers appearing in the specialization
1488 is correct. This is usually done in check_explicit_specialization,
1489 but the check done there cannot be exhaustive when specializing
1490 member functions. Consider the following code:
1492 template <> void A<int>::f(int);
1493 template <> template <> void A<int>::f(int);
1495 Assuming that A<int> is not itself an explicit specialization
1496 already, the first line specializes "f" which is a non-template
1497 member function, whilst the second line specializes "f" which
1498 is a template member function. So both lines are syntactically
1499 correct, and check_explicit_specialization does not reject
1502 Here, we can do better, as we are matching the specialization
1503 against the declarations. We count the number of template
1504 headers, and we check if they match TEMPLATE_COUNT + 1
1505 (TEMPLATE_COUNT is the number of qualifying template classes,
1506 plus there must be another header for the member template
1509 Notice that if header_count is zero, this is not a
1510 specialization but rather a template instantiation, so there
1511 is no check we can perform here. */
1512 if (header_count && header_count != template_count + 1)
1515 /* Check that the number of template arguments at the
1516 innermost level for DECL is the same as for FN. */
1517 if (current_binding_level->kind == sk_template_parms
1518 && !current_binding_level->explicit_spec_p
1519 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn))
1520 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
1521 (current_template_parms))))
1524 /* DECL might be a specialization of FN. */
1525 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1526 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
1528 /* For a non-static member function, we need to make sure
1529 that the const qualification is the same. Since
1530 get_bindings does not try to merge the "this" parameter,
1531 we must do the comparison explicitly. */
1532 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1533 && !same_type_p (TREE_VALUE (fn_arg_types),
1534 TREE_VALUE (decl_arg_types)))
1537 /* Skip the "this" parameter and, for constructors of
1538 classes with virtual bases, the VTT parameter. A
1539 full specialization of a constructor will have a VTT
1540 parameter, but a template never will. */
1542 = skip_artificial_parms_for (decl, decl_arg_types);
1544 = skip_artificial_parms_for (fn, fn_arg_types);
1546 /* Check that the number of function parameters matches.
1548 template <class T> void f(int i = 0);
1549 template <> void f<int>();
1550 The specialization f<int> is invalid but is not caught
1551 by get_bindings below. */
1552 if (list_length (fn_arg_types) != list_length (decl_arg_types))
1555 /* Function templates cannot be specializations; there are
1556 no partial specializations of functions. Therefore, if
1557 the type of DECL does not match FN, there is no
1559 if (tsk == tsk_template)
1561 if (compparms (fn_arg_types, decl_arg_types))
1562 candidates = tree_cons (NULL_TREE, fn, candidates);
1566 /* See whether this function might be a specialization of this
1568 targs = get_bindings (fn, decl, explicit_targs, /*check_ret=*/true);
1571 /* We cannot deduce template arguments that when used to
1572 specialize TMPL will produce DECL. */
1575 /* Save this template, and the arguments deduced. */
1576 templates = tree_cons (targs, fn, templates);
1578 else if (need_member_template)
1579 /* FN is an ordinary member function, and we need a
1580 specialization of a member template. */
1582 else if (TREE_CODE (fn) != FUNCTION_DECL)
1583 /* We can get IDENTIFIER_NODEs here in certain erroneous
1586 else if (!DECL_FUNCTION_MEMBER_P (fn))
1587 /* This is just an ordinary non-member function. Nothing can
1588 be a specialization of that. */
1590 else if (DECL_ARTIFICIAL (fn))
1591 /* Cannot specialize functions that are created implicitly. */
1595 tree decl_arg_types;
1597 /* This is an ordinary member function. However, since
1598 we're here, we can assume it's enclosing class is a
1599 template class. For example,
1601 template <typename T> struct S { void f(); };
1602 template <> void S<int>::f() {}
1604 Here, S<int>::f is a non-template, but S<int> is a
1605 template class. If FN has the same type as DECL, we
1606 might be in business. */
1608 if (!DECL_TEMPLATE_INFO (fn))
1609 /* Its enclosing class is an explicit specialization
1610 of a template class. This is not a candidate. */
1613 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
1614 TREE_TYPE (TREE_TYPE (fn))))
1615 /* The return types differ. */
1618 /* Adjust the type of DECL in case FN is a static member. */
1619 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1620 if (DECL_STATIC_FUNCTION_P (fn)
1621 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1622 decl_arg_types = TREE_CHAIN (decl_arg_types);
1624 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1627 candidates = tree_cons (NULL_TREE, fn, candidates);
1631 if (templates && TREE_CHAIN (templates))
1637 It is possible for a specialization with a given function
1638 signature to be instantiated from more than one function
1639 template. In such cases, explicit specification of the
1640 template arguments must be used to uniquely identify the
1641 function template specialization being specialized.
1643 Note that here, there's no suggestion that we're supposed to
1644 determine which of the candidate templates is most
1645 specialized. However, we, also have:
1649 Partial ordering of overloaded function template
1650 declarations is used in the following contexts to select
1651 the function template to which a function template
1652 specialization refers:
1654 -- when an explicit specialization refers to a function
1657 So, we do use the partial ordering rules, at least for now.
1658 This extension can only serve to make invalid programs valid,
1659 so it's safe. And, there is strong anecdotal evidence that
1660 the committee intended the partial ordering rules to apply;
1661 the EDG front end has that behavior, and John Spicer claims
1662 that the committee simply forgot to delete the wording in
1663 [temp.expl.spec]. */
1664 tree tmpl = most_specialized_instantiation (templates);
1665 if (tmpl != error_mark_node)
1668 TREE_CHAIN (templates) = NULL_TREE;
1672 if (templates == NULL_TREE && candidates == NULL_TREE)
1674 error ("template-id %qD for %q+D does not match any template "
1675 "declaration", template_id, decl);
1676 return error_mark_node;
1678 else if ((templates && TREE_CHAIN (templates))
1679 || (candidates && TREE_CHAIN (candidates))
1680 || (templates && candidates))
1682 error ("ambiguous template specialization %qD for %q+D",
1684 chainon (candidates, templates);
1685 print_candidates (candidates);
1686 return error_mark_node;
1689 /* We have one, and exactly one, match. */
1692 tree fn = TREE_VALUE (candidates);
1693 /* DECL is a re-declaration of a template function. */
1694 if (TREE_CODE (fn) == TEMPLATE_DECL)
1696 /* It was a specialization of an ordinary member function in a
1698 *targs_out = copy_node (DECL_TI_ARGS (fn));
1699 return DECL_TI_TEMPLATE (fn);
1702 /* It was a specialization of a template. */
1703 targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates)));
1704 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs))
1706 *targs_out = copy_node (targs);
1707 SET_TMPL_ARGS_LEVEL (*targs_out,
1708 TMPL_ARGS_DEPTH (*targs_out),
1709 TREE_PURPOSE (templates));
1712 *targs_out = TREE_PURPOSE (templates);
1713 return TREE_VALUE (templates);
1716 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
1717 but with the default argument values filled in from those in the
1721 copy_default_args_to_explicit_spec_1 (tree spec_types,
1724 tree new_spec_types;
1729 if (spec_types == void_list_node)
1730 return void_list_node;
1732 /* Substitute into the rest of the list. */
1734 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
1735 TREE_CHAIN (tmpl_types));
1737 /* Add the default argument for this parameter. */
1738 return hash_tree_cons (TREE_PURPOSE (tmpl_types),
1739 TREE_VALUE (spec_types),
1743 /* DECL is an explicit specialization. Replicate default arguments
1744 from the template it specializes. (That way, code like:
1746 template <class T> void f(T = 3);
1747 template <> void f(double);
1750 works, as required.) An alternative approach would be to look up
1751 the correct default arguments at the call-site, but this approach
1752 is consistent with how implicit instantiations are handled. */
1755 copy_default_args_to_explicit_spec (tree decl)
1760 tree new_spec_types;
1764 tree object_type = NULL_TREE;
1765 tree in_charge = NULL_TREE;
1766 tree vtt = NULL_TREE;
1768 /* See if there's anything we need to do. */
1769 tmpl = DECL_TI_TEMPLATE (decl);
1770 tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
1771 for (t = tmpl_types; t; t = TREE_CHAIN (t))
1772 if (TREE_PURPOSE (t))
1777 old_type = TREE_TYPE (decl);
1778 spec_types = TYPE_ARG_TYPES (old_type);
1780 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1782 /* Remove the this pointer, but remember the object's type for
1784 object_type = TREE_TYPE (TREE_VALUE (spec_types));
1785 spec_types = TREE_CHAIN (spec_types);
1786 tmpl_types = TREE_CHAIN (tmpl_types);
1788 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
1790 /* DECL may contain more parameters than TMPL due to the extra
1791 in-charge parameter in constructors and destructors. */
1792 in_charge = spec_types;
1793 spec_types = TREE_CHAIN (spec_types);
1795 if (DECL_HAS_VTT_PARM_P (decl))
1798 spec_types = TREE_CHAIN (spec_types);
1802 /* Compute the merged default arguments. */
1804 copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);
1806 /* Compute the new FUNCTION_TYPE. */
1810 new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt),
1815 /* Put the in-charge parameter back. */
1816 new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
1817 TREE_VALUE (in_charge),
1820 new_type = build_method_type_directly (object_type,
1821 TREE_TYPE (old_type),
1825 new_type = build_function_type (TREE_TYPE (old_type),
1827 new_type = cp_build_type_attribute_variant (new_type,
1828 TYPE_ATTRIBUTES (old_type));
1829 new_type = build_exception_variant (new_type,
1830 TYPE_RAISES_EXCEPTIONS (old_type));
1831 TREE_TYPE (decl) = new_type;
1834 /* Check to see if the function just declared, as indicated in
1835 DECLARATOR, and in DECL, is a specialization of a function
1836 template. We may also discover that the declaration is an explicit
1837 instantiation at this point.
1839 Returns DECL, or an equivalent declaration that should be used
1840 instead if all goes well. Issues an error message if something is
1841 amiss. Returns error_mark_node if the error is not easily
1844 FLAGS is a bitmask consisting of the following flags:
1846 2: The function has a definition.
1847 4: The function is a friend.
1849 The TEMPLATE_COUNT is the number of references to qualifying
1850 template classes that appeared in the name of the function. For
1853 template <class T> struct S { void f(); };
1856 the TEMPLATE_COUNT would be 1. However, explicitly specialized
1857 classes are not counted in the TEMPLATE_COUNT, so that in
1859 template <class T> struct S {};
1860 template <> struct S<int> { void f(); }
1861 template <> void S<int>::f();
1863 the TEMPLATE_COUNT would be 0. (Note that this declaration is
1864 invalid; there should be no template <>.)
1866 If the function is a specialization, it is marked as such via
1867 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
1868 is set up correctly, and it is added to the list of specializations
1869 for that template. */
1872 check_explicit_specialization (tree declarator,
1877 int have_def = flags & 2;
1878 int is_friend = flags & 4;
1879 int specialization = 0;
1880 int explicit_instantiation = 0;
1881 int member_specialization = 0;
1882 tree ctype = DECL_CLASS_CONTEXT (decl);
1883 tree dname = DECL_NAME (decl);
1888 if (!processing_specialization)
1891 tsk = tsk_excessive_parms;
1894 tsk = current_tmpl_spec_kind (template_count);
1899 if (processing_specialization)
1902 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1904 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1907 /* This could be something like:
1909 template <class T> void f(T);
1910 class S { friend void f<>(int); } */
1914 /* This case handles bogus declarations like template <>
1915 template <class T> void f<int>(); */
1917 error ("template-id %qD in declaration of primary template",
1924 case tsk_invalid_member_spec:
1925 /* The error has already been reported in
1926 check_specialization_scope. */
1927 return error_mark_node;
1929 case tsk_invalid_expl_inst:
1930 error ("template parameter list used in explicit instantiation");
1936 error ("definition provided for explicit instantiation");
1938 explicit_instantiation = 1;
1941 case tsk_excessive_parms:
1942 case tsk_insufficient_parms:
1943 if (tsk == tsk_excessive_parms)
1944 error ("too many template parameter lists in declaration of %qD",
1946 else if (template_header_count)
1947 error("too few template parameter lists in declaration of %qD", decl);
1949 error("explicit specialization of %qD must be introduced by "
1950 "%<template <>%>", decl);
1954 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
1956 member_specialization = 1;
1962 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
1964 /* This case handles bogus declarations like template <>
1965 template <class T> void f<int>(); */
1967 if (uses_template_parms (declarator))
1968 error ("function template partial specialization %qD "
1969 "is not allowed", declarator);
1971 error ("template-id %qD in declaration of primary template",
1976 if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
1977 /* This is a specialization of a member template, without
1978 specialization the containing class. Something like:
1980 template <class T> struct S {
1981 template <class U> void f (U);
1983 template <> template <class U> void S<int>::f(U) {}
1985 That's a specialization -- but of the entire template. */
1993 if (specialization || member_specialization)
1995 tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
1996 for (; t; t = TREE_CHAIN (t))
1997 if (TREE_PURPOSE (t))
2000 ("default argument specified in explicit specialization");
2005 if (specialization || member_specialization || explicit_instantiation)
2007 tree tmpl = NULL_TREE;
2008 tree targs = NULL_TREE;
2010 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2011 if (TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
2015 gcc_assert (TREE_CODE (declarator) == IDENTIFIER_NODE);
2020 /* If there is no class context, the explicit instantiation
2021 must be at namespace scope. */
2022 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl));
2024 /* Find the namespace binding, using the declaration
2026 fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
2028 if (fns == error_mark_node || !is_overloaded_fn (fns))
2030 error ("%qD is not a template function", dname);
2031 fns = error_mark_node;
2035 tree fn = OVL_CURRENT (fns);
2036 if (!is_associated_namespace (CP_DECL_CONTEXT (decl),
2037 CP_DECL_CONTEXT (fn)))
2038 error ("%qD is not declared in %qD",
2039 decl, current_namespace);
2043 declarator = lookup_template_function (fns, NULL_TREE);
2046 if (declarator == error_mark_node)
2047 return error_mark_node;
2049 if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
2051 if (!explicit_instantiation)
2052 /* A specialization in class scope. This is invalid,
2053 but the error will already have been flagged by
2054 check_specialization_scope. */
2055 return error_mark_node;
2058 /* It's not valid to write an explicit instantiation in
2061 class C { template void f(); }
2063 This case is caught by the parser. However, on
2066 template class C { void f(); };
2068 (which is invalid) we can get here. The error will be
2075 else if (ctype != NULL_TREE
2076 && (TREE_CODE (TREE_OPERAND (declarator, 0)) ==
2079 /* Find the list of functions in ctype that have the same
2080 name as the declared function. */
2081 tree name = TREE_OPERAND (declarator, 0);
2082 tree fns = NULL_TREE;
2085 if (constructor_name_p (name, ctype))
2087 int is_constructor = DECL_CONSTRUCTOR_P (decl);
2089 if (is_constructor ? !TYPE_HAS_CONSTRUCTOR (ctype)
2090 : !CLASSTYPE_DESTRUCTORS (ctype))
2092 /* From [temp.expl.spec]:
2094 If such an explicit specialization for the member
2095 of a class template names an implicitly-declared
2096 special member function (clause _special_), the
2097 program is ill-formed.
2099 Similar language is found in [temp.explicit]. */
2100 error ("specialization of implicitly-declared special member function");
2101 return error_mark_node;
2104 name = is_constructor ? ctor_identifier : dtor_identifier;
2107 if (!DECL_CONV_FN_P (decl))
2109 idx = lookup_fnfields_1 (ctype, name);
2111 fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (ctype), idx);
2115 VEC(tree,gc) *methods;
2118 /* For a type-conversion operator, we cannot do a
2119 name-based lookup. We might be looking for `operator
2120 int' which will be a specialization of `operator T'.
2121 So, we find *all* the conversion operators, and then
2122 select from them. */
2125 methods = CLASSTYPE_METHOD_VEC (ctype);
2127 for (idx = CLASSTYPE_FIRST_CONVERSION_SLOT;
2128 VEC_iterate (tree, methods, idx, ovl);
2131 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl)))
2132 /* There are no more conversion functions. */
2135 /* Glue all these conversion functions together
2136 with those we already have. */
2137 for (; ovl; ovl = OVL_NEXT (ovl))
2138 fns = ovl_cons (OVL_CURRENT (ovl), fns);
2142 if (fns == NULL_TREE)
2144 error ("no member function %qD declared in %qT", name, ctype);
2145 return error_mark_node;
2148 TREE_OPERAND (declarator, 0) = fns;
2151 /* Figure out what exactly is being specialized at this point.
2152 Note that for an explicit instantiation, even one for a
2153 member function, we cannot tell apriori whether the
2154 instantiation is for a member template, or just a member
2155 function of a template class. Even if a member template is
2156 being instantiated, the member template arguments may be
2157 elided if they can be deduced from the rest of the
2159 tmpl = determine_specialization (declarator, decl,
2161 member_specialization,
2165 if (!tmpl || tmpl == error_mark_node)
2166 /* We couldn't figure out what this declaration was
2168 return error_mark_node;
2171 tree gen_tmpl = most_general_template (tmpl);
2173 if (explicit_instantiation)
2175 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2176 is done by do_decl_instantiation later. */
2178 int arg_depth = TMPL_ARGS_DEPTH (targs);
2179 int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
2181 if (arg_depth > parm_depth)
2183 /* If TMPL is not the most general template (for
2184 example, if TMPL is a friend template that is
2185 injected into namespace scope), then there will
2186 be too many levels of TARGS. Remove some of them
2191 new_targs = make_tree_vec (parm_depth);
2192 for (i = arg_depth - parm_depth; i < arg_depth; ++i)
2193 TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
2194 = TREE_VEC_ELT (targs, i);
2198 return instantiate_template (tmpl, targs, tf_error);
2201 /* If we thought that the DECL was a member function, but it
2202 turns out to be specializing a static member function,
2203 make DECL a static member function as well. */
2204 if (DECL_STATIC_FUNCTION_P (tmpl)
2205 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2206 revert_static_member_fn (decl);
2208 /* If this is a specialization of a member template of a
2209 template class, we want to return the TEMPLATE_DECL, not
2210 the specialization of it. */
2211 if (tsk == tsk_template)
2213 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
2214 DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl)) = NULL_TREE;
2217 DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
2218 DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (tmpl))
2219 = DECL_SOURCE_LOCATION (decl);
2220 /* We want to use the argument list specified in the
2221 definition, not in the original declaration. */
2222 DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (tmpl))
2223 = DECL_ARGUMENTS (decl);
2228 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2229 DECL_TEMPLATE_INFO (decl) = tree_cons (tmpl, targs, NULL_TREE);
2231 /* Inherit default function arguments from the template
2232 DECL is specializing. */
2233 copy_default_args_to_explicit_spec (decl);
2235 /* This specialization has the same protection as the
2236 template it specializes. */
2237 TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
2238 TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
2240 /* 7.1.1-1 [dcl.stc]
2242 A storage-class-specifier shall not be specified in an
2243 explicit specialization...
2245 The parser rejects these, so unless action is taken here,
2246 explicit function specializations will always appear with
2249 The action recommended by the C++ CWG in response to C++
2250 defect report 605 is to make the storage class and linkage
2251 of the explicit specialization match the templated function:
2253 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2255 if (tsk == tsk_expl_spec && DECL_FUNCTION_TEMPLATE_P (gen_tmpl))
2257 tree tmpl_func = DECL_TEMPLATE_RESULT (gen_tmpl);
2258 gcc_assert (TREE_CODE (tmpl_func) == FUNCTION_DECL);
2260 /* This specialization has the same linkage and visibility as
2261 the function template it specializes. */
2262 TREE_PUBLIC (decl) = TREE_PUBLIC (tmpl_func);
2263 if (! TREE_PUBLIC (decl))
2265 DECL_INTERFACE_KNOWN (decl) = 1;
2266 DECL_NOT_REALLY_EXTERN (decl) = 1;
2268 DECL_THIS_STATIC (decl) = DECL_THIS_STATIC (tmpl_func);
2269 if (DECL_VISIBILITY_SPECIFIED (tmpl_func))
2271 DECL_VISIBILITY_SPECIFIED (decl) = 1;
2272 DECL_VISIBILITY (decl) = DECL_VISIBILITY (tmpl_func);
2276 /* If DECL is a friend declaration, declared using an
2277 unqualified name, the namespace associated with DECL may
2278 have been set incorrectly. For example, in:
2280 template <typename T> void f(T);
2282 struct S { friend void f<int>(int); }
2285 we will have set the DECL_CONTEXT for the friend
2286 declaration to N, rather than to the global namespace. */
2287 if (DECL_NAMESPACE_SCOPE_P (decl))
2288 DECL_CONTEXT (decl) = DECL_CONTEXT (tmpl);
2290 if (is_friend && !have_def)
2291 /* This is not really a declaration of a specialization.
2292 It's just the name of an instantiation. But, it's not
2293 a request for an instantiation, either. */
2294 SET_DECL_IMPLICIT_INSTANTIATION (decl);
2295 else if (DECL_CONSTRUCTOR_P (decl) || DECL_DESTRUCTOR_P (decl))
2296 /* This is indeed a specialization. In case of constructors
2297 and destructors, we need in-charge and not-in-charge
2298 versions in V3 ABI. */
2299 clone_function_decl (decl, /*update_method_vec_p=*/0);
2301 /* Register this specialization so that we can find it
2303 decl = register_specialization (decl, gen_tmpl, targs, is_friend);
2310 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2311 parameters. These are represented in the same format used for
2312 DECL_TEMPLATE_PARMS. */
2315 comp_template_parms (const_tree parms1, const_tree parms2)
2320 if (parms1 == parms2)
2323 for (p1 = parms1, p2 = parms2;
2324 p1 != NULL_TREE && p2 != NULL_TREE;
2325 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2))
2327 tree t1 = TREE_VALUE (p1);
2328 tree t2 = TREE_VALUE (p2);
2331 gcc_assert (TREE_CODE (t1) == TREE_VEC);
2332 gcc_assert (TREE_CODE (t2) == TREE_VEC);
2334 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
2337 for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
2339 tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
2340 tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
2342 /* If either of the template parameters are invalid, assume
2343 they match for the sake of error recovery. */
2344 if (parm1 == error_mark_node || parm2 == error_mark_node)
2347 if (TREE_CODE (parm1) != TREE_CODE (parm2))
2350 if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM
2351 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1)
2352 == TEMPLATE_TYPE_PARAMETER_PACK (parm2)))
2354 else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
2359 if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
2360 /* One set of parameters has more parameters lists than the
2367 /* Determine whether PARM is a parameter pack. */
2369 template_parameter_pack_p (const_tree parm)
2371 /* Determine if we have a non-type template parameter pack. */
2372 if (TREE_CODE (parm) == PARM_DECL)
2373 return (DECL_TEMPLATE_PARM_P (parm)
2374 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)));
2376 /* If this is a list of template parameters, we could get a
2377 TYPE_DECL or a TEMPLATE_DECL. */
2378 if (TREE_CODE (parm) == TYPE_DECL || TREE_CODE (parm) == TEMPLATE_DECL)
2379 parm = TREE_TYPE (parm);
2381 return ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
2382 || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM)
2383 && TEMPLATE_TYPE_PARAMETER_PACK (parm));
2386 /* Determine whether ARGS describes a variadic template args list,
2387 i.e., one that is terminated by a template argument pack. */
2389 template_args_variadic_p (tree args)
2394 if (args == NULL_TREE)
2397 args = INNERMOST_TEMPLATE_ARGS (args);
2398 nargs = TREE_VEC_LENGTH (args);
2403 last_parm = TREE_VEC_ELT (args, nargs - 1);
2405 return ARGUMENT_PACK_P (last_parm);
2408 /* Generate a new name for the parameter pack name NAME (an
2409 IDENTIFIER_NODE) that incorporates its */
2411 make_ith_pack_parameter_name (tree name, int i)
2413 /* Munge the name to include the parameter index. */
2417 sprintf(numbuf, "%i", i);
2418 newname = (char*)alloca (IDENTIFIER_LENGTH (name) + strlen(numbuf) + 2);
2419 sprintf(newname, "%s#%i", IDENTIFIER_POINTER (name), i);
2420 return get_identifier (newname);
2423 /* Structure used to track the progress of find_parameter_packs_r. */
2424 struct find_parameter_pack_data
2426 /* TREE_LIST that will contain all of the parameter packs found by
2428 tree* parameter_packs;
2430 /* Set of AST nodes that have been visited by the traversal. */
2431 struct pointer_set_t *visited;
2433 /* Whether we should replace parameter packs with
2434 ERROR_MARK_NODE. Used by check_for_bare_parameter_packs. */
2435 bool set_packs_to_error;
2438 /* Identifies all of the argument packs that occur in a template
2439 argument and appends them to the TREE_LIST inside DATA, which is a
2440 find_parameter_pack_data structure. This is a subroutine of
2441 make_pack_expansion and uses_parameter_packs. */
2443 find_parameter_packs_r (tree *tp, int *walk_subtrees, void* data)
2446 struct find_parameter_pack_data* ppd =
2447 (struct find_parameter_pack_data*)data;
2448 bool parameter_pack_p = false;
2450 /* Don't visit nodes twice, except when we're clearing out parameter
2452 if (pointer_set_contains (ppd->visited, *tp))
2459 /* Identify whether this is a parameter pack or not. */
2460 switch (TREE_CODE (t))
2462 case TEMPLATE_PARM_INDEX:
2463 if (TEMPLATE_PARM_PARAMETER_PACK (t))
2464 parameter_pack_p = true;
2467 case TEMPLATE_TYPE_PARM:
2468 case TEMPLATE_TEMPLATE_PARM:
2469 if (TEMPLATE_TYPE_PARAMETER_PACK (t))
2470 parameter_pack_p = true;
2474 if (FUNCTION_PARAMETER_PACK_P (t))
2476 /* We don't want to walk into the type of a PARM_DECL,
2477 because we don't want to see the type parameter pack. */
2479 parameter_pack_p = true;
2484 if (ppd->set_packs_to_error)
2485 /* Pointer types are shared, set in that case the outermost
2486 POINTER_TYPE to error_mark_node rather than the parameter pack. */
2494 /* Not a parameter pack. */
2498 if (parameter_pack_p)
2500 /* Add this parameter pack to the list. */
2501 *ppd->parameter_packs = tree_cons (NULL_TREE, t, *ppd->parameter_packs);
2503 if (ppd->set_packs_to_error)
2504 /* The caller requested that we set the parameter packs to
2505 ERROR_MARK_NODE so that they will not trip up the compiler
2506 later. The caller is responsible for emitting an error. */
2507 *tp = error_mark_node;
2509 /* Make sure we do not visit this node again. */
2510 pointer_set_insert (ppd->visited, *tp);
2513 /* Make sure we do not visit this node again. */
2514 pointer_set_insert (ppd->visited, *tp);
2517 cp_walk_tree (&TYPE_CONTEXT (t),
2518 &find_parameter_packs_r, ppd, NULL);
2520 /* This switch statement will return immediately if we don't find a
2522 switch (TREE_CODE (t))
2524 case TEMPLATE_PARM_INDEX:
2527 case BOUND_TEMPLATE_TEMPLATE_PARM:
2528 /* Check the template itself. */
2529 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t)),
2530 &find_parameter_packs_r, ppd, NULL);
2531 /* Check the template arguments. */
2532 cp_walk_tree (&TYPE_TI_ARGS (t), &find_parameter_packs_r, ppd,
2537 case TEMPLATE_TYPE_PARM:
2538 case TEMPLATE_TEMPLATE_PARM:
2545 if (TYPE_PTRMEMFUNC_P (t))
2551 if (TYPE_TEMPLATE_INFO (t))
2552 cp_walk_tree (&TREE_VALUE (TYPE_TEMPLATE_INFO (t)),
2553 &find_parameter_packs_r, ppd, NULL);
2559 cp_walk_tree (&TREE_TYPE (t),
2560 &find_parameter_packs_r, ppd, NULL);
2564 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t), &find_parameter_packs_r,
2569 case TYPE_PACK_EXPANSION:
2570 case EXPR_PACK_EXPANSION:
2575 cp_walk_tree (&TYPE_MAX_VALUE (t), &find_parameter_packs_r,
2587 /* Determines if the expression or type T uses any parameter packs. */
2589 uses_parameter_packs (tree t)
2591 tree parameter_packs = NULL_TREE;
2592 struct find_parameter_pack_data ppd;
2593 ppd.parameter_packs = ¶meter_packs;
2594 ppd.visited = pointer_set_create ();
2595 ppd.set_packs_to_error = false;
2596 cp_walk_tree (&t, &find_parameter_packs_r, &ppd, NULL);
2597 pointer_set_destroy (ppd.visited);
2598 return parameter_packs != NULL_TREE;
2601 /* Turn ARG, which may be an expression, type, or a TREE_LIST
2602 representation a base-class initializer into a parameter pack
2603 expansion. If all goes well, the resulting node will be an
2604 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
2607 make_pack_expansion (tree arg)
2610 tree parameter_packs = NULL_TREE;
2611 bool for_types = false;
2612 struct find_parameter_pack_data ppd;
2614 ppd.set_packs_to_error = false;
2616 if (!arg || arg == error_mark_node)
2619 if (TREE_CODE (arg) == TREE_LIST)
2621 /* The only time we will see a TREE_LIST here is for a base
2622 class initializer. In this case, the TREE_PURPOSE will be a
2623 _TYPE node (representing the base class expansion we're
2624 initializing) and the TREE_VALUE will be a TREE_LIST
2625 containing the initialization arguments.
2627 The resulting expansion looks somewhat different from most
2628 expansions. Rather than returning just one _EXPANSION, we
2629 return a TREE_LIST whose TREE_PURPOSE is a
2630 TYPE_PACK_EXPANSION containing the bases that will be
2631 initialized. The TREE_VALUE will be identical to the
2632 original TREE_VALUE, which is a list of arguments that will
2633 be passed to each base. We do not introduce any new pack
2634 expansion nodes into the TREE_VALUE (although it is possible
2635 that some already exist), because the TREE_PURPOSE and
2636 TREE_VALUE all need to be expanded together with the same
2637 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
2638 resulting TREE_PURPOSE will mention the parameter packs in
2639 both the bases and the arguments to the bases. */
2642 tree parameter_packs = NULL_TREE;
2644 /* Determine which parameter packs will be used by the base
2646 ppd.visited = pointer_set_create ();
2647 ppd.parameter_packs = ¶meter_packs;
2648 cp_walk_tree (&TREE_PURPOSE (arg), &find_parameter_packs_r,
2651 if (parameter_packs == NULL_TREE)
2653 error ("base initializer expansion %<%T%> contains no parameter packs", arg);
2654 pointer_set_destroy (ppd.visited);
2655 return error_mark_node;
2658 if (TREE_VALUE (arg) != void_type_node)
2660 /* Collect the sets of parameter packs used in each of the
2661 initialization arguments. */
2662 for (value = TREE_VALUE (arg); value; value = TREE_CHAIN (value))
2664 /* Determine which parameter packs will be expanded in this
2666 cp_walk_tree (&TREE_VALUE (value), &find_parameter_packs_r,
2671 pointer_set_destroy (ppd.visited);
2673 /* Create the pack expansion type for the base type. */
2674 purpose = make_node (TYPE_PACK_EXPANSION);
2675 SET_PACK_EXPANSION_PATTERN (purpose, TREE_PURPOSE (arg));
2676 PACK_EXPANSION_PARAMETER_PACKS (purpose) = parameter_packs;
2678 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
2679 they will rarely be compared to anything. */
2680 SET_TYPE_STRUCTURAL_EQUALITY (purpose);
2682 return tree_cons (purpose, TREE_VALUE (arg), NULL_TREE);
2685 if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
2688 /* Build the PACK_EXPANSION_* node. */
2689 result = make_node (for_types ? TYPE_PACK_EXPANSION : EXPR_PACK_EXPANSION);
2690 SET_PACK_EXPANSION_PATTERN (result, arg);
2691 if (TREE_CODE (result) == EXPR_PACK_EXPANSION)
2693 /* Propagate type and const-expression information. */
2694 TREE_TYPE (result) = TREE_TYPE (arg);
2695 TREE_CONSTANT (result) = TREE_CONSTANT (arg);
2698 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
2699 they will rarely be compared to anything. */
2700 SET_TYPE_STRUCTURAL_EQUALITY (result);
2702 /* Determine which parameter packs will be expanded. */
2703 ppd.parameter_packs = ¶meter_packs;
2704 ppd.visited = pointer_set_create ();
2705 cp_walk_tree (&arg, &find_parameter_packs_r, &ppd, NULL);
2706 pointer_set_destroy (ppd.visited);
2708 /* Make sure we found some parameter packs. */
2709 if (parameter_packs == NULL_TREE)
2712 error ("expansion pattern %<%T%> contains no argument packs", arg);
2714 error ("expansion pattern %<%E%> contains no argument packs", arg);
2715 return error_mark_node;
2717 PACK_EXPANSION_PARAMETER_PACKS (result) = parameter_packs;
2722 /* Checks T for any "bare" parameter packs, which have not yet been
2723 expanded, and issues an error if any are found. This operation can
2724 only be done on full expressions or types (e.g., an expression
2725 statement, "if" condition, etc.), because we could have expressions like:
2727 foo(f(g(h(args)))...)
2729 where "args" is a parameter pack. check_for_bare_parameter_packs
2730 should not be called for the subexpressions args, h(args),
2731 g(h(args)), or f(g(h(args))), because we would produce erroneous
2734 Returns TRUE if there were no bare parameter packs, returns FALSE
2735 (and emits an error) if there were bare parameter packs.*/
2737 check_for_bare_parameter_packs (tree* t)
2739 tree parameter_packs = NULL_TREE;
2740 struct find_parameter_pack_data ppd;
2742 if (!processing_template_decl || !t || !*t || *t == error_mark_node)
2745 if (TREE_CODE (*t) == TYPE_DECL)
2746 t = &TREE_TYPE (*t);
2748 ppd.parameter_packs = ¶meter_packs;
2749 ppd.visited = pointer_set_create ();
2750 ppd.set_packs_to_error = false;
2751 cp_walk_tree (t, &find_parameter_packs_r, &ppd, NULL);
2752 pointer_set_destroy (ppd.visited);
2754 if (parameter_packs)
2756 error ("parameter packs not expanded with `...':");
2757 while (parameter_packs)
2759 tree pack = TREE_VALUE (parameter_packs);
2760 tree name = NULL_TREE;
2762 if (TREE_CODE (pack) == TEMPLATE_TYPE_PARM
2763 || TREE_CODE (pack) == TEMPLATE_TEMPLATE_PARM)
2764 name = TYPE_NAME (pack);
2765 else if (TREE_CODE (pack) == TEMPLATE_PARM_INDEX)
2766 name = DECL_NAME (TEMPLATE_PARM_DECL (pack));
2768 name = DECL_NAME (pack);
2771 inform (" %qD", name);
2773 inform (" <anonymous>");
2775 parameter_packs = TREE_CHAIN (parameter_packs);
2778 /* Clean up any references to these parameter packs within the
2780 ppd.parameter_packs = ¶meter_packs;
2781 ppd.visited = pointer_set_create ();
2782 ppd.set_packs_to_error = true;
2783 cp_walk_tree (t, &find_parameter_packs_r, &ppd, NULL);
2784 pointer_set_destroy (ppd.visited);
2792 /* Expand any parameter packs that occur in the template arguments in
2795 expand_template_argument_pack (tree args)
2797 tree result_args = NULL_TREE;
2798 int in_arg, out_arg = 0, nargs = args ? TREE_VEC_LENGTH (args) : 0;
2799 int num_result_args = -1;
2801 /* First, determine if we need to expand anything, and the number of
2802 slots we'll need. */
2803 for (in_arg = 0; in_arg < nargs; ++in_arg)
2805 tree arg = TREE_VEC_ELT (args, in_arg);
2806 if (ARGUMENT_PACK_P (arg))
2808 int num_packed = TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg));
2809 if (num_result_args < 0)
2810 num_result_args = in_arg + num_packed;
2812 num_result_args += num_packed;
2816 if (num_result_args >= 0)
2821 /* If no expansion is necessary, we're done. */
2822 if (num_result_args < 0)
2825 /* Expand arguments. */
2826 result_args = make_tree_vec (num_result_args);
2827 for (in_arg = 0; in_arg < nargs; ++in_arg)
2829 tree arg = TREE_VEC_ELT (args, in_arg);
2830 if (ARGUMENT_PACK_P (arg))
2832 tree packed = ARGUMENT_PACK_ARGS (arg);
2833 int i, num_packed = TREE_VEC_LENGTH (packed);
2834 for (i = 0; i < num_packed; ++i, ++out_arg)
2835 TREE_VEC_ELT (result_args, out_arg) = TREE_VEC_ELT(packed, i);
2839 TREE_VEC_ELT (result_args, out_arg) = arg;
2847 /* Complain if DECL shadows a template parameter.
2849 [temp.local]: A template-parameter shall not be redeclared within its
2850 scope (including nested scopes). */
2853 check_template_shadow (tree decl)
2857 /* If we're not in a template, we can't possibly shadow a template
2859 if (!current_template_parms)
2862 /* Figure out what we're shadowing. */
2863 if (TREE_CODE (decl) == OVERLOAD)
2864 decl = OVL_CURRENT (decl);
2865 olddecl = innermost_non_namespace_value (DECL_NAME (decl));
2867 /* If there's no previous binding for this name, we're not shadowing
2868 anything, let alone a template parameter. */
2872 /* If we're not shadowing a template parameter, we're done. Note
2873 that OLDDECL might be an OVERLOAD (or perhaps even an
2874 ERROR_MARK), so we can't just blithely assume it to be a _DECL
2876 if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
2879 /* We check for decl != olddecl to avoid bogus errors for using a
2880 name inside a class. We check TPFI to avoid duplicate errors for
2881 inline member templates. */
2883 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms))
2886 error ("declaration of %q+#D", decl);
2887 error (" shadows template parm %q+#D", olddecl);
2890 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
2891 ORIG_LEVEL, DECL, and TYPE. */
2894 build_template_parm_index (int index,
2900 tree t = make_node (TEMPLATE_PARM_INDEX);
2901 TEMPLATE_PARM_IDX (t) = index;
2902 TEMPLATE_PARM_LEVEL (t) = level;
2903 TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
2904 TEMPLATE_PARM_DECL (t) = decl;
2905 TREE_TYPE (t) = type;
2906 TREE_CONSTANT (t) = TREE_CONSTANT (decl);
2907 TREE_INVARIANT (t) = TREE_INVARIANT (decl);
2908 TREE_READONLY (t) = TREE_READONLY (decl);
2913 /* Find the canonical type parameter for the given template type
2914 parameter. Returns the canonical type parameter, which may be TYPE
2915 if no such parameter existed. */
2917 canonical_type_parameter (tree type)
2920 int idx = TEMPLATE_TYPE_IDX (type);
2921 if (!canonical_template_parms)
2922 canonical_template_parms = VEC_alloc (tree, gc, idx+1);
2924 while (VEC_length (tree, canonical_template_parms) <= (unsigned)idx)
2925 VEC_safe_push (tree, gc, canonical_template_parms, NULL_TREE);
2927 list = VEC_index (tree, canonical_template_parms, idx);
2928 while (list && !comptypes (type, TREE_VALUE (list), COMPARE_STRUCTURAL))
2929 list = TREE_CHAIN (list);
2932 return TREE_VALUE (list);
2935 VEC_replace(tree, canonical_template_parms, idx,
2936 tree_cons (NULL_TREE, type,
2937 VEC_index (tree, canonical_template_parms, idx)));
2942 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
2943 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
2944 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
2945 new one is created. */
2948 reduce_template_parm_level (tree index, tree type, int levels, tree args,
2949 tsubst_flags_t complain)
2951 if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
2952 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
2953 != TEMPLATE_PARM_LEVEL (index) - levels))
2955 tree orig_decl = TEMPLATE_PARM_DECL (index);
2958 decl = build_decl (TREE_CODE (orig_decl), DECL_NAME (orig_decl), type);
2959 TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl);
2960 TREE_INVARIANT (decl) = TREE_INVARIANT (orig_decl);
2961 TREE_READONLY (decl) = TREE_READONLY (orig_decl);
2962 DECL_ARTIFICIAL (decl) = 1;
2963 SET_DECL_TEMPLATE_PARM_P (decl);
2965 t = build_template_parm_index (TEMPLATE_PARM_IDX (index),
2966 TEMPLATE_PARM_LEVEL (index) - levels,
2967 TEMPLATE_PARM_ORIG_LEVEL (index),
2969 TEMPLATE_PARM_DESCENDANTS (index) = t;
2970 TEMPLATE_PARM_PARAMETER_PACK (t)
2971 = TEMPLATE_PARM_PARAMETER_PACK (index);
2973 /* Template template parameters need this. */
2974 if (TREE_CODE (decl) == TEMPLATE_DECL)
2975 DECL_TEMPLATE_PARMS (decl) = tsubst_template_parms
2976 (DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index)),
2980 return TEMPLATE_PARM_DESCENDANTS (index);
2983 /* Process information from new template parameter PARM and append it to the
2984 LIST being built. This new parameter is a non-type parameter iff
2985 IS_NON_TYPE is true. This new parameter is a parameter
2986 pack iff IS_PARAMETER_PACK is true. */
2989 process_template_parm (tree list, tree parm, bool is_non_type,
2990 bool is_parameter_pack)
2997 gcc_assert (TREE_CODE (parm) == TREE_LIST);
2998 defval = TREE_PURPOSE (parm);
3002 tree p = tree_last (list);
3004 if (p && TREE_VALUE (p) != error_mark_node)
3007 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
3008 idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
3010 idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
3020 parm = TREE_VALUE (parm);
3022 SET_DECL_TEMPLATE_PARM_P (parm);
3024 if (TREE_TYPE (parm) == error_mark_node)
3026 err_parm_list = build_tree_list (defval, parm);
3027 TREE_VALUE (err_parm_list) = error_mark_node;
3028 return chainon (list, err_parm_list);
3034 The top-level cv-qualifiers on the template-parameter are
3035 ignored when determining its type. */
3036 TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
3037 if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
3039 err_parm_list = build_tree_list (defval, parm);
3040 TREE_VALUE (err_parm_list) = error_mark_node;
3041 return chainon (list, err_parm_list);
3044 if (uses_parameter_packs (TREE_TYPE (parm)) && !is_parameter_pack)
3046 /* This template parameter is not a parameter pack, but it
3047 should be. Complain about "bare" parameter packs. */
3048 check_for_bare_parameter_packs (&TREE_TYPE (parm));
3050 /* Recover by calling this a parameter pack. */
3051 is_parameter_pack = true;
3055 /* A template parameter is not modifiable. */
3056 TREE_CONSTANT (parm) = 1;
3057 TREE_INVARIANT (parm) = 1;
3058 TREE_READONLY (parm) = 1;
3059 decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
3060 TREE_CONSTANT (decl) = 1;
3061 TREE_INVARIANT (decl) = 1;
3062 TREE_READONLY (decl) = 1;
3063 DECL_INITIAL (parm) = DECL_INITIAL (decl)
3064 = build_template_parm_index (idx, processing_template_decl,
3065 processing_template_decl,
3066 decl, TREE_TYPE (parm));
3068 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm))
3069 = is_parameter_pack;
3074 parm = TREE_VALUE (TREE_VALUE (parm));
3076 if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
3078 t = make_aggr_type (TEMPLATE_TEMPLATE_PARM);
3079 /* This is for distinguishing between real templates and template
3080 template parameters */
3081 TREE_TYPE (parm) = t;
3082 TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t;
3087 t = make_aggr_type (TEMPLATE_TYPE_PARM);
3088 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3089 decl = build_decl (TYPE_DECL, parm, t);
3092 TYPE_NAME (t) = decl;
3093 TYPE_STUB_DECL (t) = decl;
3095 TEMPLATE_TYPE_PARM_INDEX (t)
3096 = build_template_parm_index (idx, processing_template_decl,
3097 processing_template_decl,
3098 decl, TREE_TYPE (parm));
3099 TEMPLATE_TYPE_PARAMETER_PACK (t) = is_parameter_pack;
3100 TYPE_CANONICAL (t) = canonical_type_parameter (t);
3102 DECL_ARTIFICIAL (decl) = 1;
3103 SET_DECL_TEMPLATE_PARM_P (decl);
3105 parm = build_tree_list (defval, parm);
3106 return chainon (list, parm);
3109 /* The end of a template parameter list has been reached. Process the
3110 tree list into a parameter vector, converting each parameter into a more
3111 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3115 end_template_parm_list (tree parms)
3119 tree saved_parmlist = make_tree_vec (list_length (parms));
3121 current_template_parms
3122 = tree_cons (size_int (processing_template_decl),
3123 saved_parmlist, current_template_parms);
3125 for (parm = parms, nparms = 0; parm; parm = next, nparms++)
3127 next = TREE_CHAIN (parm);
3128 TREE_VEC_ELT (saved_parmlist, nparms) = parm;
3129 TREE_CHAIN (parm) = NULL_TREE;
3132 --processing_template_parmlist;
3134 return saved_parmlist;
3137 /* end_template_decl is called after a template declaration is seen. */
3140 end_template_decl (void)
3142 reset_specialization ();
3144 if (! processing_template_decl)
3147 /* This matches the pushlevel in begin_template_parm_list. */
3150 --processing_template_decl;
3151 current_template_parms = TREE_CHAIN (current_template_parms);
3154 /* Within the declaration of a template, return all levels of template
3155 parameters that apply. The template parameters are represented as
3156 a TREE_VEC, in the form documented in cp-tree.h for template
3160 current_template_args (void)
3163 tree args = NULL_TREE;
3164 int length = TMPL_PARMS_DEPTH (current_template_parms);
3167 /* If there is only one level of template parameters, we do not
3168 create a TREE_VEC of TREE_VECs. Instead, we return a single
3169 TREE_VEC containing the arguments. */
3171 args = make_tree_vec (length);
3173 for (header = current_template_parms; header; header = TREE_CHAIN (header))
3175 tree a = copy_node (TREE_VALUE (header));
3178 TREE_TYPE (a) = NULL_TREE;
3179 for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
3181 tree t = TREE_VEC_ELT (a, i);
3183 /* T will be a list if we are called from within a
3184 begin/end_template_parm_list pair, but a vector directly
3185 if within a begin/end_member_template_processing pair. */
3186 if (TREE_CODE (t) == TREE_LIST)
3190 if (!error_operand_p (t))
3192 if (TREE_CODE (t) == TYPE_DECL
3193 || TREE_CODE (t) == TEMPLATE_DECL)
3197 if (TEMPLATE_TYPE_PARAMETER_PACK (t))
3199 /* Turn this argument into a TYPE_ARGUMENT_PACK
3200 with a single element, which expands T. */
3201 tree vec = make_tree_vec (1);
3202 TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
3204 t = make_node (TYPE_ARGUMENT_PACK);
3205 SET_ARGUMENT_PACK_ARGS (t, vec);
3210 t = DECL_INITIAL (t);
3212 if (TEMPLATE_PARM_PARAMETER_PACK (t))
3214 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3215 with a single element, which expands T. */
3216 tree vec = make_tree_vec (1);
3217 tree type = TREE_TYPE (TEMPLATE_PARM_DECL (t));
3218 TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
3220 t = make_node (NONTYPE_ARGUMENT_PACK);
3221 SET_ARGUMENT_PACK_ARGS (t, vec);
3222 TREE_TYPE (t) = type;
3225 TREE_VEC_ELT (a, i) = t;
3231 TREE_VEC_ELT (args, --l) = a;
3239 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
3240 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
3241 a member template. Used by push_template_decl below. */
3244 build_template_decl (tree decl, tree parms, bool member_template_p)
3246 tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
3247 DECL_TEMPLATE_PARMS (tmpl) = parms;
3248 DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
3249 DECL_MEMBER_TEMPLATE_P (tmpl) = member_template_p;
3250 if (DECL_LANG_SPECIFIC (decl))
3252 DECL_STATIC_FUNCTION_P (tmpl) = DECL_STATIC_FUNCTION_P (decl);
3253 DECL_CONSTRUCTOR_P (tmpl) = DECL_CONSTRUCTOR_P (decl);
3254 DECL_DESTRUCTOR_P (tmpl) = DECL_DESTRUCTOR_P (decl);
3255 DECL_NONCONVERTING_P (tmpl) = DECL_NONCONVERTING_P (decl);
3256 DECL_ASSIGNMENT_OPERATOR_P (tmpl) = DECL_ASSIGNMENT_OPERATOR_P (decl);
3257 if (DECL_OVERLOADED_OPERATOR_P (decl))
3258 SET_OVERLOADED_OPERATOR_CODE (tmpl,
3259 DECL_OVERLOADED_OPERATOR_P (decl));
3265 struct template_parm_data
3267 /* The level of the template parameters we are currently
3271 /* The index of the specialization argument we are currently
3275 /* An array whose size is the number of template parameters. The
3276 elements are nonzero if the parameter has been used in any one
3277 of the arguments processed so far. */
3280 /* An array whose size is the number of template arguments. The
3281 elements are nonzero if the argument makes use of template
3282 parameters of this level. */
3283 int* arg_uses_template_parms;
3286 /* Subroutine of push_template_decl used to see if each template
3287 parameter in a partial specialization is used in the explicit
3288 argument list. If T is of the LEVEL given in DATA (which is
3289 treated as a template_parm_data*), then DATA->PARMS is marked
3293 mark_template_parm (tree t, void* data)
3297 struct template_parm_data* tpd = (struct template_parm_data*) data;
3299 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
3301 level = TEMPLATE_PARM_LEVEL (t);
3302 idx = TEMPLATE_PARM_IDX (t);
3306 level = TEMPLATE_TYPE_LEVEL (t);
3307 idx = TEMPLATE_TYPE_IDX (t);
3310 if (level == tpd->level)
3312 tpd->parms[idx] = 1;
3313 tpd->arg_uses_template_parms[tpd->current_arg] = 1;
3316 /* Return zero so that for_each_template_parm will continue the
3317 traversal of the tree; we want to mark *every* template parm. */
3321 /* Process the partial specialization DECL. */
3324 process_partial_specialization (tree decl)
3326 tree type = TREE_TYPE (decl);
3327 tree maintmpl = CLASSTYPE_TI_TEMPLATE (type);
3328 tree specargs = CLASSTYPE_TI_ARGS (type);
3329 tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
3330 tree inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
3331 tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
3332 int nargs = TREE_VEC_LENGTH (inner_args);
3333 int ntparms = TREE_VEC_LENGTH (inner_parms);
3335 int did_error_intro = 0;
3336 struct template_parm_data tpd;
3337 struct template_parm_data tpd2;
3339 /* We check that each of the template parameters given in the
3340 partial specialization is used in the argument list to the
3341 specialization. For example:
3343 template <class T> struct S;
3344 template <class T> struct S<T*>;
3346 The second declaration is OK because `T*' uses the template
3347 parameter T, whereas
3349 template <class T> struct S<int>;
3351 is no good. Even trickier is:
3362 The S2<T> declaration is actually invalid; it is a
3363 full-specialization. Of course,
3366 struct S2<T (*)(U)>;
3368 or some such would have been OK. */
3369 tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
3370 tpd.parms = (int *) alloca (sizeof (int) * ntparms);
3371 memset (tpd.parms, 0, sizeof (int) * ntparms);
3373 tpd.arg_uses_template_parms = (int *) alloca (sizeof (int) * nargs);
3374 memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
3375 for (i = 0; i < nargs; ++i)
3377 tpd.current_arg = i;
3378 for_each_template_parm (TREE_VEC_ELT (inner_args, i),
3379 &mark_template_parm,
3382 /*include_nondeduced_p=*/false);
3384 for (i = 0; i < ntparms; ++i)
3385 if (tpd.parms[i] == 0)
3387 /* One of the template parms was not used in the
3389 if (!did_error_intro)
3391 error ("template parameters not used in partial specialization:");
3392 did_error_intro = 1;
3395 error (" %qD", TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
3398 /* [temp.class.spec]
3400 The argument list of the specialization shall not be identical to
3401 the implicit argument list of the primary template. */
3402 if (comp_template_args
3404 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
3406 error ("partial specialization %qT does not specialize any template arguments", type);
3408 /* [temp.class.spec]
3410 A partially specialized non-type argument expression shall not
3411 involve template parameters of the partial specialization except
3412 when the argument expression is a simple identifier.
3414 The type of a template parameter corresponding to a specialized
3415 non-type argument shall not be dependent on a parameter of the
3418 Also, we verify that pack expansions only occur at the
3419 end of the argument list. */
3420 gcc_assert (nargs == DECL_NTPARMS (maintmpl));
3422 for (i = 0; i < nargs; ++i)
3424 tree parm = TREE_VALUE (TREE_VEC_ELT (main_inner_parms, i));
3425 tree arg = TREE_VEC_ELT (inner_args, i);
3426 tree packed_args = NULL_TREE;
3429 if (ARGUMENT_PACK_P (arg))
3431 /* Extract the arguments from the argument pack. We'll be
3432 iterating over these in the following loop. */
3433 packed_args = ARGUMENT_PACK_ARGS (arg);
3434 len = TREE_VEC_LENGTH (packed_args);
3437 for (j = 0; j < len; j++)
3440 /* Get the Jth argument in the parameter pack. */
3441 arg = TREE_VEC_ELT (packed_args, j);
3443 if (PACK_EXPANSION_P (arg))
3445 /* Pack expansions must come at the end of the
3447 if ((packed_args && j < len - 1)
3448 || (!packed_args && i < nargs - 1))
3450 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
3451 error ("parameter pack argument %qE must be at the end of the template argument list", arg);
3453 error ("parameter pack argument %qT must be at the end of the template argument list", arg);
3456 TREE_VEC_ELT (packed_args, j) = error_mark_node;
3460 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
3461 /* We only care about the pattern. */
3462 arg = PACK_EXPANSION_PATTERN (arg);
3464 if (/* These first two lines are the `non-type' bit. */
3466 && TREE_CODE (arg) != TEMPLATE_DECL
3467 /* This next line is the `argument expression is not just a
3468 simple identifier' condition and also the `specialized
3469 non-type argument' bit. */
3470 && TREE_CODE (arg) != TEMPLATE_PARM_INDEX)
3472 if ((!packed_args && tpd.arg_uses_template_parms[i])
3473 || (packed_args && uses_template_parms (arg)))
3474 error ("template argument %qE involves template parameter(s)",
3478 /* Look at the corresponding template parameter,
3479 marking which template parameters its type depends
3481 tree type = TREE_TYPE (parm);
3485 /* We haven't yet initialized TPD2. Do so now. */
3486 tpd2.arg_uses_template_parms
3487 = (int *) alloca (sizeof (int) * nargs);
3488 /* The number of parameters here is the number in the
3489 main template, which, as checked in the assertion
3491 tpd2.parms = (int *) alloca (sizeof (int) * nargs);
3493 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
3496 /* Mark the template parameters. But this time, we're
3497 looking for the template parameters of the main
3498 template, not in the specialization. */
3499 tpd2.current_arg = i;
3500 tpd2.arg_uses_template_parms[i] = 0;
3501 memset (tpd2.parms, 0, sizeof (int) * nargs);
3502 for_each_template_parm (type,
3503 &mark_template_parm,
3506 /*include_nondeduced_p=*/false);
3508 if (tpd2.arg_uses_template_parms [i])
3510 /* The type depended on some template parameters.
3511 If they are fully specialized in the
3512 specialization, that's OK. */
3514 for (j = 0; j < nargs; ++j)
3515 if (tpd2.parms[j] != 0
3516 && tpd.arg_uses_template_parms [j])
3518 error ("type %qT of template argument %qE depends "
3519 "on template parameter(s)",
3530 if (retrieve_specialization (maintmpl, specargs,
3531 /*class_specializations_p=*/true))
3532 /* We've already got this specialization. */
3535 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
3536 = tree_cons (specargs, inner_parms,
3537 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
3538 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
3542 /* Check that a template declaration's use of default arguments and
3543 parameter packs is not invalid. Here, PARMS are the template
3544 parameters. IS_PRIMARY is nonzero if DECL is the thing declared by
3545 a primary template. IS_PARTIAL is nonzero if DECL is a partial
3549 IS_FRIEND_DECL is nonzero if DECL is a friend function template
3550 declaration (but not a definition); 1 indicates a declaration, 2
3551 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
3552 emitted for extraneous default arguments.
3554 Returns TRUE if there were no errors found, FALSE otherwise. */
3557 check_default_tmpl_args (tree decl, tree parms, int is_primary,
3558 int is_partial, int is_friend_decl)
3561 int last_level_to_check;
3563 bool no_errors = true;
3567 A default template-argument shall not be specified in a
3568 function template declaration or a function template definition, nor
3569 in the template-parameter-list of the definition of a member of a
3572 if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
3573 /* You can't have a function template declaration in a local
3574 scope, nor you can you define a member of a class template in a
3578 if (current_class_type
3579 && !TYPE_BEING_DEFINED (current_class_type)
3580 && DECL_LANG_SPECIFIC (decl)
3581 /* If this is either a friend defined in the scope of the class
3582 or a member function. */
3583 && (DECL_FUNCTION_MEMBER_P (decl)
3584 ? same_type_p (DECL_CONTEXT (decl), current_class_type)
3585 : DECL_FRIEND_CONTEXT (decl)
3586 ? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type)
3588 /* And, if it was a member function, it really was defined in
3589 the scope of the class. */
3590 && (!DECL_FUNCTION_MEMBER_P (decl)
3591 || DECL_INITIALIZED_IN_CLASS_P (decl)))
3592 /* We already checked these parameters when the template was
3593 declared, so there's no need to do it again now. This function
3594 was defined in class scope, but we're processing it's body now
3595 that the class is complete. */
3598 /* Core issue 226 (C++0x only): the following only applies to class
3600 if ((cxx_dialect == cxx98) || TREE_CODE (decl) != FUNCTION_DECL)
3604 If a template-parameter has a default template-argument, all
3605 subsequent template-parameters shall have a default
3606 template-argument supplied. */
3607 for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
3609 tree inner_parms = TREE_VALUE (parm_level);
3610 int ntparms = TREE_VEC_LENGTH (inner_parms);
3611 int seen_def_arg_p = 0;
3614 for (i = 0; i < ntparms; ++i)
3616 tree parm = TREE_VEC_ELT (inner_parms, i);
3618 if (parm == error_mark_node)
3621 if (TREE_PURPOSE (parm))
3623 else if (seen_def_arg_p)
3625 error ("no default argument for %qD", TREE_VALUE (parm));
3626 /* For better subsequent error-recovery, we indicate that
3627 there should have been a default argument. */
3628 TREE_PURPOSE (parm) = error_mark_node;
3634 && TREE_CODE (decl) == TYPE_DECL
3636 && template_parameter_pack_p (TREE_VALUE (parm)))
3638 /* A primary class template can only have one
3639 parameter pack, at the end of the template
3642 if (TREE_CODE (TREE_VALUE (parm)) == PARM_DECL)
3643 error ("parameter pack %qE must be at the end of the"
3644 " template parameter list", TREE_VALUE (parm));
3646 error ("parameter pack %qT must be at the end of the"
3647 " template parameter list",
3648 TREE_TYPE (TREE_VALUE (parm)));
3650 TREE_VALUE (TREE_VEC_ELT (inner_parms, i))
3658 if (((cxx_dialect == cxx98) && TREE_CODE (decl) != TYPE_DECL)
3662 /* For an ordinary class template, default template arguments are
3663 allowed at the innermost level, e.g.:
3664 template <class T = int>
3666 but, in a partial specialization, they're not allowed even
3667 there, as we have in [temp.class.spec]:
3669 The template parameter list of a specialization shall not
3670 contain default template argument values.
3672 So, for a partial specialization, or for a function template
3673 (in C++98/C++03), we look at all of them. */
3676 /* But, for a primary class template that is not a partial
3677 specialization we look at all template parameters except the
3679 parms = TREE_CHAIN (parms);
3681 /* Figure out what error message to issue. */
3682 if (is_friend_decl == 2)
3683 msg = "default template arguments may not be used in function template friend re-declaration";
3684 else if (is_friend_decl)
3685 msg = "default template arguments may not be used in function template friend declarations";
3686 else if (TREE_CODE (decl) == FUNCTION_DECL && (cxx_dialect == cxx98))
3687 msg = "default template arguments may not be used in function templates";
3688 else if (is_partial)
3689 msg = "default template arguments may not be used in partial specializations";
3691 msg = "default argument for template parameter for class enclosing %qD";
3693 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
3694 /* If we're inside a class definition, there's no need to
3695 examine the parameters to the class itself. On the one
3696 hand, they will be checked when the class is defined, and,
3697 on the other, default arguments are valid in things like:
3698 template <class T = double>
3699 struct S { template <class U> void f(U); };
3700 Here the default argument for `S' has no bearing on the
3701 declaration of `f'. */
3702 last_level_to_check = template_class_depth (current_class_type) + 1;
3704 /* Check everything. */
3705 last_level_to_check = 0;
3707 for (parm_level = parms;
3708 parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
3709 parm_level = TREE_CHAIN (parm_level))
3711 tree inner_parms = TREE_VALUE (parm_level);
3715 ntparms = TREE_VEC_LENGTH (inner_parms);
3716 for (i = 0; i < ntparms; ++i)
3718 if (TREE_VEC_ELT (inner_parms, i) == error_mark_node)
3721 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
3726 if (is_friend_decl == 2)
3733 /* Clear out the default argument so that we are not
3735 TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
3739 /* At this point, if we're still interested in issuing messages,
3740 they must apply to classes surrounding the object declared. */
3742 msg = "default argument for template parameter for class enclosing %qD";
3748 /* Worker for push_template_decl_real, called via
3749 for_each_template_parm. DATA is really an int, indicating the
3750 level of the parameters we are interested in. If T is a template
3751 parameter of that level, return nonzero. */
3754 template_parm_this_level_p (tree t, void* data)
3756 int this_level = *(int *)data;
3759 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
3760 level = TEMPLATE_PARM_LEVEL (t);
3762 level = TEMPLATE_TYPE_LEVEL (t);
3763 return level == this_level;
3766 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
3767 parameters given by current_template_args, or reuses a
3768 previously existing one, if appropriate. Returns the DECL, or an
3769 equivalent one, if it is replaced via a call to duplicate_decls.
3771 If IS_FRIEND is true, DECL is a friend declaration. */
3774 push_template_decl_real (tree decl, bool is_friend)
3782 int new_template_p = 0;
3783 /* True if the template is a member template, in the sense of
3785 bool member_template_p = false;
3787 if (decl == error_mark_node)
3790 /* See if this is a partial specialization. */
3791 is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl)
3792 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
3793 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)));
3795 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl))
3799 /* For a friend, we want the context of the friend function, not
3800 the type of which it is a friend. */
3801 ctx = DECL_CONTEXT (decl);
3802 else if (CP_DECL_CONTEXT (decl)
3803 && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
3804 /* In the case of a virtual function, we want the class in which
3806 ctx = CP_DECL_CONTEXT (decl);
3808 /* Otherwise, if we're currently defining some class, the DECL
3809 is assumed to be a member of the class. */
3810 ctx = current_scope ();
3812 if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
3815 if (!DECL_CONTEXT (decl))
3816 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
3818 /* See if this is a primary template. */
3819 if (is_friend && ctx)
3820 /* A friend template that specifies a class context, i.e.
3821 template <typename T> friend void A<T>::f();
3825 primary = template_parm_scope_p ();
3829 if (DECL_CLASS_SCOPE_P (decl))
3830 member_template_p = true;
3831 if (TREE_CODE (decl) == TYPE_DECL
3832 && ANON_AGGRNAME_P (DECL_NAME (decl)))
3833 error ("template class without a name");
3834 else if (TREE_CODE (decl) == FUNCTION_DECL)
3836 if (DECL_DESTRUCTOR_P (decl))
3840 A destructor shall not be a member template. */
3841 error ("destructor %qD declared as member template", decl);
3842 return error_mark_node;
3844 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl))
3845 && (!TYPE_ARG_TYPES (TREE_TYPE (decl))
3846 || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
3847 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
3848 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl))))
3849 == void_list_node)))
3851 /* [basic.stc.dynamic.allocation]
3853 An allocation function can be a function
3854 template. ... Template allocation functions shall
3855 have two or more parameters. */
3856 error ("invalid template declaration of %qD", decl);
3857 return error_mark_node;
3860 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
3861 && CLASS_TYPE_P (TREE_TYPE (decl)))
3865 error ("template declaration of %q#D", decl);
3866 return error_mark_node;
3870 /* Check to see that the rules regarding the use of default
3871 arguments are not being violated. */
3872 check_default_tmpl_args (decl, current_template_parms,
3873 primary, is_partial, /*is_friend_decl=*/0);
3875 /* Ensure that there are no parameter packs in the type of this
3876 declaration that have not been expanded. */
3877 if (TREE_CODE (decl) == FUNCTION_DECL)
3879 /* Check each of the arguments individually to see if there are
3880 any bare parameter packs. */
3881 tree type = TREE_TYPE (decl);
3882 tree arg = DECL_ARGUMENTS (decl);
3883 tree argtype = TYPE_ARG_TYPES (type);
3885 while (arg && argtype)
3887 if (!FUNCTION_PARAMETER_PACK_P (arg)
3888 && !check_for_bare_parameter_packs (&TREE_TYPE (arg)))
3890 /* This is a PARM_DECL that contains unexpanded parameter
3891 packs. We have already complained about this in the
3892 check_for_bare_parameter_packs call, so just replace
3893 these types with ERROR_MARK_NODE. */
3894 TREE_TYPE (arg) = error_mark_node;
3895 TREE_VALUE (argtype) = error_mark_node;
3898 arg = TREE_CHAIN (arg);
3899 argtype = TREE_CHAIN (argtype);
3902 /* Check for bare parameter packs in the return type and the
3903 exception specifiers. */
3904 if (!check_for_bare_parameter_packs (&TREE_TYPE (type)))
3905 /* Errors were already issued, set return type to int
3906 as the frontend doesn't expect error_mark_node as
3908 TREE_TYPE (type) = integer_type_node;
3909 check_for_bare_parameter_packs (&TYPE_RAISES_EXCEPTIONS (type));
3911 else if (!check_for_bare_parameter_packs (&TREE_TYPE (decl)))
3912 return error_mark_node;
3915 return process_partial_specialization (decl);
3917 args = current_template_args ();
3920 || TREE_CODE (ctx) == FUNCTION_DECL
3921 || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
3922 || (is_friend && !DECL_TEMPLATE_INFO (decl)))
3924 if (DECL_LANG_SPECIFIC (decl)
3925 && DECL_TEMPLATE_INFO (decl)
3926 && DECL_TI_TEMPLATE (decl))
3927 tmpl = DECL_TI_TEMPLATE (decl);
3928 /* If DECL is a TYPE_DECL for a class-template, then there won't
3929 be DECL_LANG_SPECIFIC. The information equivalent to
3930 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
3931 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
3932 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
3933 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
3935 /* Since a template declaration already existed for this
3936 class-type, we must be redeclaring it here. Make sure
3937 that the redeclaration is valid. */
3938 redeclare_class_template (TREE_TYPE (decl),
3939 current_template_parms);
3940 /* We don't need to create a new TEMPLATE_DECL; just use the
3941 one we already had. */
3942 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
3946 tmpl = build_template_decl (decl, current_template_parms,
3950 if (DECL_LANG_SPECIFIC (decl)
3951 && DECL_TEMPLATE_SPECIALIZATION (decl))
3953 /* A specialization of a member template of a template
3955 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
3956 DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
3957 DECL_TEMPLATE_INFO (decl) = NULL_TREE;
3963 tree a, t, current, parms;
3965 tree tinfo = get_template_info (decl);
3969 error ("template definition of non-template %q#D", decl);
3973 tmpl = TI_TEMPLATE (tinfo);
3975 if (DECL_FUNCTION_TEMPLATE_P (tmpl)
3976 && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
3977 && DECL_TEMPLATE_SPECIALIZATION (decl)
3978 && DECL_MEMBER_TEMPLATE_P (tmpl))
3982 /* The declaration is a specialization of a member
3983 template, declared outside the class. Therefore, the
3984 innermost template arguments will be NULL, so we
3985 replace them with the arguments determined by the
3986 earlier call to check_explicit_specialization. */
3987 args = DECL_TI_ARGS (decl);
3990 = build_template_decl (decl, current_template_parms,
3992 DECL_TEMPLATE_RESULT (new_tmpl) = decl;
3993 TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
3994 DECL_TI_TEMPLATE (decl) = new_tmpl;
3995 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
3996 DECL_TEMPLATE_INFO (new_tmpl)
3997 = tree_cons (tmpl, args, NULL_TREE);
3999 register_specialization (new_tmpl,
4000 most_general_template (tmpl),
4006 /* Make sure the template headers we got make sense. */
4008 parms = DECL_TEMPLATE_PARMS (tmpl);
4009 i = TMPL_PARMS_DEPTH (parms);
4010 if (TMPL_ARGS_DEPTH (args) != i)
4012 error ("expected %d levels of template parms for %q#D, got %d",
4013 i, decl, TMPL_ARGS_DEPTH (args));
4016 for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
4018 a = TMPL_ARGS_LEVEL (args, i);
4019 t = INNERMOST_TEMPLATE_PARMS (parms);
4021 if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
4023 if (current == decl)
4024 error ("got %d template parameters for %q#D",
4025 TREE_VEC_LENGTH (a), decl);
4027 error ("got %d template parameters for %q#T",
4028 TREE_VEC_LENGTH (a), current);
4029 error (" but %d required", TREE_VEC_LENGTH (t));
4030 return error_mark_node;
4033 if (current == decl)
4036 current = (TYPE_P (current)
4037 ? TYPE_CONTEXT (current)
4038 : DECL_CONTEXT (current));
4041 /* Check that the parms are used in the appropriate qualifying scopes
4042 in the declarator. */
4043 if (!comp_template_args
4045 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl)))))
4048 template arguments to %qD do not match original template %qD",
4049 decl, DECL_TEMPLATE_RESULT (tmpl));
4050 if (!uses_template_parms (TI_ARGS (tinfo)))
4051 inform ("use template<> for an explicit specialization");
4052 /* Avoid crash in import_export_decl. */
4053 DECL_INTERFACE_KNOWN (decl) = 1;
4054 return error_mark_node;
4058 DECL_TEMPLATE_RESULT (tmpl) = decl;
4059 TREE_TYPE (tmpl) = TREE_TYPE (decl);
4061 /* Push template declarations for global functions and types. Note
4062 that we do not try to push a global template friend declared in a
4063 template class; such a thing may well depend on the template
4064 parameters of the class. */
4065 if (new_template_p && !ctx
4066 && !(is_friend && template_class_depth (current_class_type) > 0))
4068 tmpl = pushdecl_namespace_level (tmpl, is_friend);
4069 if (tmpl == error_mark_node)
4070 return error_mark_node;
4072 /* Hide template friend classes that haven't been declared yet. */
4073 if (is_friend && TREE_CODE (decl) == TYPE_DECL)
4075 DECL_ANTICIPATED (tmpl) = 1;
4076 DECL_FRIEND_P (tmpl) = 1;
4082 tree parms = DECL_TEMPLATE_PARMS (tmpl);
4085 DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
4086 if (DECL_CONV_FN_P (tmpl))
4088 int depth = TMPL_PARMS_DEPTH (parms);
4090 /* It is a conversion operator. See if the type converted to
4091 depends on innermost template operands. */
4093 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl)),
4095 DECL_TEMPLATE_CONV_FN_P (tmpl) = 1;
4098 /* Give template template parms a DECL_CONTEXT of the template
4099 for which they are a parameter. */
4100 parms = INNERMOST_TEMPLATE_PARMS (parms);
4101 for (i = TREE_VEC_LENGTH (parms) - 1; i >= 0; --i)
4103 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
4104 if (TREE_CODE (parm) == TEMPLATE_DECL)
4105 DECL_CONTEXT (parm) = tmpl;
4109 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
4110 back to its most general template. If TMPL is a specialization,
4111 ARGS may only have the innermost set of arguments. Add the missing
4112 argument levels if necessary. */
4113 if (DECL_TEMPLATE_INFO (tmpl))
4114 args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);
4116 info = tree_cons (tmpl, args, NULL_TREE);
4118 if (DECL_IMPLICIT_TYPEDEF_P (decl))
4119 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
4120 else if (DECL_LANG_SPECIFIC (decl))
4121 DECL_TEMPLATE_INFO (decl) = info;
4123 return DECL_TEMPLATE_RESULT (tmpl);
4127 push_template_decl (tree decl)
4129 return push_template_decl_real (decl, false);
4132 /* Called when a class template TYPE is redeclared with the indicated
4133 template PARMS, e.g.:
4135 template <class T> struct S;
4136 template <class T> struct S {}; */
4139 redeclare_class_template (tree type, tree parms)
4145 if (!TYPE_TEMPLATE_INFO (type))
4147 error ("%qT is not a template type", type);
4151 tmpl = TYPE_TI_TEMPLATE (type);
4152 if (!PRIMARY_TEMPLATE_P (tmpl))
4153 /* The type is nested in some template class. Nothing to worry
4154 about here; there are no new template parameters for the nested
4160 error ("template specifiers not specified in declaration of %qD",
4165 parms = INNERMOST_TEMPLATE_PARMS (parms);
4166 tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
4168 if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
4170 error ("redeclared with %d template parameter(s)",
4171 TREE_VEC_LENGTH (parms));
4172 inform ("previous declaration %q+D used %d template parameter(s)",
4173 tmpl, TREE_VEC_LENGTH (tmpl_parms));
4177 for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
4184 if (TREE_VEC_ELT (tmpl_parms, i) == error_mark_node
4185 || TREE_VEC_ELT (parms, i) == error_mark_node)
4188 tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
4189 parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
4190 tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i));
4191 parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
4193 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
4195 if (tmpl_parm != error_mark_node
4196 && (TREE_CODE (tmpl_parm) != TREE_CODE (parm)
4197 || (TREE_CODE (tmpl_parm) != TYPE_DECL
4198 && !same_type_p (TREE_TYPE (tmpl_parm), TREE_TYPE (parm)))))
4200 error ("template parameter %q+#D", tmpl_parm);
4201 error ("redeclared here as %q#D", parm);
4205 if (tmpl_default != NULL_TREE && parm_default != NULL_TREE)
4207 /* We have in [temp.param]:
4209 A template-parameter may not be given default arguments
4210 by two different declarations in the same scope. */
4211 error ("redefinition of default argument for %q#D", parm);
4212 inform ("%Joriginal definition appeared here", tmpl_parm);
4216 if (parm_default != NULL_TREE)
4217 /* Update the previous template parameters (which are the ones
4218 that will really count) with the new default value. */
4219 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default;
4220 else if (tmpl_default != NULL_TREE)
4221 /* Update the new parameters, too; they'll be used as the
4222 parameters for any members. */
4223 TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default;
4229 /* Simplify EXPR if it is a non-dependent expression. Returns the
4230 (possibly simplified) expression. */
4233 fold_non_dependent_expr (tree expr)
4235 if (expr == NULL_TREE)
4238 /* If we're in a template, but EXPR isn't value dependent, simplify
4239 it. We're supposed to treat:
4241 template <typename T> void f(T[1 + 1]);
4242 template <typename T> void f(T[2]);
4244 as two declarations of the same function, for example. */
4245 if (processing_template_decl
4246 && !type_dependent_expression_p (expr)
4247 && !value_dependent_expression_p (expr))
4249 HOST_WIDE_INT saved_processing_template_decl;
4251 saved_processing_template_decl = processing_template_decl;
4252 processing_template_decl = 0;
4253 expr = tsubst_copy_and_build (expr,
4256 /*in_decl=*/NULL_TREE,
4257 /*function_p=*/false,
4258 /*integral_constant_expression_p=*/true);
4259 processing_template_decl = saved_processing_template_decl;
4264 /* EXPR is an expression which is used in a constant-expression context.
4265 For instance, it could be a VAR_DECL with a constant initializer.
4266 Extract the innest constant expression.
4268 This is basically a more powerful version of
4269 integral_constant_value, which can be used also in templates where
4270 initializers can maintain a syntactic rather than semantic form
4271 (even if they are non-dependent, for access-checking purposes). */
4274 fold_decl_constant_value (tree expr)
4276 tree const_expr = expr;
4279 expr = fold_non_dependent_expr (const_expr);
4280 const_expr = integral_constant_value (expr);
4282 while (expr != const_expr);
4287 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
4288 must be a function or a pointer-to-function type, as specified
4289 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
4290 and check that the resulting function has external linkage. */
4293 convert_nontype_argument_function (tree type, tree expr)
4298 fn = instantiate_type (type, fns, tf_none);
4299 if (fn == error_mark_node)
4300 return error_mark_node;
4303 if (TREE_CODE (fn_no_ptr) == ADDR_EXPR)
4304 fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0);
4305 if (TREE_CODE (fn_no_ptr) == BASELINK)
4306 fn_no_ptr = BASELINK_FUNCTIONS (fn_no_ptr);
4308 /* [temp.arg.nontype]/1
4310 A template-argument for a non-type, non-template template-parameter
4313 -- the address of an object or function with external linkage. */
4314 if (!DECL_EXTERNAL_LINKAGE_P (fn_no_ptr))
4316 error ("%qE is not a valid template argument for type %qT "
4317 "because function %qD has not external linkage",
4318 expr, type, fn_no_ptr);
4325 /* Attempt to convert the non-type template parameter EXPR to the
4326 indicated TYPE. If the conversion is successful, return the
4327 converted value. If the conversion is unsuccessful, return
4328 NULL_TREE if we issued an error message, or error_mark_node if we
4329 did not. We issue error messages for out-and-out bad template
4330 parameters, but not simply because the conversion failed, since we
4331 might be just trying to do argument deduction. Both TYPE and EXPR
4332 must be non-dependent.
4334 The conversion follows the special rules described in
4335 [temp.arg.nontype], and it is much more strict than an implicit
4338 This function is called twice for each template argument (see
4339 lookup_template_class for a more accurate description of this
4340 problem). This means that we need to handle expressions which
4341 are not valid in a C++ source, but can be created from the
4342 first call (for instance, casts to perform conversions). These
4343 hacks can go away after we fix the double coercion problem. */
4346 convert_nontype_argument (tree type, tree expr)
4350 /* Detect immediately string literals as invalid non-type argument.
4351 This special-case is not needed for correctness (we would easily
4352 catch this later), but only to provide better diagnostic for this
4353 common user mistake. As suggested by DR 100, we do not mention
4354 linkage issues in the diagnostic as this is not the point. */
4355 if (TREE_CODE (expr) == STRING_CST)
4357 error ("%qE is not a valid template argument for type %qT "
4358 "because string literals can never be used in this context",
4363 /* If we are in a template, EXPR may be non-dependent, but still
4364 have a syntactic, rather than semantic, form. For example, EXPR
4365 might be a SCOPE_REF, rather than the VAR_DECL to which the
4366 SCOPE_REF refers. Preserving the qualifying scope is necessary
4367 so that access checking can be performed when the template is
4368 instantiated -- but here we need the resolved form so that we can
4369 convert the argument. */
4370 expr = fold_non_dependent_expr (expr);
4371 if (error_operand_p (expr))
4372 return error_mark_node;
4373 expr_type = TREE_TYPE (expr);
4375 /* HACK: Due to double coercion, we can get a
4376 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
4377 which is the tree that we built on the first call (see
4378 below when coercing to reference to object or to reference to
4379 function). We just strip everything and get to the arg.
4380 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
4382 if (TREE_CODE (expr) == NOP_EXPR)
4384 if (TYPE_REF_OBJ_P (type) || TYPE_REFFN_P (type))
4386 /* ??? Maybe we could use convert_from_reference here, but we
4387 would need to relax its constraints because the NOP_EXPR
4388 could actually change the type to something more cv-qualified,
4389 and this is not folded by convert_from_reference. */
4390 tree addr = TREE_OPERAND (expr, 0);
4391 gcc_assert (TREE_CODE (expr_type) == REFERENCE_TYPE);
4392 gcc_assert (TREE_CODE (addr) == ADDR_EXPR);
4393 gcc_assert (TREE_CODE (TREE_TYPE (addr)) == POINTER_TYPE);
4394 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4395 (TREE_TYPE (expr_type),
4396 TREE_TYPE (TREE_TYPE (addr))));
4398 expr = TREE_OPERAND (addr, 0);
4399 expr_type = TREE_TYPE (expr);
4402 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
4403 parameter is a pointer to object, through decay and
4404 qualification conversion. Let's strip everything. */
4405 else if (TYPE_PTROBV_P (type))
4408 gcc_assert (TREE_CODE (expr) == ADDR_EXPR);
4409 gcc_assert (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE);
4410 /* Skip the ADDR_EXPR only if it is part of the decay for
4411 an array. Otherwise, it is part of the original argument
4412 in the source code. */
4413 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == ARRAY_TYPE)
4414 expr = TREE_OPERAND (expr, 0);
4415 expr_type = TREE_TYPE (expr);
4419 /* [temp.arg.nontype]/5, bullet 1
4421 For a non-type template-parameter of integral or enumeration type,
4422 integral promotions (_conv.prom_) and integral conversions
4423 (_conv.integral_) are applied. */
4424 if (INTEGRAL_TYPE_P (type))
4426 if (!INTEGRAL_TYPE_P (expr_type))
4427 return error_mark_node;
4429 expr = fold_decl_constant_value (expr);
4430 /* Notice that there are constant expressions like '4 % 0' which
4431 do not fold into integer constants. */
4432 if (TREE_CODE (expr) != INTEGER_CST)
4434 error ("%qE is not a valid template argument for type %qT "
4435 "because it is a non-constant expression", expr, type);
4439 /* At this point, an implicit conversion does what we want,
4440 because we already know that the expression is of integral
4442 expr = ocp_convert (type, expr, CONV_IMPLICIT, LOOKUP_PROTECT);
4443 if (expr == error_mark_node)
4444 return error_mark_node;
4446 /* Conversion was allowed: fold it to a bare integer constant. */
4449 /* [temp.arg.nontype]/5, bullet 2
4451 For a non-type template-parameter of type pointer to object,
4452 qualification conversions (_conv.qual_) and the array-to-pointer
4453 conversion (_conv.array_) are applied. */
4454 else if (TYPE_PTROBV_P (type))
4456 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
4458 A template-argument for a non-type, non-template template-parameter
4459 shall be one of: [...]
4461 -- the name of a non-type template-parameter;
4462 -- the address of an object or function with external linkage, [...]
4463 expressed as "& id-expression" where the & is optional if the name
4464 refers to a function or array, or if the corresponding
4465 template-parameter is a reference.
4467 Here, we do not care about functions, as they are invalid anyway
4468 for a parameter of type pointer-to-object. */
4470 if (DECL_P (expr) && DECL_TEMPLATE_PARM_P (expr))
4471 /* Non-type template parameters are OK. */
4473 else if (TREE_CODE (expr) != ADDR_EXPR
4474 && TREE_CODE (expr_type) != ARRAY_TYPE)
4476 if (TREE_CODE (expr) == VAR_DECL)
4478 error ("%qD is not a valid template argument "
4479 "because %qD is a variable, not the address of "
4484 /* Other values, like integer constants, might be valid
4485 non-type arguments of some other type. */
4486 return error_mark_node;
4492 decl = ((TREE_CODE (expr) == ADDR_EXPR)
4493 ? TREE_OPERAND (expr, 0) : expr);
4494 if (TREE_CODE (decl) != VAR_DECL)
4496 error ("%qE is not a valid template argument of type %qT "
4497 "because %qE is not a variable",
4501 else if (!DECL_EXTERNAL_LINKAGE_P (decl))
4503 error ("%qE is not a valid template argument of type %qT "
4504 "because %qD does not have external linkage",
4510 expr = decay_conversion (expr);
4511 if (expr == error_mark_node)
4512 return error_mark_node;
4514 expr = perform_qualification_conversions (type, expr);
4515 if (expr == error_mark_node)
4516 return error_mark_node;
4518 /* [temp.arg.nontype]/5, bullet 3
4520 For a non-type template-parameter of type reference to object, no
4521 conversions apply. The type referred to by the reference may be more
4522 cv-qualified than the (otherwise identical) type of the
4523 template-argument. The template-parameter is bound directly to the
4524 template-argument, which must be an lvalue. */
4525 else if (TYPE_REF_OBJ_P (type))
4527 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type),
4529 return error_mark_node;
4531 if (!at_least_as_qualified_p (TREE_TYPE (type), expr_type))
4533 error ("%qE is not a valid template argument for type %qT "
4534 "because of conflicts in cv-qualification", expr, type);
4538 if (!real_lvalue_p (expr))
4540 error ("%qE is not a valid template argument for type %qT "
4541 "because it is not an lvalue", expr, type);
4545 /* [temp.arg.nontype]/1
4547 A template-argument for a non-type, non-template template-parameter
4548 shall be one of: [...]
4550 -- the address of an object or function with external linkage. */
4551 if (!DECL_EXTERNAL_LINKAGE_P (expr))
4553 error ("%qE is not a valid template argument for type %qT "
4554 "because object %qD has not external linkage",
4559 expr = build_nop (type, build_address (expr));
4561 /* [temp.arg.nontype]/5, bullet 4
4563 For a non-type template-parameter of type pointer to function, only
4564 the function-to-pointer conversion (_conv.func_) is applied. If the
4565 template-argument represents a set of overloaded functions (or a
4566 pointer to such), the matching function is selected from the set
4568 else if (TYPE_PTRFN_P (type))
4570 /* If the argument is a template-id, we might not have enough
4571 context information to decay the pointer. */
4572 if (!type_unknown_p (expr_type))
4574 expr = decay_conversion (expr);
4575 if (expr == error_mark_node)
4576 return error_mark_node;
4579 expr = convert_nontype_argument_function (type, expr);
4580 if (!expr || expr == error_mark_node)
4583 /* [temp.arg.nontype]/5, bullet 5
4585 For a non-type template-parameter of type reference to function, no
4586 conversions apply. If the template-argument represents a set of
4587 overloaded functions, the matching function is selected from the set
4589 else if (TYPE_REFFN_P (type))
4591 if (TREE_CODE (expr) == ADDR_EXPR)
4593 error ("%qE is not a valid template argument for type %qT "
4594 "because it is a pointer", expr, type);
4595 inform ("try using %qE instead", TREE_OPERAND (expr, 0));
4599 expr = convert_nontype_argument_function (TREE_TYPE (type), expr);
4600 if (!expr || expr == error_mark_node)
4603 expr = build_nop (type, build_address (expr));
4605 /* [temp.arg.nontype]/5, bullet 6
4607 For a non-type template-parameter of type pointer to member function,
4608 no conversions apply. If the template-argument represents a set of
4609 overloaded member functions, the matching member function is selected
4610 from the set (_over.over_). */
4611 else if (TYPE_PTRMEMFUNC_P (type))
4613 expr = instantiate_type (type, expr, tf_none);
4614 if (expr == error_mark_node)
4615 return error_mark_node;
4617 /* There is no way to disable standard conversions in
4618 resolve_address_of_overloaded_function (called by
4619 instantiate_type). It is possible that the call succeeded by
4620 converting &B::I to &D::I (where B is a base of D), so we need
4621 to reject this conversion here.
4623 Actually, even if there was a way to disable standard conversions,
4624 it would still be better to reject them here so that we can
4625 provide a superior diagnostic. */
4626 if (!same_type_p (TREE_TYPE (expr), type))
4628 /* Make sure we are just one standard conversion off. */
4629 gcc_assert (can_convert (type, TREE_TYPE (expr)));
4630 error ("%qE is not a valid template argument for type %qT "
4631 "because it is of type %qT", expr, type,
4633 inform ("standard conversions are not allowed in this context");
4637 /* [temp.arg.nontype]/5, bullet 7
4639 For a non-type template-parameter of type pointer to data member,
4640 qualification conversions (_conv.qual_) are applied. */
4641 else if (TYPE_PTRMEM_P (type))
4643 expr = perform_qualification_conversions (type, expr);
4644 if (expr == error_mark_node)
4647 /* A template non-type parameter must be one of the above. */
4651 /* Sanity check: did we actually convert the argument to the
4653 gcc_assert (same_type_p (type, TREE_TYPE (expr)));
4658 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
4659 template template parameters. Both PARM_PARMS and ARG_PARMS are
4660 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
4663 Consider the example:
4664 template <class T> class A;
4665 template<template <class U> class TT> class B;
4667 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
4668 the parameters to A, and OUTER_ARGS contains A. */
4671 coerce_template_template_parms (tree parm_parms,
4673 tsubst_flags_t complain,
4677 int nparms, nargs, i;
4680 gcc_assert (TREE_CODE (parm_parms) == TREE_VEC);
4681 gcc_assert (TREE_CODE (arg_parms) == TREE_VEC);
4683 nparms = TREE_VEC_LENGTH (parm_parms);
4684 nargs = TREE_VEC_LENGTH (arg_parms);
4686 if (nargs != nparms)
4689 for (i = 0; i < nparms; ++i)
4691 if (TREE_VEC_ELT (parm_parms, i) == error_mark_node
4692 || TREE_VEC_ELT (arg_parms, i) == error_mark_node)
4695 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
4696 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
4698 if (arg == NULL_TREE || arg == error_mark_node
4699 || parm == NULL_TREE || parm == error_mark_node)
4702 if (TREE_CODE (arg) != TREE_CODE (parm))
4705 switch (TREE_CODE (parm))
4708 /* We encounter instantiations of templates like
4709 template <template <template <class> class> class TT>
4712 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
4713 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
4715 if (!coerce_template_template_parms
4716 (parmparm, argparm, complain, in_decl, outer_args))
4722 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm))
4723 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg)))
4724 /* One is a parameter pack, the other is not. */
4729 /* The tsubst call is used to handle cases such as
4731 template <int> class C {};
4732 template <class T, template <T> class TT> class D {};
4735 i.e. the parameter list of TT depends on earlier parameters. */
4736 if (!dependent_type_p (TREE_TYPE (arg))
4738 (tsubst (TREE_TYPE (parm), outer_args, complain, in_decl),
4742 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm))
4743 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg)))
4744 /* One is a parameter pack, the other is not. */
4755 /* Verifies that the deduced template arguments (in TARGS) for the
4756 template template parameters (in TPARMS) represent valid bindings,
4757 by comparing the template parameter list of each template argument
4758 to the template parameter list of its corresponding template
4759 template parameter, in accordance with DR150. This
4760 routine can only be called after all template arguments have been
4761 deduced. It will return TRUE if all of the template template
4762 parameter bindings are okay, FALSE otherwise. */
4764 template_template_parm_bindings_ok_p (tree tparms, tree targs)
4766 int i, ntparms = TREE_VEC_LENGTH (tparms);
4768 targs = INNERMOST_TEMPLATE_ARGS (targs);
4770 for (i = 0; i < ntparms; ++i)
4772 tree tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
4773 tree targ = TREE_VEC_ELT (targs, i);
4775 if (TREE_CODE (tparm) == TEMPLATE_DECL && targ)
4777 tree packed_args = NULL_TREE;
4780 if (ARGUMENT_PACK_P (targ))
4782 /* Look inside the argument pack. */
4783 packed_args = ARGUMENT_PACK_ARGS (targ);
4784 len = TREE_VEC_LENGTH (packed_args);
4787 for (idx = 0; idx < len; ++idx)
4789 tree targ_parms = NULL_TREE;
4792 /* Extract the next argument from the argument
4794 targ = TREE_VEC_ELT (packed_args, idx);
4796 if (PACK_EXPANSION_P (targ))
4797 /* Look at the pattern of the pack expansion. */
4798 targ = PACK_EXPANSION_PATTERN (targ);
4800 /* Extract the template parameters from the template
4802 if (TREE_CODE (targ) == TEMPLATE_DECL)
4803 targ_parms = DECL_INNERMOST_TEMPLATE_PARMS (targ);
4804 else if (TREE_CODE (targ) == TEMPLATE_TEMPLATE_PARM)
4805 targ_parms = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ));
4807 /* Verify that we can coerce the template template
4808 parameters from the template argument to the template
4809 parameter. This requires an exact match. */
4811 && !coerce_template_template_parms
4812 (DECL_INNERMOST_TEMPLATE_PARMS (tparm),
4822 /* Everything is okay. */
4826 /* Convert the indicated template ARG as necessary to match the
4827 indicated template PARM. Returns the converted ARG, or
4828 error_mark_node if the conversion was unsuccessful. Error and
4829 warning messages are issued under control of COMPLAIN. This
4830 conversion is for the Ith parameter in the parameter list. ARGS is
4831 the full set of template arguments deduced so far. */
4834 convert_template_argument (tree parm,
4837 tsubst_flags_t complain,
4843 int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
4845 if (TREE_CODE (arg) == TREE_LIST
4846 && TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF)
4848 /* The template argument was the name of some
4849 member function. That's usually
4850 invalid, but static members are OK. In any
4851 case, grab the underlying fields/functions
4852 and issue an error later if required. */
4853 orig_arg = TREE_VALUE (arg);
4854 TREE_TYPE (arg) = unknown_type_node;
4859 requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
4860 requires_type = (TREE_CODE (parm) == TYPE_DECL
4861 || requires_tmpl_type);
4863 /* When determining whether an argument pack expansion is a template,
4864 look at the pattern. */
4865 if (TREE_CODE (arg) == TYPE_PACK_EXPANSION)
4866 arg = PACK_EXPANSION_PATTERN (arg);
4869 ((TREE_CODE (arg) == TEMPLATE_DECL
4870 && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
4871 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4872 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
4875 && (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4876 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE))
4877 arg = TYPE_STUB_DECL (arg);
4879 is_type = TYPE_P (arg) || is_tmpl_type;
4881 if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
4882 && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
4884 pedwarn ("to refer to a type member of a template parameter, "
4885 "use %<typename %E%>", orig_arg);
4887 orig_arg = make_typename_type (TREE_OPERAND (arg, 0),
4888 TREE_OPERAND (arg, 1),
4890 complain & tf_error);
4894 if (is_type != requires_type)
4898 if (complain & tf_error)
4900 error ("type/value mismatch at argument %d in template "
4901 "parameter list for %qD",
4904 error (" expected a constant of type %qT, got %qT",
4906 (DECL_P (arg) ? DECL_NAME (arg) : orig_arg));
4907 else if (requires_tmpl_type)
4908 error (" expected a class template, got %qE", orig_arg);
4910 error (" expected a type, got %qE", orig_arg);
4913 return error_mark_node;
4915 if (is_tmpl_type ^ requires_tmpl_type)
4917 if (in_decl && (complain & tf_error))
4919 error ("type/value mismatch at argument %d in template "
4920 "parameter list for %qD",
4923 error (" expected a type, got %qT", DECL_NAME (arg));
4925 error (" expected a class template, got %qT", orig_arg);
4927 return error_mark_node;
4932 if (requires_tmpl_type)
4934 if (TREE_CODE (TREE_TYPE (arg)) == UNBOUND_CLASS_TEMPLATE)
4935 /* The number of argument required is not known yet.
4936 Just accept it for now. */
4937 val = TREE_TYPE (arg);
4940 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
4943 argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
4945 if (coerce_template_template_parms (parmparm, argparm,
4951 /* TEMPLATE_TEMPLATE_PARM node is preferred over
4953 if (val != error_mark_node)
4955 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val))
4956 val = TREE_TYPE (val);
4957 else if (TREE_CODE (val) == TYPE_PACK_EXPANSION
4958 && DECL_TEMPLATE_TEMPLATE_PARM_P (arg))
4960 val = TREE_TYPE (arg);
4961 val = make_pack_expansion (val);
4967 if (in_decl && (complain & tf_error))
4969 error ("type/value mismatch at argument %d in "
4970 "template parameter list for %qD",
4972 error (" expected a template of type %qD, got %qD",
4976 val = error_mark_node;
4982 /* We only form one instance of each template specialization.
4983 Therefore, if we use a non-canonical variant (i.e., a
4984 typedef), any future messages referring to the type will use
4985 the typedef, which is confusing if those future uses do not
4986 themselves also use the typedef. */
4988 val = canonical_type_variant (val);
4992 tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl);
4994 if (invalid_nontype_parm_type_p (t, complain))
4995 return error_mark_node;
4997 if (!uses_template_parms (orig_arg) && !uses_template_parms (t))
4998 /* We used to call digest_init here. However, digest_init
4999 will report errors, which we don't want when complain
5000 is zero. More importantly, digest_init will try too
5001 hard to convert things: for example, `0' should not be
5002 converted to pointer type at this point according to
5003 the standard. Accepting this is not merely an
5004 extension, since deciding whether or not these
5005 conversions can occur is part of determining which
5006 function template to call, or whether a given explicit
5007 argument specification is valid. */
5008 val = convert_nontype_argument (t, orig_arg);
5012 if (val == NULL_TREE)
5013 val = error_mark_node;
5014 else if (val == error_mark_node && (complain & tf_error))
5015 error ("could not convert template argument %qE to %qT", orig_arg, t);
5021 /* Coerces the remaining template arguments in INNER_ARGS (from
5022 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
5023 Returns the coerced argument pack. PARM_IDX is the position of this
5024 parameter in the template parameter list. ARGS is the original
5025 template argument list. */
5027 coerce_template_parameter_pack (tree parms,
5035 tsubst_flags_t complain)
5037 tree parm = TREE_VEC_ELT (parms, parm_idx);
5038 int nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
5041 tree packed_types = NULL_TREE;
5043 if (arg_idx > nargs)
5046 packed_args = make_tree_vec (nargs - arg_idx);
5048 if (TREE_CODE (TREE_VALUE (parm)) == PARM_DECL
5049 && uses_parameter_packs (TREE_TYPE (TREE_VALUE (parm))))
5051 /* When the template parameter is a non-type template
5052 parameter pack whose type uses parameter packs, we need
5053 to look at each of the template arguments
5054 separately. Build a vector of the types for these
5055 non-type template parameters in PACKED_TYPES. */
5057 = make_pack_expansion (TREE_TYPE (TREE_VALUE (parm)));
5058 packed_types = tsubst_pack_expansion (expansion, args,
5061 if (packed_types == error_mark_node)
5062 return error_mark_node;
5064 /* Check that we have the right number of arguments. */
5066 && !PACK_EXPANSION_P (TREE_VEC_ELT (inner_args, arg_idx))
5067 && nargs - arg_idx != TREE_VEC_LENGTH (packed_types))
5070 = TREE_VEC_LENGTH (parms) - 1 + TREE_VEC_LENGTH (packed_types);
5071 error ("wrong number of template arguments (%d, should be %d)",
5072 nargs, needed_parms);
5073 return error_mark_node;
5076 /* If we aren't able to check the actual arguments now
5077 (because they haven't been expanded yet), we can at least
5078 verify that all of the types used for the non-type
5079 template parameter pack are, in fact, valid for non-type
5080 template parameters. */
5082 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args, arg_idx)))
5084 int j, len = TREE_VEC_LENGTH (packed_types);
5085 for (j = 0; j < len; ++j)
5087 tree t = TREE_VEC_ELT (packed_types, j);
5088 if (invalid_nontype_parm_type_p (t, complain))
5089 return error_mark_node;
5094 /* Convert the remaining arguments, which will be a part of the
5095 parameter pack "parm". */
5096 for (; arg_idx < nargs; ++arg_idx)
5098 tree arg = TREE_VEC_ELT (inner_args, arg_idx);
5099 tree actual_parm = TREE_VALUE (parm);
5101 if (packed_types && !PACK_EXPANSION_P (arg))
5103 /* When we have a vector of types (corresponding to the
5104 non-type template parameter pack that uses parameter
5105 packs in its type, as mention above), and the
5106 argument is not an expansion (which expands to a
5107 currently unknown number of arguments), clone the
5108 parm and give it the next type in PACKED_TYPES. */
5109 actual_parm = copy_node (actual_parm);
5110 TREE_TYPE (actual_parm) =
5111 TREE_VEC_ELT (packed_types, arg_idx - parm_idx);
5114 if (arg != error_mark_node)
5115 arg = convert_template_argument (actual_parm,
5116 arg, new_args, complain, parm_idx,
5118 if (arg == error_mark_node)
5120 TREE_VEC_ELT (packed_args, arg_idx - parm_idx) = arg;
5123 if (TREE_CODE (TREE_VALUE (parm)) == TYPE_DECL
5124 || TREE_CODE (TREE_VALUE (parm)) == TEMPLATE_DECL)
5125 argument_pack = make_node (TYPE_ARGUMENT_PACK);
5128 argument_pack = make_node (NONTYPE_ARGUMENT_PACK);
5129 TREE_TYPE (argument_pack)
5130 = tsubst (TREE_TYPE (TREE_VALUE (parm)), args, complain, in_decl);
5131 TREE_CONSTANT (argument_pack) = 1;
5134 SET_ARGUMENT_PACK_ARGS (argument_pack, packed_args);
5135 return argument_pack;
5138 /* Convert all template arguments to their appropriate types, and
5139 return a vector containing the innermost resulting template
5140 arguments. If any error occurs, return error_mark_node. Error and
5141 warning messages are issued under control of COMPLAIN.
5143 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
5144 for arguments not specified in ARGS. Otherwise, if
5145 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
5146 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
5147 USE_DEFAULT_ARGS is false, then all arguments must be specified in
5151 coerce_template_parms (tree parms,
5154 tsubst_flags_t complain,
5155 bool require_all_args,
5156 bool use_default_args)
5158 int nparms, nargs, parm_idx, arg_idx, lost = 0;
5161 tree new_inner_args;
5162 bool saved_skip_evaluation;
5164 /* When used as a boolean value, indicates whether this is a
5165 variadic template parameter list. Since it's an int, we can also
5166 subtract it from nparms to get the number of non-variadic
5171 = expand_template_argument_pack (INNERMOST_TEMPLATE_ARGS (args));
5173 nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
5174 nparms = TREE_VEC_LENGTH (parms);
5176 /* Determine if there are any parameter packs. */
5177 for (parm_idx = 0; parm_idx < nparms; ++parm_idx)
5179 tree tparm = TREE_VALUE (TREE_VEC_ELT (parms, parm_idx));
5180 if (template_parameter_pack_p (tparm))
5187 if ((nargs > nparms - variadic_p && !variadic_p)
5188 || (nargs < nparms - variadic_p
5190 && (!use_default_args
5191 || (TREE_VEC_ELT (parms, nargs) != error_mark_node
5192 && !TREE_PURPOSE (TREE_VEC_ELT (parms, nargs))))))
5194 if (complain & tf_error)
5196 const char *or_more = "";
5199 or_more = " or more";
5203 error ("wrong number of template arguments (%d, should be %d%s)",
5204 nargs, nparms, or_more);
5207 error ("provided for %q+D", in_decl);
5210 return error_mark_node;
5213 /* We need to evaluate the template arguments, even though this
5214 template-id may be nested within a "sizeof". */
5215 saved_skip_evaluation = skip_evaluation;
5216 skip_evaluation = false;
5217 new_inner_args = make_tree_vec (nparms);
5218 new_args = add_outermost_template_args (args, new_inner_args);
5219 for (parm_idx = 0, arg_idx = 0; parm_idx < nparms; parm_idx++, arg_idx++)
5224 /* Get the Ith template parameter. */
5225 parm = TREE_VEC_ELT (parms, parm_idx);
5227 if (parm == error_mark_node)
5229 TREE_VEC_ELT (new_inner_args, arg_idx) = error_mark_node;
5233 /* Calculate the next argument. */
5234 if (template_parameter_pack_p (TREE_VALUE (parm)))
5236 /* All remaining arguments will be placed in the
5237 template parameter pack PARM. */
5238 arg = coerce_template_parameter_pack (parms, parm_idx, args,
5239 inner_args, arg_idx,
5243 /* Store this argument. */
5244 if (arg == error_mark_node)
5246 TREE_VEC_ELT (new_inner_args, parm_idx) = arg;
5248 /* We are done with all of the arguments. */
5253 else if (arg_idx < nargs)
5255 arg = TREE_VEC_ELT (inner_args, arg_idx);
5257 if (arg && PACK_EXPANSION_P (arg))
5259 if (complain & tf_error)
5261 /* If ARG is a pack expansion, but PARM is not a
5262 template parameter pack (if it were, we would have
5263 handled it above), we're trying to expand into a
5264 fixed-length argument list. */
5265 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
5266 error ("cannot expand %<%E%> into a fixed-length "
5267 "argument list", arg);
5269 error ("cannot expand %<%T%> into a fixed-length "
5270 "argument list", arg);
5272 return error_mark_node;
5275 else if (require_all_args)
5276 /* There must be a default arg in this case. */
5277 arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
5282 if (arg == error_mark_node)
5284 if (complain & tf_error)
5285 error ("template argument %d is invalid", arg_idx + 1);
5288 /* This only occurs if there was an error in the template
5289 parameter list itself (which we would already have
5290 reported) that we are trying to recover from, e.g., a class
5291 template with a parameter list such as
5292 template<typename..., typename>. */
5293 return error_mark_node;
5295 arg = convert_template_argument (TREE_VALUE (parm),
5296 arg, new_args, complain,
5299 if (arg == error_mark_node)
5301 TREE_VEC_ELT (new_inner_args, arg_idx) = arg;
5303 skip_evaluation = saved_skip_evaluation;
5306 return error_mark_node;
5308 return new_inner_args;
5311 /* Returns 1 if template args OT and NT are equivalent. */
5314 template_args_equal (tree ot, tree nt)
5319 if (TREE_CODE (nt) == TREE_VEC)
5320 /* For member templates */
5321 return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt);
5322 else if (PACK_EXPANSION_P (ot))
5323 return PACK_EXPANSION_P (nt)
5324 && template_args_equal (PACK_EXPANSION_PATTERN (ot),
5325 PACK_EXPANSION_PATTERN (nt));
5326 else if (TYPE_P (nt))
5327 return TYPE_P (ot) && same_type_p (ot, nt);
5328 else if (TREE_CODE (ot) == TREE_VEC || TYPE_P (ot))
5331 return cp_tree_equal (ot, nt);
5334 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
5335 of template arguments. Returns 0 otherwise. */
5338 comp_template_args (tree oldargs, tree newargs)
5342 oldargs = expand_template_argument_pack (oldargs);
5343 newargs = expand_template_argument_pack (newargs);
5345 if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
5348 for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
5350 tree nt = TREE_VEC_ELT (newargs, i);
5351 tree ot = TREE_VEC_ELT (oldargs, i);
5353 if (! template_args_equal (ot, nt))
5360 add_pending_template (tree d)
5362 tree ti = (TYPE_P (d)
5363 ? CLASSTYPE_TEMPLATE_INFO (d)
5364 : DECL_TEMPLATE_INFO (d));
5365 struct pending_template *pt;
5368 if (TI_PENDING_TEMPLATE_FLAG (ti))
5371 /* We are called both from instantiate_decl, where we've already had a
5372 tinst_level pushed, and instantiate_template, where we haven't.
5374 level = !current_tinst_level || current_tinst_level->decl != d;
5377 push_tinst_level (d);
5379 pt = GGC_NEW (struct pending_template);
5381 pt->tinst = current_tinst_level;
5382 if (last_pending_template)
5383 last_pending_template->next = pt;
5385 pending_templates = pt;
5387 last_pending_template = pt;
5389 TI_PENDING_TEMPLATE_FLAG (ti) = 1;
5396 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
5397 ARGLIST. Valid choices for FNS are given in the cp-tree.def
5398 documentation for TEMPLATE_ID_EXPR. */
5401 lookup_template_function (tree fns, tree arglist)
5405 if (fns == error_mark_node || arglist == error_mark_node)
5406 return error_mark_node;
5408 gcc_assert (!arglist || TREE_CODE (arglist) == TREE_VEC);
5409 gcc_assert (fns && (is_overloaded_fn (fns)
5410 || TREE_CODE (fns) == IDENTIFIER_NODE));
5412 if (BASELINK_P (fns))
5414 BASELINK_FUNCTIONS (fns) = build2 (TEMPLATE_ID_EXPR,
5416 BASELINK_FUNCTIONS (fns),
5421 type = TREE_TYPE (fns);
5422 if (TREE_CODE (fns) == OVERLOAD || !type)
5423 type = unknown_type_node;
5425 return build2 (TEMPLATE_ID_EXPR, type, fns, arglist);
5428 /* Within the scope of a template class S<T>, the name S gets bound
5429 (in build_self_reference) to a TYPE_DECL for the class, not a
5430 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
5431 or one of its enclosing classes, and that type is a template,
5432 return the associated TEMPLATE_DECL. Otherwise, the original
5433 DECL is returned. */
5436 maybe_get_template_decl_from_type_decl (tree decl)
5438 return (decl != NULL_TREE
5439 && TREE_CODE (decl) == TYPE_DECL
5440 && DECL_ARTIFICIAL (decl)
5441 && CLASS_TYPE_P (TREE_TYPE (decl))
5442 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
5443 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl;
5446 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
5447 parameters, find the desired type.
5449 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
5451 IN_DECL, if non-NULL, is the template declaration we are trying to
5454 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
5455 the class we are looking up.
5457 Issue error and warning messages under control of COMPLAIN.
5459 If the template class is really a local class in a template
5460 function, then the FUNCTION_CONTEXT is the function in which it is
5463 ??? Note that this function is currently called *twice* for each
5464 template-id: the first time from the parser, while creating the
5465 incomplete type (finish_template_type), and the second type during the
5466 real instantiation (instantiate_template_class). This is surely something
5467 that we want to avoid. It also causes some problems with argument
5468 coercion (see convert_nontype_argument for more information on this). */
5471 lookup_template_class (tree d1,
5476 tsubst_flags_t complain)
5478 tree template = NULL_TREE, parmlist;
5481 timevar_push (TV_NAME_LOOKUP);
5483 if (TREE_CODE (d1) == IDENTIFIER_NODE)
5485 tree value = innermost_non_namespace_value (d1);
5486 if (value && DECL_TEMPLATE_TEMPLATE_PARM_P (value))
5491 push_decl_namespace (context);
5492 template = lookup_name (d1);
5493 template = maybe_get_template_decl_from_type_decl (template);
5495 pop_decl_namespace ();
5498 context = DECL_CONTEXT (template);
5500 else if (TREE_CODE (d1) == TYPE_DECL && IS_AGGR_TYPE (TREE_TYPE (d1)))
5502 tree type = TREE_TYPE (d1);
5504 /* If we are declaring a constructor, say A<T>::A<T>, we will get
5505 an implicit typename for the second A. Deal with it. */
5506 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5507 type = TREE_TYPE (type);
5509 if (CLASSTYPE_TEMPLATE_INFO (type))
5511 template = CLASSTYPE_TI_TEMPLATE (type);
5512 d1 = DECL_NAME (template);
5515 else if (TREE_CODE (d1) == ENUMERAL_TYPE
5516 || (TYPE_P (d1) && IS_AGGR_TYPE (d1)))
5518 template = TYPE_TI_TEMPLATE (d1);
5519 d1 = DECL_NAME (template);
5521 else if (TREE_CODE (d1) == TEMPLATE_DECL
5522 && TREE_CODE (DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL)
5525 d1 = DECL_NAME (template);
5526 context = DECL_CONTEXT (template);
5529 /* Issue an error message if we didn't find a template. */
5532 if (complain & tf_error)
5533 error ("%qT is not a template", d1);
5534 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5537 if (TREE_CODE (template) != TEMPLATE_DECL
5538 /* Make sure it's a user visible template, if it was named by
5540 || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (template)
5541 && !PRIMARY_TEMPLATE_P (template)))
5543 if (complain & tf_error)
5545 error ("non-template type %qT used as a template", d1);
5547 error ("for template declaration %q+D", in_decl);
5549 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5552 complain &= ~tf_user;
5554 if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
5556 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
5557 template arguments */
5563 parmlist = DECL_INNERMOST_TEMPLATE_PARMS (template);
5565 /* Consider an example where a template template parameter declared as
5567 template <class T, class U = std::allocator<T> > class TT
5569 The template parameter level of T and U are one level larger than
5570 of TT. To proper process the default argument of U, say when an
5571 instantiation `TT<int>' is seen, we need to build the full
5572 arguments containing {int} as the innermost level. Outer levels,
5573 available when not appearing as default template argument, can be
5574 obtained from the arguments of the enclosing template.
5576 Suppose that TT is later substituted with std::vector. The above
5577 instantiation is `TT<int, std::allocator<T> >' with TT at
5578 level 1, and T at level 2, while the template arguments at level 1
5579 becomes {std::vector} and the inner level 2 is {int}. */
5581 outer = DECL_CONTEXT (template);
5583 outer = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer)));
5584 else if (current_template_parms)
5585 /* This is an argument of the current template, so we haven't set
5586 DECL_CONTEXT yet. */
5587 outer = current_template_args ();
5590 arglist = add_to_template_args (outer, arglist);
5592 arglist2 = coerce_template_parms (parmlist, arglist, template,
5594 /*require_all_args=*/true,
5595 /*use_default_args=*/true);
5596 if (arglist2 == error_mark_node
5597 || (!uses_template_parms (arglist2)
5598 && check_instantiated_args (template, arglist2, complain)))
5599 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5601 parm = bind_template_template_parm (TREE_TYPE (template), arglist2);
5602 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, parm);
5606 tree template_type = TREE_TYPE (template);
5609 tree found = NULL_TREE;
5612 int is_partial_instantiation;
5614 gen_tmpl = most_general_template (template);
5615 parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
5616 parm_depth = TMPL_PARMS_DEPTH (parmlist);
5617 arg_depth = TMPL_ARGS_DEPTH (arglist);
5619 if (arg_depth == 1 && parm_depth > 1)
5621 /* We've been given an incomplete set of template arguments.
5624 template <class T> struct S1 {
5625 template <class U> struct S2 {};
5626 template <class U> struct S2<U*> {};
5629 we will be called with an ARGLIST of `U*', but the
5630 TEMPLATE will be `template <class T> template
5631 <class U> struct S1<T>::S2'. We must fill in the missing
5634 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)),
5636 arg_depth = TMPL_ARGS_DEPTH (arglist);
5639 /* Now we should have enough arguments. */
5640 gcc_assert (parm_depth == arg_depth);
5642 /* From here on, we're only interested in the most general
5644 template = gen_tmpl;
5646 /* Calculate the BOUND_ARGS. These will be the args that are
5647 actually tsubst'd into the definition to create the
5651 /* We have multiple levels of arguments to coerce, at once. */
5653 int saved_depth = TMPL_ARGS_DEPTH (arglist);
5655 tree bound_args = make_tree_vec (parm_depth);
5657 for (i = saved_depth,
5658 t = DECL_TEMPLATE_PARMS (template);
5659 i > 0 && t != NULL_TREE;
5660 --i, t = TREE_CHAIN (t))
5662 tree a = coerce_template_parms (TREE_VALUE (t),
5665 /*require_all_args=*/true,
5666 /*use_default_args=*/true);
5668 /* Don't process further if one of the levels fails. */
5669 if (a == error_mark_node)
5671 /* Restore the ARGLIST to its full size. */
5672 TREE_VEC_LENGTH (arglist) = saved_depth;
5673 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5676 SET_TMPL_ARGS_LEVEL (bound_args, i, a);
5678 /* We temporarily reduce the length of the ARGLIST so
5679 that coerce_template_parms will see only the arguments
5680 corresponding to the template parameters it is
5682 TREE_VEC_LENGTH (arglist)--;
5685 /* Restore the ARGLIST to its full size. */
5686 TREE_VEC_LENGTH (arglist) = saved_depth;
5688 arglist = bound_args;
5692 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist),
5693 INNERMOST_TEMPLATE_ARGS (arglist),
5696 /*require_all_args=*/true,
5697 /*use_default_args=*/true);
5699 if (arglist == error_mark_node)
5700 /* We were unable to bind the arguments. */
5701 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5703 /* In the scope of a template class, explicit references to the
5704 template class refer to the type of the template, not any
5705 instantiation of it. For example, in:
5707 template <class T> class C { void f(C<T>); }
5709 the `C<T>' is just the same as `C'. Outside of the
5710 class, however, such a reference is an instantiation. */
5711 if (comp_template_args (TYPE_TI_ARGS (template_type),
5714 found = template_type;
5716 if (!entering_scope && PRIMARY_TEMPLATE_P (template))
5720 for (ctx = current_class_type;
5721 ctx && TREE_CODE (ctx) != NAMESPACE_DECL;
5723 ? TYPE_CONTEXT (ctx)
5724 : DECL_CONTEXT (ctx)))
5725 if (TYPE_P (ctx) && same_type_p (ctx, template_type))
5728 /* We're not in the scope of the class, so the
5729 TEMPLATE_TYPE is not the type we want after all. */
5735 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
5737 /* If we already have this specialization, return it. */
5738 found = retrieve_specialization (template, arglist,
5739 /*class_specializations_p=*/false);
5741 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
5743 /* This type is a "partial instantiation" if any of the template
5744 arguments still involve template parameters. Note that we set
5745 IS_PARTIAL_INSTANTIATION for partial specializations as
5747 is_partial_instantiation = uses_template_parms (arglist);
5749 /* If the deduced arguments are invalid, then the binding
5751 if (!is_partial_instantiation
5752 && check_instantiated_args (template,
5753 INNERMOST_TEMPLATE_ARGS (arglist),
5755 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5757 if (!is_partial_instantiation
5758 && !PRIMARY_TEMPLATE_P (template)
5759 && TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL)
5761 found = xref_tag_from_type (TREE_TYPE (template),
5762 DECL_NAME (template),
5763 /*tag_scope=*/ts_global);
5764 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
5767 context = tsubst (DECL_CONTEXT (template), arglist,
5770 context = global_namespace;
5772 /* Create the type. */
5773 if (TREE_CODE (template_type) == ENUMERAL_TYPE)
5775 if (!is_partial_instantiation)
5777 set_current_access_from_decl (TYPE_NAME (template_type));
5778 t = start_enum (TYPE_IDENTIFIER (template_type));
5781 /* We don't want to call start_enum for this type, since
5782 the values for the enumeration constants may involve
5783 template parameters. And, no one should be interested
5784 in the enumeration constants for such a type. */
5785 t = make_node (ENUMERAL_TYPE);
5789 t = make_aggr_type (TREE_CODE (template_type));
5790 CLASSTYPE_DECLARED_CLASS (t)
5791 = CLASSTYPE_DECLARED_CLASS (template_type);
5792 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
5793 TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);
5795 /* A local class. Make sure the decl gets registered properly. */
5796 if (context == current_function_decl)
5797 pushtag (DECL_NAME (template), t, /*tag_scope=*/ts_current);
5799 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type), arglist))
5800 /* This instantiation is another name for the primary
5801 template type. Set the TYPE_CANONICAL field
5803 TYPE_CANONICAL (t) = template_type;
5804 else if (any_template_arguments_need_structural_equality_p (arglist))
5805 /* Some of the template arguments require structural
5806 equality testing, so this template class requires
5807 structural equality testing. */
5808 SET_TYPE_STRUCTURAL_EQUALITY (t);
5811 /* If we called start_enum or pushtag above, this information
5812 will already be set up. */
5815 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5817 type_decl = create_implicit_typedef (DECL_NAME (template), t);
5818 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
5819 TYPE_STUB_DECL (t) = type_decl;
5820 DECL_SOURCE_LOCATION (type_decl)
5821 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type));
5824 type_decl = TYPE_NAME (t);
5826 TREE_PRIVATE (type_decl)
5827 = TREE_PRIVATE (TYPE_STUB_DECL (template_type));
5828 TREE_PROTECTED (type_decl)
5829 = TREE_PROTECTED (TYPE_STUB_DECL (template_type));
5830 DECL_IN_SYSTEM_HEADER (type_decl)
5831 = DECL_IN_SYSTEM_HEADER (template);
5832 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type))
5834 DECL_VISIBILITY_SPECIFIED (type_decl) = 1;
5835 DECL_VISIBILITY (type_decl) = CLASSTYPE_VISIBILITY (template_type);
5838 /* Set up the template information. We have to figure out which
5839 template is the immediate parent if this is a full
5841 if (parm_depth == 1 || is_partial_instantiation
5842 || !PRIMARY_TEMPLATE_P (template))
5843 /* This case is easy; there are no member templates involved. */
5847 /* This is a full instantiation of a member template. Look
5848 for a partial instantiation of which this is an instance. */
5850 for (found = DECL_TEMPLATE_INSTANTIATIONS (template);
5851 found; found = TREE_CHAIN (found))
5854 tree tmpl = CLASSTYPE_TI_TEMPLATE (TREE_VALUE (found));
5856 /* We only want partial instantiations, here, not
5857 specializations or full instantiations. */
5858 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_VALUE (found))
5859 || !uses_template_parms (TREE_VALUE (found)))
5862 /* Temporarily reduce by one the number of levels in the
5863 ARGLIST and in FOUND so as to avoid comparing the
5864 last set of arguments. */
5865 TREE_VEC_LENGTH (arglist)--;
5866 TREE_VEC_LENGTH (TREE_PURPOSE (found)) --;
5868 /* See if the arguments match. If they do, then TMPL is
5869 the partial instantiation we want. */
5870 success = comp_template_args (TREE_PURPOSE (found), arglist);
5872 /* Restore the argument vectors to their full size. */
5873 TREE_VEC_LENGTH (arglist)++;
5874 TREE_VEC_LENGTH (TREE_PURPOSE (found))++;
5885 /* There was no partial instantiation. This happens
5886 where C<T> is a member template of A<T> and it's used
5889 template <typename T> struct B { A<T>::C<int> m; };
5892 Create the partial instantiation.
5894 TREE_VEC_LENGTH (arglist)--;
5895 found = tsubst (template, arglist, complain, NULL_TREE);
5896 TREE_VEC_LENGTH (arglist)++;
5900 SET_TYPE_TEMPLATE_INFO (t, tree_cons (found, arglist, NULL_TREE));
5901 DECL_TEMPLATE_INSTANTIATIONS (template)
5902 = tree_cons (arglist, t,
5903 DECL_TEMPLATE_INSTANTIATIONS (template));
5905 if (TREE_CODE (t) == ENUMERAL_TYPE
5906 && !is_partial_instantiation)
5907 /* Now that the type has been registered on the instantiations
5908 list, we set up the enumerators. Because the enumeration
5909 constants may involve the enumeration type itself, we make
5910 sure to register the type first, and then create the
5911 constants. That way, doing tsubst_expr for the enumeration
5912 constants won't result in recursive calls here; we'll find
5913 the instantiation and exit above. */
5914 tsubst_enum (template_type, t, arglist);
5916 if (is_partial_instantiation)
5917 /* If the type makes use of template parameters, the
5918 code that generates debugging information will crash. */
5919 DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1;
5921 /* Possibly limit visibility based on template args. */
5922 TREE_PUBLIC (type_decl) = 1;
5923 determine_visibility (type_decl);
5925 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
5927 timevar_pop (TV_NAME_LOOKUP);
5934 /* True when we should also visit template parameters that occur in
5935 non-deduced contexts. */
5936 bool include_nondeduced_p;
5937 struct pointer_set_t *visited;
5940 /* Called from for_each_template_parm via walk_tree. */
5943 for_each_template_parm_r (tree *tp, int *walk_subtrees, void *d)
5946 struct pair_fn_data *pfd = (struct pair_fn_data *) d;
5947 tree_fn_t fn = pfd->fn;
5948 void *data = pfd->data;
5951 && (pfd->include_nondeduced_p || TREE_CODE (t) != TYPENAME_TYPE)
5952 && for_each_template_parm (TYPE_CONTEXT (t), fn, data, pfd->visited,
5953 pfd->include_nondeduced_p))
5954 return error_mark_node;
5956 switch (TREE_CODE (t))
5959 if (TYPE_PTRMEMFUNC_P (t))
5965 if (!TYPE_TEMPLATE_INFO (t))
5967 else if (for_each_template_parm (TREE_VALUE (TYPE_TEMPLATE_INFO (t)),
5968 fn, data, pfd->visited,
5969 pfd->include_nondeduced_p))
5970 return error_mark_node;
5974 if (for_each_template_parm (TYPE_MIN_VALUE (t),
5975 fn, data, pfd->visited,
5976 pfd->include_nondeduced_p)
5977 || for_each_template_parm (TYPE_MAX_VALUE (t),
5978 fn, data, pfd->visited,
5979 pfd->include_nondeduced_p))
5980 return error_mark_node;
5984 /* Since we're not going to walk subtrees, we have to do this
5986 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data,
5987 pfd->visited, pfd->include_nondeduced_p))
5988 return error_mark_node;
5992 /* Check the return type. */
5993 if (for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited,
5994 pfd->include_nondeduced_p))
5995 return error_mark_node;
5997 /* Check the parameter types. Since default arguments are not
5998 instantiated until they are needed, the TYPE_ARG_TYPES may
5999 contain expressions that involve template parameters. But,
6000 no-one should be looking at them yet. And, once they're
6001 instantiated, they don't contain template parameters, so
6002 there's no point in looking at them then, either. */
6006 for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm))
6007 if (for_each_template_parm (TREE_VALUE (parm), fn, data,
6008 pfd->visited, pfd->include_nondeduced_p))
6009 return error_mark_node;
6011 /* Since we've already handled the TYPE_ARG_TYPES, we don't
6012 want walk_tree walking into them itself. */
6018 if (pfd->include_nondeduced_p
6019 && for_each_template_parm (TYPE_FIELDS (t), fn, data,
6021 pfd->include_nondeduced_p))
6022 return error_mark_node;
6027 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
6028 && for_each_template_parm (DECL_TI_ARGS (t), fn, data,
6029 pfd->visited, pfd->include_nondeduced_p))
6030 return error_mark_node;
6035 if (TREE_CODE (t) == CONST_DECL && DECL_TEMPLATE_PARM_P (t)
6036 && for_each_template_parm (DECL_INITIAL (t), fn, data,
6037 pfd->visited, pfd->include_nondeduced_p))
6038 return error_mark_node;
6039 if (DECL_CONTEXT (t)
6040 && pfd->include_nondeduced_p
6041 && for_each_template_parm (DECL_CONTEXT (t), fn, data,
6042 pfd->visited, pfd->include_nondeduced_p))
6043 return error_mark_node;
6046 case BOUND_TEMPLATE_TEMPLATE_PARM:
6047 /* Record template parameters such as `T' inside `TT<T>'. */
6048 if (for_each_template_parm (TYPE_TI_ARGS (t), fn, data, pfd->visited,
6049 pfd->include_nondeduced_p))
6050 return error_mark_node;
6053 case TEMPLATE_TEMPLATE_PARM:
6054 case TEMPLATE_TYPE_PARM:
6055 case TEMPLATE_PARM_INDEX:
6056 if (fn && (*fn)(t, data))
6057 return error_mark_node;
6059 return error_mark_node;
6063 /* A template template parameter is encountered. */
6064 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)
6065 && for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited,
6066 pfd->include_nondeduced_p))
6067 return error_mark_node;
6069 /* Already substituted template template parameter */
6075 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t), fn,
6077 pfd->include_nondeduced_p))
6078 return error_mark_node;
6082 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))
6083 && pfd->include_nondeduced_p
6084 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
6085 (TREE_TYPE (t)), fn, data,
6086 pfd->visited, pfd->include_nondeduced_p))
6087 return error_mark_node;
6092 /* If there's no type, then this thing must be some expression
6093 involving template parameters. */
6094 if (!fn && !TREE_TYPE (t))
6095 return error_mark_node;
6100 case REINTERPRET_CAST_EXPR:
6101 case CONST_CAST_EXPR:
6102 case STATIC_CAST_EXPR:
6103 case DYNAMIC_CAST_EXPR:
6107 case PSEUDO_DTOR_EXPR:
6109 return error_mark_node;
6116 /* We didn't find any template parameters we liked. */
6120 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
6121 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
6122 call FN with the parameter and the DATA.
6123 If FN returns nonzero, the iteration is terminated, and
6124 for_each_template_parm returns 1. Otherwise, the iteration
6125 continues. If FN never returns a nonzero value, the value
6126 returned by for_each_template_parm is 0. If FN is NULL, it is
6127 considered to be the function which always returns 1.
6129 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
6130 parameters that occur in non-deduced contexts. When false, only
6131 visits those template parameters that can be deduced. */
6134 for_each_template_parm (tree t, tree_fn_t fn, void* data,
6135 struct pointer_set_t *visited,
6136 bool include_nondeduced_p)
6138 struct pair_fn_data pfd;
6144 pfd.include_nondeduced_p = include_nondeduced_p;
6146 /* Walk the tree. (Conceptually, we would like to walk without
6147 duplicates, but for_each_template_parm_r recursively calls
6148 for_each_template_parm, so we would need to reorganize a fair
6149 bit to use walk_tree_without_duplicates, so we keep our own
6152 pfd.visited = visited;
6154 pfd.visited = pointer_set_create ();
6155 result = cp_walk_tree (&t,
6156 for_each_template_parm_r,
6158 pfd.visited) != NULL_TREE;
6163 pointer_set_destroy (pfd.visited);
6170 /* Returns true if T depends on any template parameter. */
6173 uses_template_parms (tree t)
6176 int saved_processing_template_decl;
6178 saved_processing_template_decl = processing_template_decl;
6179 if (!saved_processing_template_decl)
6180 processing_template_decl = 1;
6182 dependent_p = dependent_type_p (t);
6183 else if (TREE_CODE (t) == TREE_VEC)
6184 dependent_p = any_dependent_template_arguments_p (t);
6185 else if (TREE_CODE (t) == TREE_LIST)
6186 dependent_p = (uses_template_parms (TREE_VALUE (t))
6187 || uses_template_parms (TREE_CHAIN (t)));
6188 else if (TREE_CODE (t) == TYPE_DECL)
6189 dependent_p = dependent_type_p (TREE_TYPE (t));
6192 || TREE_CODE (t) == TEMPLATE_PARM_INDEX
6193 || TREE_CODE (t) == OVERLOAD
6194 || TREE_CODE (t) == BASELINK
6195 || TREE_CODE (t) == IDENTIFIER_NODE
6196 || TREE_CODE (t) == TRAIT_EXPR
6197 || CONSTANT_CLASS_P (t))
6198 dependent_p = (type_dependent_expression_p (t)
6199 || value_dependent_expression_p (t));
6202 gcc_assert (t == error_mark_node);
6203 dependent_p = false;
6206 processing_template_decl = saved_processing_template_decl;
6211 /* Returns true if T depends on any template parameter with level LEVEL. */
6214 uses_template_parms_level (tree t, int level)
6216 return for_each_template_parm (t, template_parm_this_level_p, &level, NULL,
6217 /*include_nondeduced_p=*/true);
6220 static int tinst_depth;
6221 extern int max_tinst_depth;
6222 #ifdef GATHER_STATISTICS
6225 static int tinst_level_tick;
6226 static int last_template_error_tick;
6228 /* We're starting to instantiate D; record the template instantiation context
6229 for diagnostics and to restore it later. */
6232 push_tinst_level (tree d)
6234 struct tinst_level *new;
6236 if (tinst_depth >= max_tinst_depth)
6238 /* If the instantiation in question still has unbound template parms,
6239 we don't really care if we can't instantiate it, so just return.
6240 This happens with base instantiation for implicit `typename'. */
6241 if (uses_template_parms (d))
6244 last_template_error_tick = tinst_level_tick;
6245 error ("template instantiation depth exceeds maximum of %d (use "
6246 "-ftemplate-depth-NN to increase the maximum) instantiating %qD",
6247 max_tinst_depth, d);
6249 print_instantiation_context ();
6254 new = GGC_NEW (struct tinst_level);
6256 new->locus = input_location;
6257 new->in_system_header_p = in_system_header;
6258 new->next = current_tinst_level;
6259 current_tinst_level = new;
6262 #ifdef GATHER_STATISTICS
6263 if (tinst_depth > depth_reached)
6264 depth_reached = tinst_depth;
6271 /* We're done instantiating this template; return to the instantiation
6275 pop_tinst_level (void)
6277 /* Restore the filename and line number stashed away when we started
6278 this instantiation. */
6279 input_location = current_tinst_level->locus;
6280 in_system_header = current_tinst_level->in_system_header_p;
6281 current_tinst_level = current_tinst_level->next;
6286 /* We're instantiating a deferred template; restore the template
6287 instantiation context in which the instantiation was requested, which
6288 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
6291 reopen_tinst_level (struct tinst_level *level)
6293 struct tinst_level *t;
6296 for (t = level; t; t = t->next)
6299 current_tinst_level = level;
6304 /* Returns the TINST_LEVEL which gives the original instantiation
6307 struct tinst_level *
6308 outermost_tinst_level (void)
6310 struct tinst_level *level = current_tinst_level;
6313 level = level->next;
6317 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
6318 vector of template arguments, as for tsubst.
6320 Returns an appropriate tsubst'd friend declaration. */
6323 tsubst_friend_function (tree decl, tree args)
6327 if (TREE_CODE (decl) == FUNCTION_DECL
6328 && DECL_TEMPLATE_INSTANTIATION (decl)
6329 && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
6330 /* This was a friend declared with an explicit template
6331 argument list, e.g.:
6335 to indicate that f was a template instantiation, not a new
6336 function declaration. Now, we have to figure out what
6337 instantiation of what template. */
6339 tree template_id, arglist, fns;
6342 tree ns = decl_namespace_context (TYPE_MAIN_DECL (current_class_type));
6344 /* Friend functions are looked up in the containing namespace scope.
6345 We must enter that scope, to avoid finding member functions of the
6346 current cless with same name. */
6347 push_nested_namespace (ns);
6348 fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args,
6349 tf_warning_or_error, NULL_TREE,
6350 /*integral_constant_expression_p=*/false);
6351 pop_nested_namespace (ns);
6352 arglist = tsubst (DECL_TI_ARGS (decl), args,
6353 tf_warning_or_error, NULL_TREE);
6354 template_id = lookup_template_function (fns, arglist);
6356 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
6357 tmpl = determine_specialization (template_id, new_friend,
6359 /*need_member_template=*/0,
6360 TREE_VEC_LENGTH (args),
6362 return instantiate_template (tmpl, new_args, tf_error);
6365 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
6367 /* The NEW_FRIEND will look like an instantiation, to the
6368 compiler, but is not an instantiation from the point of view of
6369 the language. For example, we might have had:
6371 template <class T> struct S {
6372 template <class U> friend void f(T, U);
6375 Then, in S<int>, template <class U> void f(int, U) is not an
6376 instantiation of anything. */
6377 if (new_friend == error_mark_node)
6378 return error_mark_node;
6380 DECL_USE_TEMPLATE (new_friend) = 0;
6381 if (TREE_CODE (decl) == TEMPLATE_DECL)
6383 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0;
6384 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend))
6385 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
6388 /* The mangled name for the NEW_FRIEND is incorrect. The function
6389 is not a template instantiation and should not be mangled like
6390 one. Therefore, we forget the mangling here; we'll recompute it
6391 later if we need it. */
6392 if (TREE_CODE (new_friend) != TEMPLATE_DECL)
6394 SET_DECL_RTL (new_friend, NULL_RTX);
6395 SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE);
6398 if (DECL_NAMESPACE_SCOPE_P (new_friend))
6401 tree new_friend_template_info;
6402 tree new_friend_result_template_info;
6404 int new_friend_is_defn;
6406 /* We must save some information from NEW_FRIEND before calling
6407 duplicate decls since that function will free NEW_FRIEND if
6409 new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
6410 new_friend_is_defn =
6411 (DECL_INITIAL (DECL_TEMPLATE_RESULT
6412 (template_for_substitution (new_friend)))
6414 if (TREE_CODE (new_friend) == TEMPLATE_DECL)
6416 /* This declaration is a `primary' template. */
6417 DECL_PRIMARY_TEMPLATE (new_friend) = new_friend;
6419 new_friend_result_template_info
6420 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend));
6423 new_friend_result_template_info = NULL_TREE;
6425 /* Make the init_value nonzero so pushdecl knows this is a defn. */
6426 if (new_friend_is_defn)
6427 DECL_INITIAL (new_friend) = error_mark_node;
6429 /* Inside pushdecl_namespace_level, we will push into the
6430 current namespace. However, the friend function should go
6431 into the namespace of the template. */
6432 ns = decl_namespace_context (new_friend);
6433 push_nested_namespace (ns);
6434 old_decl = pushdecl_namespace_level (new_friend, /*is_friend=*/true);
6435 pop_nested_namespace (ns);
6437 if (old_decl == error_mark_node)
6438 return error_mark_node;
6440 if (old_decl != new_friend)
6442 /* This new friend declaration matched an existing
6443 declaration. For example, given:
6445 template <class T> void f(T);
6446 template <class U> class C {
6447 template <class T> friend void f(T) {}
6450 the friend declaration actually provides the definition
6451 of `f', once C has been instantiated for some type. So,
6452 old_decl will be the out-of-class template declaration,
6453 while new_friend is the in-class definition.
6455 But, if `f' was called before this point, the
6456 instantiation of `f' will have DECL_TI_ARGS corresponding
6457 to `T' but not to `U', references to which might appear
6458 in the definition of `f'. Previously, the most general
6459 template for an instantiation of `f' was the out-of-class
6460 version; now it is the in-class version. Therefore, we
6461 run through all specialization of `f', adding to their
6462 DECL_TI_ARGS appropriately. In particular, they need a
6463 new set of outer arguments, corresponding to the
6464 arguments for this class instantiation.
6466 The same situation can arise with something like this:
6469 template <class T> class C {
6473 when `C<int>' is instantiated. Now, `f(int)' is defined
6476 if (!new_friend_is_defn)
6477 /* On the other hand, if the in-class declaration does
6478 *not* provide a definition, then we don't want to alter
6479 existing definitions. We can just leave everything
6484 /* Overwrite whatever template info was there before, if
6485 any, with the new template information pertaining to
6487 DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
6489 if (TREE_CODE (old_decl) != TEMPLATE_DECL)
6490 reregister_specialization (new_friend,
6491 most_general_template (old_decl),
6496 tree new_friend_args;
6498 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl))
6499 = new_friend_result_template_info;
6501 new_friend_args = TI_ARGS (new_friend_template_info);
6502 for (t = DECL_TEMPLATE_SPECIALIZATIONS (old_decl);
6506 tree spec = TREE_VALUE (t);
6509 = add_outermost_template_args (new_friend_args,
6510 DECL_TI_ARGS (spec));
6513 /* Now, since specializations are always supposed to
6514 hang off of the most general template, we must move
6516 t = most_general_template (old_decl);
6519 DECL_TEMPLATE_SPECIALIZATIONS (t)
6520 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (t),
6521 DECL_TEMPLATE_SPECIALIZATIONS (old_decl));
6522 DECL_TEMPLATE_SPECIALIZATIONS (old_decl) = NULL_TREE;
6527 /* The information from NEW_FRIEND has been merged into OLD_DECL
6528 by duplicate_decls. */
6529 new_friend = old_decl;
6534 tree context = DECL_CONTEXT (new_friend);
6538 template <class T> class C {
6539 template <class U> friend void C1<U>::f (); // case 1
6540 friend void C2<T>::f (); // case 2
6542 we only need to make sure CONTEXT is a complete type for
6543 case 2. To distinguish between the two cases, we note that
6544 CONTEXT of case 1 remains dependent type after tsubst while
6545 this isn't true for case 2. */
6546 ++processing_template_decl;
6547 dependent_p = dependent_type_p (context);
6548 --processing_template_decl;
6551 && !complete_type_or_else (context, NULL_TREE))
6552 return error_mark_node;
6554 if (COMPLETE_TYPE_P (context))
6556 /* Check to see that the declaration is really present, and,
6557 possibly obtain an improved declaration. */
6558 tree fn = check_classfn (context,
6559 new_friend, NULL_TREE);
6569 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
6570 template arguments, as for tsubst.
6572 Returns an appropriate tsubst'd friend type or error_mark_node on
6576 tsubst_friend_class (tree friend_tmpl, tree args)
6582 context = DECL_CONTEXT (friend_tmpl);
6586 if (TREE_CODE (context) == NAMESPACE_DECL)
6587 push_nested_namespace (context);
6589 push_nested_class (tsubst (context, args, tf_none, NULL_TREE));
6592 /* Look for a class template declaration. We look for hidden names
6593 because two friend declarations of the same template are the
6594 same. For example, in:
6597 template <typename> friend class F;
6599 template <typename> struct B {
6600 template <typename> friend class F;
6603 both F templates are the same. */
6604 tmpl = lookup_name_real (DECL_NAME (friend_tmpl), 0, 0,
6605 /*block_p=*/true, 0,
6606 LOOKUP_COMPLAIN | LOOKUP_HIDDEN);
6608 /* But, if we don't find one, it might be because we're in a
6609 situation like this:
6617 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
6618 for `S<int>', not the TEMPLATE_DECL. */
6619 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
6621 tmpl = lookup_name_prefer_type (DECL_NAME (friend_tmpl), 1);
6622 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
6625 if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
6627 /* The friend template has already been declared. Just
6628 check to see that the declarations match, and install any new
6629 default parameters. We must tsubst the default parameters,
6630 of course. We only need the innermost template parameters
6631 because that is all that redeclare_class_template will look
6633 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl))
6634 > TMPL_ARGS_DEPTH (args))
6637 location_t saved_input_location;
6638 parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
6639 args, tf_warning_or_error);
6641 saved_input_location = input_location;
6642 input_location = DECL_SOURCE_LOCATION (friend_tmpl);
6643 redeclare_class_template (TREE_TYPE (tmpl), parms);
6644 input_location = saved_input_location;
6648 friend_type = TREE_TYPE (tmpl);
6652 /* The friend template has not already been declared. In this
6653 case, the instantiation of the template class will cause the
6654 injection of this template into the global scope. */
6655 tmpl = tsubst (friend_tmpl, args, tf_warning_or_error, NULL_TREE);
6656 if (tmpl == error_mark_node)
6657 return error_mark_node;
6659 /* The new TMPL is not an instantiation of anything, so we
6660 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
6661 the new type because that is supposed to be the corresponding
6662 template decl, i.e., TMPL. */
6663 DECL_USE_TEMPLATE (tmpl) = 0;
6664 DECL_TEMPLATE_INFO (tmpl) = NULL_TREE;
6665 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0;
6666 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl))
6667 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)));
6669 /* Inject this template into the global scope. */
6670 friend_type = TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl, true));
6675 if (TREE_CODE (context) == NAMESPACE_DECL)
6676 pop_nested_namespace (context);
6678 pop_nested_class ();
6684 /* Returns zero if TYPE cannot be completed later due to circularity.
6685 Otherwise returns one. */
6688 can_complete_type_without_circularity (tree type)
6690 if (type == NULL_TREE || type == error_mark_node)
6692 else if (COMPLETE_TYPE_P (type))
6694 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
6695 return can_complete_type_without_circularity (TREE_TYPE (type));
6696 else if (CLASS_TYPE_P (type)
6697 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type)))
6703 /* Apply any attributes which had to be deferred until instantiation
6704 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
6705 ARGS, COMPLAIN, IN_DECL are as tsubst. */
6708 apply_late_template_attributes (tree *decl_p, tree attributes, int attr_flags,
6709 tree args, tsubst_flags_t complain, tree in_decl)
6711 tree last_dep = NULL_TREE;
6715 for (t = attributes; t; t = TREE_CHAIN (t))
6716 if (ATTR_IS_DEPENDENT (t))
6719 attributes = copy_list (attributes);
6723 if (DECL_P (*decl_p))
6725 if (TREE_TYPE (*decl_p) == error_mark_node)
6727 p = &DECL_ATTRIBUTES (*decl_p);
6730 p = &TYPE_ATTRIBUTES (*decl_p);
6734 tree late_attrs = NULL_TREE;
6735 tree *q = &late_attrs;
6737 for (*p = attributes; *p; )
6740 if (ATTR_IS_DEPENDENT (t))
6742 *p = TREE_CHAIN (t);
6743 TREE_CHAIN (t) = NULL_TREE;
6745 = tsubst_expr (TREE_VALUE (t), args, complain, in_decl,
6746 /*integral_constant_expression_p=*/false);
6748 q = &TREE_CHAIN (t);
6751 p = &TREE_CHAIN (t);
6754 cplus_decl_attributes (decl_p, late_attrs, attr_flags);
6759 instantiate_class_template (tree type)
6761 tree template, args, pattern, t, member;
6766 if (type == error_mark_node)
6767 return error_mark_node;
6769 if (TYPE_BEING_DEFINED (type)
6770 || COMPLETE_TYPE_P (type)
6771 || dependent_type_p (type))
6774 /* Figure out which template is being instantiated. */
6775 template = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
6776 gcc_assert (TREE_CODE (template) == TEMPLATE_DECL);
6778 /* Determine what specialization of the original template to
6780 t = most_specialized_class (type, template);
6781 if (t == error_mark_node)
6783 TYPE_BEING_DEFINED (type) = 1;
6784 return error_mark_node;
6788 /* This TYPE is actually an instantiation of a partial
6789 specialization. We replace the innermost set of ARGS with
6790 the arguments appropriate for substitution. For example,
6793 template <class T> struct S {};
6794 template <class T> struct S<T*> {};
6796 and supposing that we are instantiating S<int*>, ARGS will
6797 presently be {int*} -- but we need {int}. */
6798 pattern = TREE_TYPE (t);
6799 args = TREE_PURPOSE (t);
6803 pattern = TREE_TYPE (template);
6804 args = CLASSTYPE_TI_ARGS (type);
6807 /* If the template we're instantiating is incomplete, then clearly
6808 there's nothing we can do. */
6809 if (!COMPLETE_TYPE_P (pattern))
6812 /* If we've recursively instantiated too many templates, stop. */
6813 if (! push_tinst_level (type))
6816 /* Now we're really doing the instantiation. Mark the type as in
6817 the process of being defined. */
6818 TYPE_BEING_DEFINED (type) = 1;
6820 /* We may be in the middle of deferred access check. Disable
6822 push_deferring_access_checks (dk_no_deferred);
6824 push_to_top_level ();
6826 SET_CLASSTYPE_INTERFACE_UNKNOWN (type);
6828 /* Set the input location to the template definition. This is needed
6829 if tsubsting causes an error. */
6830 typedecl = TYPE_MAIN_DECL (type);
6831 input_location = DECL_SOURCE_LOCATION (typedecl);
6832 in_system_header = DECL_IN_SYSTEM_HEADER (typedecl);
6834 TYPE_HAS_CONSTRUCTOR (type) = TYPE_HAS_CONSTRUCTOR (pattern);
6835 TYPE_HAS_NEW_OPERATOR (type) = TYPE_HAS_NEW_OPERATOR (pattern);
6836 TYPE_HAS_ARRAY_NEW_OPERATOR (type) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern);
6837 TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern);
6838 TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern);
6839 TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern);
6840 TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern);
6841 TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern);
6842 TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern);
6843 TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern);
6844 TYPE_PACKED (type) = TYPE_PACKED (pattern);
6845 TYPE_ALIGN (type) = TYPE_ALIGN (pattern);
6846 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);
6847 TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */
6848 if (ANON_AGGR_TYPE_P (pattern))
6849 SET_ANON_AGGR_TYPE_P (type);
6850 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern))
6852 CLASSTYPE_VISIBILITY_SPECIFIED (type) = 1;
6853 CLASSTYPE_VISIBILITY (type) = CLASSTYPE_VISIBILITY (pattern);
6856 pbinfo = TYPE_BINFO (pattern);
6858 /* We should never instantiate a nested class before its enclosing
6859 class; we need to look up the nested class by name before we can
6860 instantiate it, and that lookup should instantiate the enclosing
6862 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))
6863 || COMPLETE_TYPE_P (TYPE_CONTEXT (type))
6864 || TYPE_BEING_DEFINED (TYPE_CONTEXT (type)));
6866 base_list = NULL_TREE;
6867 if (BINFO_N_BASE_BINFOS (pbinfo))
6870 tree context = TYPE_CONTEXT (type);
6874 /* We must enter the scope containing the type, as that is where
6875 the accessibility of types named in dependent bases are
6877 pushed_scope = push_scope (context ? context : global_namespace);
6879 /* Substitute into each of the bases to determine the actual
6881 for (i = 0; BINFO_BASE_ITERATE (pbinfo, i, pbase_binfo); i++)
6884 tree access = BINFO_BASE_ACCESS (pbinfo, i);
6885 tree expanded_bases = NULL_TREE;
6888 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo)))
6891 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo),
6892 args, tf_error, NULL_TREE);
6893 if (expanded_bases == error_mark_node)
6896 len = TREE_VEC_LENGTH (expanded_bases);
6899 for (idx = 0; idx < len; idx++)
6902 /* Extract the already-expanded base class. */
6903 base = TREE_VEC_ELT (expanded_bases, idx);
6905 /* Substitute to figure out the base class. */
6906 base = tsubst (BINFO_TYPE (pbase_binfo), args, tf_error,
6909 if (base == error_mark_node)
6912 base_list = tree_cons (access, base, base_list);
6913 if (BINFO_VIRTUAL_P (pbase_binfo))
6914 TREE_TYPE (base_list) = integer_type_node;
6918 /* The list is now in reverse order; correct that. */
6919 base_list = nreverse (base_list);
6922 pop_scope (pushed_scope);
6924 /* Now call xref_basetypes to set up all the base-class
6926 xref_basetypes (type, base_list);
6928 apply_late_template_attributes (&type, TYPE_ATTRIBUTES (pattern),
6929 (int) ATTR_FLAG_TYPE_IN_PLACE,
6930 args, tf_error, NULL_TREE);
6932 /* Now that our base classes are set up, enter the scope of the
6933 class, so that name lookups into base classes, etc. will work
6934 correctly. This is precisely analogous to what we do in
6935 begin_class_definition when defining an ordinary non-template
6936 class, except we also need to push the enclosing classes. */
6937 push_nested_class (type);
6939 /* Now members are processed in the order of declaration. */
6940 for (member = CLASSTYPE_DECL_LIST (pattern);
6941 member; member = TREE_CHAIN (member))
6943 tree t = TREE_VALUE (member);
6945 if (TREE_PURPOSE (member))
6949 /* Build new CLASSTYPE_NESTED_UTDS. */
6952 bool class_template_p;
6954 class_template_p = (TREE_CODE (t) != ENUMERAL_TYPE
6955 && TYPE_LANG_SPECIFIC (t)
6956 && CLASSTYPE_IS_TEMPLATE (t));
6957 /* If the member is a class template, then -- even after
6958 substitution -- there may be dependent types in the
6959 template argument list for the class. We increment
6960 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
6961 that function will assume that no types are dependent
6962 when outside of a template. */
6963 if (class_template_p)
6964 ++processing_template_decl;
6965 newtag = tsubst (t, args, tf_error, NULL_TREE);
6966 if (class_template_p)
6967 --processing_template_decl;
6968 if (newtag == error_mark_node)
6971 if (TREE_CODE (newtag) != ENUMERAL_TYPE)
6973 tree name = TYPE_IDENTIFIER (t);
6975 if (class_template_p)
6976 /* Unfortunately, lookup_template_class sets
6977 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
6978 instantiation (i.e., for the type of a member
6979 template class nested within a template class.)
6980 This behavior is required for
6981 maybe_process_partial_specialization to work
6982 correctly, but is not accurate in this case;
6983 the TAG is not an instantiation of anything.
6984 (The corresponding TEMPLATE_DECL is an
6985 instantiation, but the TYPE is not.) */
6986 CLASSTYPE_USE_TEMPLATE (newtag) = 0;
6988 /* Now, we call pushtag to put this NEWTAG into the scope of
6989 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
6990 pushtag calling push_template_decl. We don't have to do
6991 this for enums because it will already have been done in
6994 SET_IDENTIFIER_TYPE_VALUE (name, newtag);
6995 pushtag (name, newtag, /*tag_scope=*/ts_current);
6998 else if (TREE_CODE (t) == FUNCTION_DECL
6999 || DECL_FUNCTION_TEMPLATE_P (t))
7001 /* Build new TYPE_METHODS. */
7004 if (TREE_CODE (t) == TEMPLATE_DECL)
7005 ++processing_template_decl;
7006 r = tsubst (t, args, tf_error, NULL_TREE);
7007 if (TREE_CODE (t) == TEMPLATE_DECL)
7008 --processing_template_decl;
7009 set_current_access_from_decl (r);
7010 finish_member_declaration (r);
7014 /* Build new TYPE_FIELDS. */
7015 if (TREE_CODE (t) == STATIC_ASSERT)
7018 tsubst_expr (STATIC_ASSERT_CONDITION (t), args,
7019 tf_warning_or_error, NULL_TREE,
7020 /*integral_constant_expression_p=*/true);
7021 finish_static_assert (condition,
7022 STATIC_ASSERT_MESSAGE (t),
7023 STATIC_ASSERT_SOURCE_LOCATION (t),
7026 else if (TREE_CODE (t) != CONST_DECL)
7030 /* The the file and line for this declaration, to
7031 assist in error message reporting. Since we
7032 called push_tinst_level above, we don't need to
7034 input_location = DECL_SOURCE_LOCATION (t);
7036 if (TREE_CODE (t) == TEMPLATE_DECL)
7037 ++processing_template_decl;
7038 r = tsubst (t, args, tf_warning_or_error, NULL_TREE);
7039 if (TREE_CODE (t) == TEMPLATE_DECL)
7040 --processing_template_decl;
7041 if (TREE_CODE (r) == VAR_DECL)
7045 [t]he initialization (and any associated
7046 side-effects) of a static data member does
7047 not occur unless the static data member is
7048 itself used in a way that requires the
7049 definition of the static data member to
7052 Therefore, we do not substitute into the
7053 initialized for the static data member here. */
7054 finish_static_data_member_decl
7057 /*init_const_expr_p=*/false,
7058 /*asmspec_tree=*/NULL_TREE,
7060 if (DECL_INITIALIZED_IN_CLASS_P (r))
7061 check_static_variable_definition (r, TREE_TYPE (r));
7063 else if (TREE_CODE (r) == FIELD_DECL)
7065 /* Determine whether R has a valid type and can be
7066 completed later. If R is invalid, then it is
7067 replaced by error_mark_node so that it will not be
7068 added to TYPE_FIELDS. */
7069 tree rtype = TREE_TYPE (r);
7070 if (can_complete_type_without_circularity (rtype))
7071 complete_type (rtype);
7073 if (!COMPLETE_TYPE_P (rtype))
7075 cxx_incomplete_type_error (r, rtype);
7076 r = error_mark_node;
7080 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
7081 such a thing will already have been added to the field
7082 list by tsubst_enum in finish_member_declaration in the
7083 CLASSTYPE_NESTED_UTDS case above. */
7084 if (!(TREE_CODE (r) == TYPE_DECL
7085 && TREE_CODE (TREE_TYPE (r)) == ENUMERAL_TYPE
7086 && DECL_ARTIFICIAL (r)))
7088 set_current_access_from_decl (r);
7089 finish_member_declaration (r);
7096 if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t))
7098 /* Build new CLASSTYPE_FRIEND_CLASSES. */
7100 tree friend_type = t;
7101 bool adjust_processing_template_decl = false;
7103 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
7105 /* template <class T> friend class C; */
7106 friend_type = tsubst_friend_class (friend_type, args);
7107 adjust_processing_template_decl = true;
7109 else if (TREE_CODE (friend_type) == UNBOUND_CLASS_TEMPLATE)
7111 /* template <class T> friend class C::D; */
7112 friend_type = tsubst (friend_type, args,
7113 tf_warning_or_error, NULL_TREE);
7114 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
7115 friend_type = TREE_TYPE (friend_type);
7116 adjust_processing_template_decl = true;
7118 else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
7120 /* This could be either
7124 when dependent_type_p is false or
7126 template <class U> friend class T::C;
7129 friend_type = tsubst (friend_type, args,
7130 tf_warning_or_error, NULL_TREE);
7131 /* Bump processing_template_decl for correct
7132 dependent_type_p calculation. */
7133 ++processing_template_decl;
7134 if (dependent_type_p (friend_type))
7135 adjust_processing_template_decl = true;
7136 --processing_template_decl;
7138 else if (!CLASSTYPE_USE_TEMPLATE (friend_type)
7139 && hidden_name_p (TYPE_NAME (friend_type)))
7143 where C hasn't been declared yet. Let's lookup name
7144 from namespace scope directly, bypassing any name that
7145 come from dependent base class. */
7146 tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type));
7148 /* The call to xref_tag_from_type does injection for friend
7150 push_nested_namespace (ns);
7152 xref_tag_from_type (friend_type, NULL_TREE,
7153 /*tag_scope=*/ts_current);
7154 pop_nested_namespace (ns);
7156 else if (uses_template_parms (friend_type))
7157 /* friend class C<T>; */
7158 friend_type = tsubst (friend_type, args,
7159 tf_warning_or_error, NULL_TREE);
7164 where C is already declared or
7166 friend class C<int>;
7168 We don't have to do anything in these cases. */
7170 if (adjust_processing_template_decl)
7171 /* Trick make_friend_class into realizing that the friend
7172 we're adding is a template, not an ordinary class. It's
7173 important that we use make_friend_class since it will
7174 perform some error-checking and output cross-reference
7176 ++processing_template_decl;
7178 if (friend_type != error_mark_node)
7179 make_friend_class (type, friend_type, /*complain=*/false);
7181 if (adjust_processing_template_decl)
7182 --processing_template_decl;
7186 /* Build new DECL_FRIENDLIST. */
7189 /* The the file and line for this declaration, to
7190 assist in error message reporting. Since we
7191 called push_tinst_level above, we don't need to
7193 input_location = DECL_SOURCE_LOCATION (t);
7195 if (TREE_CODE (t) == TEMPLATE_DECL)
7197 ++processing_template_decl;
7198 push_deferring_access_checks (dk_no_check);
7201 r = tsubst_friend_function (t, args);
7202 add_friend (type, r, /*complain=*/false);
7203 if (TREE_CODE (t) == TEMPLATE_DECL)
7205 pop_deferring_access_checks ();
7206 --processing_template_decl;
7212 /* Set the file and line number information to whatever is given for
7213 the class itself. This puts error messages involving generated
7214 implicit functions at a predictable point, and the same point
7215 that would be used for non-template classes. */
7216 input_location = DECL_SOURCE_LOCATION (typedecl);
7218 unreverse_member_declarations (type);
7219 finish_struct_1 (type);
7220 TYPE_BEING_DEFINED (type) = 0;
7222 /* Now that the class is complete, instantiate default arguments for
7223 any member functions. We don't do this earlier because the
7224 default arguments may reference members of the class. */
7225 if (!PRIMARY_TEMPLATE_P (template))
7226 for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t))
7227 if (TREE_CODE (t) == FUNCTION_DECL
7228 /* Implicitly generated member functions will not have template
7229 information; they are not instantiations, but instead are
7230 created "fresh" for each instantiation. */
7231 && DECL_TEMPLATE_INFO (t))
7232 tsubst_default_arguments (t);
7234 pop_nested_class ();
7235 pop_from_top_level ();
7236 pop_deferring_access_checks ();
7239 /* The vtable for a template class can be emitted in any translation
7240 unit in which the class is instantiated. When there is no key
7241 method, however, finish_struct_1 will already have added TYPE to
7242 the keyed_classes list. */
7243 if (TYPE_CONTAINS_VPTR_P (type) && CLASSTYPE_KEY_METHOD (type))
7244 keyed_classes = tree_cons (NULL_TREE, type, keyed_classes);
7250 tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl)
7256 else if (TYPE_P (t))
7257 r = tsubst (t, args, complain, in_decl);
7260 r = tsubst_expr (t, args, complain, in_decl,
7261 /*integral_constant_expression_p=*/true);
7262 r = fold_non_dependent_expr (r);
7267 /* Substitute ARGS into T, which is an pack expansion
7268 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
7269 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
7270 (if only a partial substitution could be performed) or
7271 ERROR_MARK_NODE if there was an error. */
7273 tsubst_pack_expansion (tree t, tree args, tsubst_flags_t complain,
7277 tree pack, packs = NULL_TREE, unsubstituted_packs = NULL_TREE;
7278 tree first_arg_pack; int i, len = -1;
7282 gcc_assert (PACK_EXPANSION_P (t));
7283 pattern = PACK_EXPANSION_PATTERN (t);
7285 /* Determine the argument packs that will instantiate the parameter
7286 packs used in the expansion expression. While we're at it,
7287 compute the number of arguments to be expanded and make sure it
7289 for (pack = PACK_EXPANSION_PARAMETER_PACKS (t); pack;
7290 pack = TREE_CHAIN (pack))
7292 tree parm_pack = TREE_VALUE (pack);
7293 tree arg_pack = NULL_TREE;
7294 tree orig_arg = NULL_TREE;
7296 if (TREE_CODE (parm_pack) == PARM_DECL)
7298 if (local_specializations)
7299 arg_pack = retrieve_local_specialization (parm_pack);
7303 int level, idx, levels;
7304 template_parm_level_and_index (parm_pack, &level, &idx);
7306 levels = TMPL_ARGS_DEPTH (args);
7307 if (level <= levels)
7308 arg_pack = TMPL_ARG (args, level, idx);
7311 orig_arg = arg_pack;
7312 if (arg_pack && TREE_CODE (arg_pack) == ARGUMENT_PACK_SELECT)
7313 arg_pack = ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack);
7315 if (arg_pack && !ARGUMENT_PACK_P (arg_pack))
7316 /* This can only happen if we forget to expand an argument
7317 pack somewhere else. Just return an error, silently. */
7319 result = make_tree_vec (1);
7320 TREE_VEC_ELT (result, 0) = error_mark_node;
7325 && TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack)) == 1
7326 && PACK_EXPANSION_P (TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg_pack), 0)))
7328 tree expansion = TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg_pack), 0);
7329 tree pattern = PACK_EXPANSION_PATTERN (expansion);
7330 if ((TYPE_P (pattern) && same_type_p (pattern, parm_pack))
7331 || (!TYPE_P (pattern) && cp_tree_equal (parm_pack, pattern)))
7332 /* The argument pack that the parameter maps to is just an
7333 expansion of the parameter itself, such as one would
7334 find in the implicit typedef of a class inside the
7335 class itself. Consider this parameter "unsubstituted",
7336 so that we will maintain the outer pack expansion. */
7337 arg_pack = NULL_TREE;
7343 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack));
7345 /* It's all-or-nothing with incomplete argument packs. */
7346 if (incomplete && !ARGUMENT_PACK_INCOMPLETE_P (arg_pack))
7347 return error_mark_node;
7349 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack))
7355 first_arg_pack = arg_pack;
7357 else if (len != my_len)
7359 if (TREE_CODE (t) == TYPE_PACK_EXPANSION)
7360 error ("mismatched argument pack lengths while expanding "
7364 error ("mismatched argument pack lengths while expanding "
7367 return error_mark_node;
7370 /* Keep track of the parameter packs and their corresponding
7372 packs = tree_cons (parm_pack, arg_pack, packs);
7373 TREE_TYPE (packs) = orig_arg;
7376 /* We can't substitute for this parameter pack. */
7377 unsubstituted_packs = tree_cons (TREE_PURPOSE (pack),
7379 unsubstituted_packs);
7382 /* We cannot expand this expansion expression, because we don't have
7383 all of the argument packs we need. Substitute into the pattern
7384 and return a PACK_EXPANSION_*. The caller will need to deal with
7386 if (unsubstituted_packs)
7387 return make_pack_expansion (tsubst (pattern, args, complain,
7390 /* We could not find any argument packs that work. */
7392 return error_mark_node;
7394 /* For each argument in each argument pack, substitute into the
7396 result = make_tree_vec (len + incomplete);
7397 for (i = 0; i < len + incomplete; ++i)
7399 /* For parameter pack, change the substitution of the parameter
7400 pack to the ith argument in its argument pack, then expand
7402 for (pack = packs; pack; pack = TREE_CHAIN (pack))
7404 tree parm = TREE_PURPOSE (pack);
7406 if (TREE_CODE (parm) == PARM_DECL)
7408 /* Select the Ith argument from the pack. */
7409 tree arg = make_node (ARGUMENT_PACK_SELECT);
7410 ARGUMENT_PACK_SELECT_FROM_PACK (arg) = TREE_VALUE (pack);
7411 ARGUMENT_PACK_SELECT_INDEX (arg) = i;
7413 register_local_specialization (arg, parm);
7419 template_parm_level_and_index (parm, &level, &idx);
7423 /* Select the Ith argument from the pack. */
7424 value = make_node (ARGUMENT_PACK_SELECT);
7425 ARGUMENT_PACK_SELECT_FROM_PACK (value) = TREE_VALUE (pack);
7426 ARGUMENT_PACK_SELECT_INDEX (value) = i;
7429 /* Update the corresponding argument. */
7430 TMPL_ARG (args, level, idx) = value;
7434 /* Substitute into the PATTERN with the altered arguments. */
7435 if (TREE_CODE (t) == EXPR_PACK_EXPANSION)
7436 TREE_VEC_ELT (result, i) =
7437 tsubst_expr (pattern, args, complain, in_decl,
7438 /*integral_constant_expression_p=*/false);
7440 TREE_VEC_ELT (result, i) = tsubst (pattern, args, complain, in_decl);
7443 /* When we have incomplete argument packs, the last "expanded"
7444 result is itself a pack expansion, which allows us
7445 to deduce more arguments. */
7446 TREE_VEC_ELT (result, i) =
7447 make_pack_expansion (TREE_VEC_ELT (result, i));
7449 if (TREE_VEC_ELT (result, i) == error_mark_node)
7451 result = error_mark_node;
7456 /* Update ARGS to restore the substitution from parameter packs to
7457 their argument packs. */
7458 for (pack = packs; pack; pack = TREE_CHAIN (pack))
7460 tree parm = TREE_PURPOSE (pack);
7462 if (TREE_CODE (parm) == PARM_DECL)
7463 register_local_specialization (TREE_TYPE (pack), parm);
7467 template_parm_level_and_index (parm, &level, &idx);
7469 /* Update the corresponding argument. */
7470 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
7471 TREE_VEC_ELT (TREE_VEC_ELT (args, level -1 ), idx) =
7474 TREE_VEC_ELT (args, idx) = TREE_TYPE (pack);
7481 /* Substitute ARGS into the vector or list of template arguments T. */
7484 tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl)
7487 int len = TREE_VEC_LENGTH (t);
7488 int need_new = 0, i, expanded_len_adjust = 0, out;
7489 tree *elts = (tree *) alloca (len * sizeof (tree));
7491 for (i = 0; i < len; i++)
7493 tree orig_arg = TREE_VEC_ELT (t, i);
7496 if (TREE_CODE (orig_arg) == TREE_VEC)
7497 new_arg = tsubst_template_args (orig_arg, args, complain, in_decl);
7498 else if (PACK_EXPANSION_P (orig_arg))
7500 /* Substitute into an expansion expression. */
7501 new_arg = tsubst_pack_expansion (orig_arg, args, complain, in_decl);
7503 if (TREE_CODE (new_arg) == TREE_VEC)
7504 /* Add to the expanded length adjustment the number of
7505 expanded arguments. We subtract one from this
7506 measurement, because the argument pack expression
7507 itself is already counted as 1 in
7508 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
7509 the argument pack is empty. */
7510 expanded_len_adjust += TREE_VEC_LENGTH (new_arg) - 1;
7512 else if (ARGUMENT_PACK_P (orig_arg))
7514 /* Substitute into each of the arguments. */
7515 new_arg = make_node (TREE_CODE (orig_arg));
7517 SET_ARGUMENT_PACK_ARGS (
7519 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg),
7520 args, complain, in_decl));
7522 if (ARGUMENT_PACK_ARGS (new_arg) == error_mark_node)
7523 new_arg = error_mark_node;
7525 if (TREE_CODE (new_arg) == NONTYPE_ARGUMENT_PACK) {
7526 TREE_TYPE (new_arg) = tsubst (TREE_TYPE (orig_arg), args,
7528 TREE_CONSTANT (new_arg) = TREE_CONSTANT (orig_arg);
7530 if (TREE_TYPE (new_arg) == error_mark_node)
7531 new_arg = error_mark_node;
7535 new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl);
7537 if (new_arg == error_mark_node)
7538 return error_mark_node;
7541 if (new_arg != orig_arg)
7548 /* Make space for the expanded arguments coming from template
7550 t = make_tree_vec (len + expanded_len_adjust);
7551 for (i = 0, out = 0; i < len; i++)
7553 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t, i))
7554 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t, i)))
7555 && TREE_CODE (elts[i]) == TREE_VEC)
7559 /* Now expand the template argument pack "in place". */
7560 for (idx = 0; idx < TREE_VEC_LENGTH (elts[i]); idx++, out++)
7561 TREE_VEC_ELT (t, out) = TREE_VEC_ELT (elts[i], idx);
7565 TREE_VEC_ELT (t, out) = elts[i];
7573 /* Return the result of substituting ARGS into the template parameters
7574 given by PARMS. If there are m levels of ARGS and m + n levels of
7575 PARMS, then the result will contain n levels of PARMS. For
7576 example, if PARMS is `template <class T> template <class U>
7577 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
7578 result will be `template <int*, double, class V>'. */
7581 tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain)
7586 /* When substituting into a template, we must set
7587 PROCESSING_TEMPLATE_DECL as the template parameters may be
7588 dependent if they are based on one-another, and the dependency
7589 predicates are short-circuit outside of templates. */
7590 ++processing_template_decl;
7592 for (new_parms = &r;
7593 TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args);
7594 new_parms = &(TREE_CHAIN (*new_parms)),
7595 parms = TREE_CHAIN (parms))
7598 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms)));
7601 for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i)
7607 if (parms == error_mark_node)
7610 tuple = TREE_VEC_ELT (TREE_VALUE (parms), i);
7612 if (tuple == error_mark_node)
7615 default_value = TREE_PURPOSE (tuple);
7616 parm_decl = TREE_VALUE (tuple);
7618 parm_decl = tsubst (parm_decl, args, complain, NULL_TREE);
7619 if (TREE_CODE (parm_decl) == PARM_DECL
7620 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl), complain))
7621 parm_decl = error_mark_node;
7622 default_value = tsubst_template_arg (default_value, args,
7623 complain, NULL_TREE);
7625 tuple = build_tree_list (default_value, parm_decl);
7626 TREE_VEC_ELT (new_vec, i) = tuple;
7630 tree_cons (size_int (TMPL_PARMS_DEPTH (parms)
7631 - TMPL_ARGS_DEPTH (args)),
7632 new_vec, NULL_TREE);
7635 --processing_template_decl;
7640 /* Substitute the ARGS into the indicated aggregate (or enumeration)
7641 type T. If T is not an aggregate or enumeration type, it is
7642 handled as if by tsubst. IN_DECL is as for tsubst. If
7643 ENTERING_SCOPE is nonzero, T is the context for a template which
7644 we are presently tsubst'ing. Return the substituted value. */
7647 tsubst_aggr_type (tree t,
7649 tsubst_flags_t complain,
7656 switch (TREE_CODE (t))
7659 if (TYPE_PTRMEMFUNC_P (t))
7660 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl);
7662 /* Else fall through. */
7665 if (TYPE_TEMPLATE_INFO (t) && uses_template_parms (t))
7670 bool saved_skip_evaluation;
7672 /* In "sizeof(X<I>)" we need to evaluate "I". */
7673 saved_skip_evaluation = skip_evaluation;
7674 skip_evaluation = false;
7676 /* First, determine the context for the type we are looking
7678 context = TYPE_CONTEXT (t);
7680 context = tsubst_aggr_type (context, args, complain,
7681 in_decl, /*entering_scope=*/1);
7683 /* Then, figure out what arguments are appropriate for the
7684 type we are trying to find. For example, given:
7686 template <class T> struct S;
7687 template <class T, class U> void f(T, U) { S<U> su; }
7689 and supposing that we are instantiating f<int, double>,
7690 then our ARGS will be {int, double}, but, when looking up
7691 S we only want {double}. */
7692 argvec = tsubst_template_args (TYPE_TI_ARGS (t), args,
7694 if (argvec == error_mark_node)
7695 r = error_mark_node;
7698 r = lookup_template_class (t, argvec, in_decl, context,
7699 entering_scope, complain);
7700 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
7703 skip_evaluation = saved_skip_evaluation;
7708 /* This is not a template type, so there's nothing to do. */
7712 return tsubst (t, args, complain, in_decl);
7716 /* Substitute into the default argument ARG (a default argument for
7717 FN), which has the indicated TYPE. */
7720 tsubst_default_argument (tree fn, tree type, tree arg)
7722 tree saved_class_ptr = NULL_TREE;
7723 tree saved_class_ref = NULL_TREE;
7725 /* This default argument came from a template. Instantiate the
7726 default argument here, not in tsubst. In the case of
7735 we must be careful to do name lookup in the scope of S<T>,
7736 rather than in the current class. */
7737 push_access_scope (fn);
7738 /* The "this" pointer is not valid in a default argument. */
7741 saved_class_ptr = current_class_ptr;
7742 cp_function_chain->x_current_class_ptr = NULL_TREE;
7743 saved_class_ref = current_class_ref;
7744 cp_function_chain->x_current_class_ref = NULL_TREE;
7747 push_deferring_access_checks(dk_no_deferred);
7748 /* The default argument expression may cause implicitly defined
7749 member functions to be synthesized, which will result in garbage
7750 collection. We must treat this situation as if we were within
7751 the body of function so as to avoid collecting live data on the
7754 arg = tsubst_expr (arg, DECL_TI_ARGS (fn),
7755 tf_warning_or_error, NULL_TREE,
7756 /*integral_constant_expression_p=*/false);
7758 pop_deferring_access_checks();
7760 /* Restore the "this" pointer. */
7763 cp_function_chain->x_current_class_ptr = saved_class_ptr;
7764 cp_function_chain->x_current_class_ref = saved_class_ref;
7767 pop_access_scope (fn);
7769 /* Make sure the default argument is reasonable. */
7770 arg = check_default_argument (type, arg);
7775 /* Substitute into all the default arguments for FN. */
7778 tsubst_default_arguments (tree fn)
7783 tmpl_args = DECL_TI_ARGS (fn);
7785 /* If this function is not yet instantiated, we certainly don't need
7786 its default arguments. */
7787 if (uses_template_parms (tmpl_args))
7790 for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
7792 arg = TREE_CHAIN (arg))
7793 if (TREE_PURPOSE (arg))
7794 TREE_PURPOSE (arg) = tsubst_default_argument (fn,
7796 TREE_PURPOSE (arg));
7799 /* Substitute the ARGS into the T, which is a _DECL. Return the
7800 result of the substitution. Issue error and warning messages under
7801 control of COMPLAIN. */
7804 tsubst_decl (tree t, tree args, tsubst_flags_t complain)
7806 location_t saved_loc;
7810 /* Set the filename and linenumber to improve error-reporting. */
7811 saved_loc = input_location;
7812 input_location = DECL_SOURCE_LOCATION (t);
7814 switch (TREE_CODE (t))
7818 /* We can get here when processing a member function template,
7819 member class template, and template template parameter of
7820 a template class. */
7821 tree decl = DECL_TEMPLATE_RESULT (t);
7826 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
7828 /* Template template parameter is treated here. */
7829 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
7830 if (new_type == error_mark_node)
7831 return error_mark_node;
7834 TREE_CHAIN (r) = NULL_TREE;
7835 TREE_TYPE (r) = new_type;
7836 DECL_TEMPLATE_RESULT (r)
7837 = build_decl (TYPE_DECL, DECL_NAME (decl), new_type);
7838 DECL_TEMPLATE_PARMS (r)
7839 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
7841 TYPE_NAME (new_type) = r;
7845 /* We might already have an instance of this template.
7846 The ARGS are for the surrounding class type, so the
7847 full args contain the tsubst'd args for the context,
7848 plus the innermost args from the template decl. */
7849 tmpl_args = DECL_CLASS_TEMPLATE_P (t)
7850 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t))
7851 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t));
7852 /* Because this is a template, the arguments will still be
7853 dependent, even after substitution. If
7854 PROCESSING_TEMPLATE_DECL is not set, the dependency
7855 predicates will short-circuit. */
7856 ++processing_template_decl;
7857 full_args = tsubst_template_args (tmpl_args, args,
7859 --processing_template_decl;
7860 if (full_args == error_mark_node)
7861 return error_mark_node;
7863 /* tsubst_template_args doesn't copy the vector if
7864 nothing changed. But, *something* should have
7866 gcc_assert (full_args != tmpl_args);
7868 spec = retrieve_specialization (t, full_args,
7869 /*class_specializations_p=*/true);
7870 if (spec != NULL_TREE)
7876 /* Make a new template decl. It will be similar to the
7877 original, but will record the current template arguments.
7878 We also create a new function declaration, which is just
7879 like the old one, but points to this new template, rather
7880 than the old one. */
7882 gcc_assert (DECL_LANG_SPECIFIC (r) != 0);
7883 TREE_CHAIN (r) = NULL_TREE;
7885 DECL_TEMPLATE_INFO (r) = build_tree_list (t, args);
7887 if (TREE_CODE (decl) == TYPE_DECL)
7890 ++processing_template_decl;
7891 new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
7892 --processing_template_decl;
7893 if (new_type == error_mark_node)
7894 return error_mark_node;
7896 TREE_TYPE (r) = new_type;
7897 CLASSTYPE_TI_TEMPLATE (new_type) = r;
7898 DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type);
7899 DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type);
7900 DECL_CONTEXT (r) = TYPE_CONTEXT (new_type);
7905 ++processing_template_decl;
7906 new_decl = tsubst (decl, args, complain, in_decl);
7907 --processing_template_decl;
7908 if (new_decl == error_mark_node)
7909 return error_mark_node;
7911 DECL_TEMPLATE_RESULT (r) = new_decl;
7912 DECL_TI_TEMPLATE (new_decl) = r;
7913 TREE_TYPE (r) = TREE_TYPE (new_decl);
7914 DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl);
7915 DECL_CONTEXT (r) = DECL_CONTEXT (new_decl);
7918 SET_DECL_IMPLICIT_INSTANTIATION (r);
7919 DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE;
7920 DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE;
7922 /* The template parameters for this new template are all the
7923 template parameters for the old template, except the
7924 outermost level of parameters. */
7925 DECL_TEMPLATE_PARMS (r)
7926 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
7929 if (PRIMARY_TEMPLATE_P (t))
7930 DECL_PRIMARY_TEMPLATE (r) = r;
7932 if (TREE_CODE (decl) != TYPE_DECL)
7933 /* Record this non-type partial instantiation. */
7934 register_specialization (r, t,
7935 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r)),
7943 tree argvec = NULL_TREE;
7951 /* Nobody should be tsubst'ing into non-template functions. */
7952 gcc_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE);
7954 if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL)
7959 /* If T is not dependent, just return it. We have to
7960 increment PROCESSING_TEMPLATE_DECL because
7961 value_dependent_expression_p assumes that nothing is
7962 dependent when PROCESSING_TEMPLATE_DECL is zero. */
7963 ++processing_template_decl;
7964 dependent_p = value_dependent_expression_p (t);
7965 --processing_template_decl;
7969 /* Calculate the most general template of which R is a
7970 specialization, and the complete set of arguments used to
7972 gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
7973 argvec = tsubst_template_args (DECL_TI_ARGS
7974 (DECL_TEMPLATE_RESULT (gen_tmpl)),
7975 args, complain, in_decl);
7977 /* Check to see if we already have this specialization. */
7978 spec = retrieve_specialization (gen_tmpl, argvec,
7979 /*class_specializations_p=*/false);
7987 /* We can see more levels of arguments than parameters if
7988 there was a specialization of a member template, like
7991 template <class T> struct S { template <class U> void f(); }
7992 template <> template <class U> void S<int>::f(U);
7994 Here, we'll be substituting into the specialization,
7995 because that's where we can find the code we actually
7996 want to generate, but we'll have enough arguments for
7997 the most general template.
7999 We also deal with the peculiar case:
8001 template <class T> struct S {
8002 template <class U> friend void f();
8004 template <class U> void f() {}
8006 template void f<double>();
8008 Here, the ARGS for the instantiation of will be {int,
8009 double}. But, we only need as many ARGS as there are
8010 levels of template parameters in CODE_PATTERN. We are
8011 careful not to get fooled into reducing the ARGS in
8014 template <class T> struct S { template <class U> void f(U); }
8015 template <class T> template <> void S<T>::f(int) {}
8017 which we can spot because the pattern will be a
8018 specialization in this case. */
8019 args_depth = TMPL_ARGS_DEPTH (args);
8021 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t)));
8022 if (args_depth > parms_depth
8023 && !DECL_TEMPLATE_SPECIALIZATION (t))
8024 args = get_innermost_template_args (args, parms_depth);
8028 /* This special case arises when we have something like this:
8030 template <class T> struct S {
8031 friend void f<int>(int, double);
8034 Here, the DECL_TI_TEMPLATE for the friend declaration
8035 will be an IDENTIFIER_NODE. We are being called from
8036 tsubst_friend_function, and we want only to create a
8037 new decl (R) with appropriate types so that we can call
8038 determine_specialization. */
8039 gen_tmpl = NULL_TREE;
8042 if (DECL_CLASS_SCOPE_P (t))
8044 if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t)))
8048 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
8049 complain, t, /*entering_scope=*/1);
8054 ctx = DECL_CONTEXT (t);
8056 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8057 if (type == error_mark_node)
8058 return error_mark_node;
8060 /* We do NOT check for matching decls pushed separately at this
8061 point, as they may not represent instantiations of this
8062 template, and in any case are considered separate under the
8065 DECL_USE_TEMPLATE (r) = 0;
8066 TREE_TYPE (r) = type;
8067 /* Clear out the mangled name and RTL for the instantiation. */
8068 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
8069 SET_DECL_RTL (r, NULL_RTX);
8070 DECL_INITIAL (r) = NULL_TREE;
8071 DECL_CONTEXT (r) = ctx;
8073 if (member && DECL_CONV_FN_P (r))
8074 /* Type-conversion operator. Reconstruct the name, in
8075 case it's the name of one of the template's parameters. */
8076 DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type));
8078 DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args,
8080 DECL_RESULT (r) = NULL_TREE;
8082 TREE_STATIC (r) = 0;
8083 TREE_PUBLIC (r) = TREE_PUBLIC (t);
8084 DECL_EXTERNAL (r) = 1;
8085 /* If this is an instantiation of a function with internal
8086 linkage, we already know what object file linkage will be
8087 assigned to the instantiation. */
8088 DECL_INTERFACE_KNOWN (r) = !TREE_PUBLIC (r);
8089 DECL_DEFER_OUTPUT (r) = 0;
8090 TREE_CHAIN (r) = NULL_TREE;
8091 DECL_PENDING_INLINE_INFO (r) = 0;
8092 DECL_PENDING_INLINE_P (r) = 0;
8093 DECL_SAVED_TREE (r) = NULL_TREE;
8095 if (DECL_CLONED_FUNCTION (r))
8097 DECL_CLONED_FUNCTION (r) = tsubst (DECL_CLONED_FUNCTION (t),
8099 TREE_CHAIN (r) = TREE_CHAIN (DECL_CLONED_FUNCTION (r));
8100 TREE_CHAIN (DECL_CLONED_FUNCTION (r)) = r;
8103 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
8104 this in the special friend case mentioned above where
8105 GEN_TMPL is NULL. */
8108 DECL_TEMPLATE_INFO (r)
8109 = tree_cons (gen_tmpl, argvec, NULL_TREE);
8110 SET_DECL_IMPLICIT_INSTANTIATION (r);
8111 register_specialization (r, gen_tmpl, argvec, false);
8113 /* We're not supposed to instantiate default arguments
8114 until they are called, for a template. But, for a
8117 template <class T> void f ()
8118 { extern void g(int i = T()); }
8120 we should do the substitution when the template is
8121 instantiated. We handle the member function case in
8122 instantiate_class_template since the default arguments
8123 might refer to other members of the class. */
8125 && !PRIMARY_TEMPLATE_P (gen_tmpl)
8126 && !uses_template_parms (argvec))
8127 tsubst_default_arguments (r);
8130 DECL_TEMPLATE_INFO (r) = NULL_TREE;
8132 /* Copy the list of befriending classes. */
8133 for (friends = &DECL_BEFRIENDING_CLASSES (r);
8135 friends = &TREE_CHAIN (*friends))
8137 *friends = copy_node (*friends);
8138 TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends),
8143 if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r))
8145 maybe_retrofit_in_chrg (r);
8146 if (DECL_CONSTRUCTOR_P (r))
8147 grok_ctor_properties (ctx, r);
8148 /* If this is an instantiation of a member template, clone it.
8149 If it isn't, that'll be handled by
8150 clone_constructors_and_destructors. */
8151 if (PRIMARY_TEMPLATE_P (gen_tmpl))
8152 clone_function_decl (r, /*update_method_vec_p=*/0);
8154 else if (IDENTIFIER_OPNAME_P (DECL_NAME (r))
8155 && !grok_op_properties (r, (complain & tf_error) != 0))
8156 return error_mark_node;
8158 if (DECL_FRIEND_P (t) && DECL_FRIEND_CONTEXT (t))
8159 SET_DECL_FRIEND_CONTEXT (r,
8160 tsubst (DECL_FRIEND_CONTEXT (t),
8161 args, complain, in_decl));
8163 /* Possibly limit visibility based on template args. */
8164 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
8165 if (DECL_VISIBILITY_SPECIFIED (t))
8167 DECL_VISIBILITY_SPECIFIED (r) = 0;
8169 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
8171 determine_visibility (r);
8173 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
8174 args, complain, in_decl);
8180 tree type = NULL_TREE;
8182 tree expanded_types = NULL_TREE;
8183 tree prev_r = NULL_TREE;
8184 tree first_r = NULL_TREE;
8186 if (FUNCTION_PARAMETER_PACK_P (t))
8188 /* If there is a local specialization that isn't a
8189 parameter pack, it means that we're doing a "simple"
8190 substitution from inside tsubst_pack_expansion. Just
8191 return the local specialization (which will be a single
8193 tree spec = NULL_TREE;
8194 if (local_specializations)
8195 spec = retrieve_local_specialization (t);
8197 && TREE_CODE (spec) == PARM_DECL
8198 && TREE_CODE (TREE_TYPE (spec)) != TYPE_PACK_EXPANSION)
8201 /* Expand the TYPE_PACK_EXPANSION that provides the types for
8202 the parameters in this function parameter pack. */
8203 expanded_types = tsubst_pack_expansion (TREE_TYPE (t), args,
8205 if (TREE_CODE (expanded_types) == TREE_VEC)
8207 len = TREE_VEC_LENGTH (expanded_types);
8209 /* Zero-length parameter packs are boring. Just substitute
8212 return tsubst (TREE_CHAIN (t), args, complain,
8217 /* All we did was update the type. Make a note of that. */
8218 type = expanded_types;
8219 expanded_types = NULL_TREE;
8223 /* Loop through all of the parameter's we'll build. When T is
8224 a function parameter pack, LEN is the number of expanded
8225 types in EXPANDED_TYPES; otherwise, LEN is 1. */
8227 for (i = 0; i < len; ++i)
8231 if (DECL_TEMPLATE_PARM_P (t))
8232 SET_DECL_TEMPLATE_PARM_P (r);
8235 /* We're on the Ith parameter of the function parameter
8238 /* Get the Ith type. */
8239 type = TREE_VEC_ELT (expanded_types, i);
8242 /* Rename the parameter to include the index. */
8244 make_ith_pack_parameter_name (DECL_NAME (r), i);
8247 /* We're dealing with a normal parameter. */
8248 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8250 type = type_decays_to (type);
8251 TREE_TYPE (r) = type;
8252 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
8254 if (DECL_INITIAL (r))
8256 if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
8257 DECL_INITIAL (r) = TREE_TYPE (r);
8259 DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
8263 DECL_CONTEXT (r) = NULL_TREE;
8265 if (!DECL_TEMPLATE_PARM_P (r))
8266 DECL_ARG_TYPE (r) = type_passed_as (type);
8268 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
8269 args, complain, in_decl);
8271 /* Keep track of the first new parameter we
8272 generate. That's what will be returned to the
8277 /* Build a proper chain of parameters when substituting
8278 into a function parameter pack. */
8280 TREE_CHAIN (prev_r) = r;
8284 TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args,
8285 complain, TREE_CHAIN (t));
8287 /* FIRST_R contains the start of the chain we've built. */
8297 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8298 if (type == error_mark_node)
8299 return error_mark_node;
8300 TREE_TYPE (r) = type;
8301 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
8303 /* DECL_INITIAL gives the number of bits in a bit-field. */
8305 = tsubst_expr (DECL_INITIAL (t), args,
8307 /*integral_constant_expression_p=*/true);
8308 /* We don't have to set DECL_CONTEXT here; it is set by
8309 finish_member_declaration. */
8310 TREE_CHAIN (r) = NULL_TREE;
8311 if (VOID_TYPE_P (type))
8312 error ("instantiation of %q+D as type %qT", r, type);
8314 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
8315 args, complain, in_decl);
8320 /* We reach here only for member using decls. */
8321 if (DECL_DEPENDENT_P (t))
8323 r = do_class_using_decl
8324 (tsubst_copy (USING_DECL_SCOPE (t), args, complain, in_decl),
8325 tsubst_copy (DECL_NAME (t), args, complain, in_decl));
8327 r = error_mark_node;
8332 TREE_CHAIN (r) = NULL_TREE;
8339 tree argvec = NULL_TREE;
8340 tree gen_tmpl = NULL_TREE;
8342 tree tmpl = NULL_TREE;
8344 tree type = NULL_TREE;
8347 if (TREE_CODE (t) == TYPE_DECL
8348 && t == TYPE_MAIN_DECL (TREE_TYPE (t)))
8350 /* If this is the canonical decl, we don't have to
8351 mess with instantiations, and often we can't (for
8352 typename, template type parms and such). Note that
8353 TYPE_NAME is not correct for the above test if
8354 we've copied the type for a typedef. */
8355 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8356 if (type == error_mark_node)
8357 return error_mark_node;
8358 r = TYPE_NAME (type);
8362 /* Check to see if we already have the specialization we
8365 if (DECL_CLASS_SCOPE_P (t) || DECL_NAMESPACE_SCOPE_P (t))
8367 /* T is a static data member or namespace-scope entity.
8368 We have to substitute into namespace-scope variables
8369 (even though such entities are never templates) because
8372 template <class T> void f() { extern T t; }
8374 where the entity referenced is not known until
8375 instantiation time. */
8377 ctx = DECL_CONTEXT (t);
8378 if (DECL_CLASS_SCOPE_P (t))
8380 ctx = tsubst_aggr_type (ctx, args,
8382 in_decl, /*entering_scope=*/1);
8383 /* If CTX is unchanged, then T is in fact the
8384 specialization we want. That situation occurs when
8385 referencing a static data member within in its own
8386 class. We can use pointer equality, rather than
8387 same_type_p, because DECL_CONTEXT is always
8389 if (ctx == DECL_CONTEXT (t))
8395 tmpl = DECL_TI_TEMPLATE (t);
8396 gen_tmpl = most_general_template (tmpl);
8397 argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl);
8398 spec = (retrieve_specialization
8400 /*class_specializations_p=*/false));
8405 /* A local variable. */
8407 /* Subsequent calls to pushdecl will fill this in. */
8409 spec = retrieve_local_specialization (t);
8411 /* If we already have the specialization we need, there is
8412 nothing more to do. */
8419 /* Create a new node for the specialization we need. */
8421 if (type == NULL_TREE)
8422 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8423 if (TREE_CODE (r) == VAR_DECL)
8425 /* Even if the original location is out of scope, the
8426 newly substituted one is not. */
8427 DECL_DEAD_FOR_LOCAL (r) = 0;
8428 DECL_INITIALIZED_P (r) = 0;
8429 DECL_TEMPLATE_INSTANTIATED (r) = 0;
8430 if (type == error_mark_node)
8431 return error_mark_node;
8432 if (TREE_CODE (type) == FUNCTION_TYPE)
8434 /* It may seem that this case cannot occur, since:
8439 declares a function, not a variable. However:
8442 template <typename T> void g() { T t; }
8443 template void g<f>();
8445 is an attempt to declare a variable with function
8447 error ("variable %qD has function type",
8448 /* R is not yet sufficiently initialized, so we
8449 just use its name. */
8451 return error_mark_node;
8453 type = complete_type (type);
8454 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
8455 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t);
8456 type = check_var_type (DECL_NAME (r), type);
8458 if (DECL_HAS_VALUE_EXPR_P (t))
8460 tree ve = DECL_VALUE_EXPR (t);
8461 ve = tsubst_expr (ve, args, complain, in_decl,
8462 /*constant_expression_p=*/false);
8463 SET_DECL_VALUE_EXPR (r, ve);
8466 else if (DECL_SELF_REFERENCE_P (t))
8467 SET_DECL_SELF_REFERENCE_P (r);
8468 TREE_TYPE (r) = type;
8469 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
8470 DECL_CONTEXT (r) = ctx;
8471 /* Clear out the mangled name and RTL for the instantiation. */
8472 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
8473 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
8474 SET_DECL_RTL (r, NULL_RTX);
8475 /* The initializer must not be expanded until it is required;
8477 DECL_INITIAL (r) = NULL_TREE;
8478 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
8479 SET_DECL_RTL (r, NULL_RTX);
8480 DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0;
8481 if (TREE_CODE (r) == VAR_DECL)
8483 /* Possibly limit visibility based on template args. */
8484 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
8485 if (DECL_VISIBILITY_SPECIFIED (t))
8487 DECL_VISIBILITY_SPECIFIED (r) = 0;
8489 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
8491 determine_visibility (r);
8493 /* Preserve a typedef that names a type. */
8494 else if (TREE_CODE (r) == TYPE_DECL
8495 && DECL_ORIGINAL_TYPE (t)
8496 && type != error_mark_node)
8498 DECL_ORIGINAL_TYPE (r) = tsubst (DECL_ORIGINAL_TYPE (t),
8499 args, complain, in_decl);
8500 TREE_TYPE (r) = type = build_variant_type_copy (type);
8501 TYPE_NAME (type) = r;
8506 /* A static data member declaration is always marked
8507 external when it is declared in-class, even if an
8508 initializer is present. We mimic the non-template
8510 DECL_EXTERNAL (r) = 1;
8512 register_specialization (r, gen_tmpl, argvec, false);
8513 DECL_TEMPLATE_INFO (r) = tree_cons (tmpl, argvec, NULL_TREE);
8514 SET_DECL_IMPLICIT_INSTANTIATION (r);
8517 register_local_specialization (r, t);
8519 TREE_CHAIN (r) = NULL_TREE;
8521 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r),
8522 (int) ATTR_FLAG_TYPE_IN_PLACE,
8523 args, complain, in_decl);
8532 /* Restore the file and line information. */
8533 input_location = saved_loc;
8538 /* Substitute into the ARG_TYPES of a function type. */
8541 tsubst_arg_types (tree arg_types,
8543 tsubst_flags_t complain,
8546 tree remaining_arg_types;
8547 tree type = NULL_TREE;
8549 tree expanded_args = NULL_TREE;
8552 if (!arg_types || arg_types == void_list_node)
8555 remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types),
8556 args, complain, in_decl);
8557 if (remaining_arg_types == error_mark_node)
8558 return error_mark_node;
8560 if (PACK_EXPANSION_P (TREE_VALUE (arg_types)))
8562 /* For a pack expansion, perform substitution on the
8563 entire expression. Later on, we'll handle the arguments
8565 expanded_args = tsubst_pack_expansion (TREE_VALUE (arg_types),
8566 args, complain, in_decl);
8568 if (TREE_CODE (expanded_args) == TREE_VEC)
8569 /* So that we'll spin through the parameters, one by one. */
8570 i = TREE_VEC_LENGTH (expanded_args);
8573 /* We only partially substituted into the parameter
8574 pack. Our type is TYPE_PACK_EXPANSION. */
8575 type = expanded_args;
8576 expanded_args = NULL_TREE;
8584 type = TREE_VEC_ELT (expanded_args, i);
8586 type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
8588 if (type == error_mark_node)
8589 return error_mark_node;
8590 if (VOID_TYPE_P (type))
8592 if (complain & tf_error)
8594 error ("invalid parameter type %qT", type);
8596 error ("in declaration %q+D", in_decl);
8598 return error_mark_node;
8601 /* Do array-to-pointer, function-to-pointer conversion, and ignore
8602 top-level qualifiers as required. */
8603 type = TYPE_MAIN_VARIANT (type_decays_to (type));
8605 /* We do not substitute into default arguments here. The standard
8606 mandates that they be instantiated only when needed, which is
8607 done in build_over_call. */
8608 default_arg = TREE_PURPOSE (arg_types);
8610 if (default_arg && TREE_CODE (default_arg) == DEFAULT_ARG)
8612 /* We've instantiated a template before its default arguments
8613 have been parsed. This can happen for a nested template
8614 class, and is not an error unless we require the default
8615 argument in a call of this function. */
8616 remaining_arg_types =
8617 tree_cons (default_arg, type, remaining_arg_types);
8618 VEC_safe_push (tree, gc, DEFARG_INSTANTIATIONS (default_arg),
8619 remaining_arg_types);
8622 remaining_arg_types =
8623 hash_tree_cons (default_arg, type, remaining_arg_types);
8626 return remaining_arg_types;
8629 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
8630 *not* handle the exception-specification for FNTYPE, because the
8631 initial substitution of explicitly provided template parameters
8632 during argument deduction forbids substitution into the
8633 exception-specification:
8637 All references in the function type of the function template to the
8638 corresponding template parameters are replaced by the specified tem-
8639 plate argument values. If a substitution in a template parameter or
8640 in the function type of the function template results in an invalid
8641 type, type deduction fails. [Note: The equivalent substitution in
8642 exception specifications is done only when the function is instanti-
8643 ated, at which point a program is ill-formed if the substitution
8644 results in an invalid type.] */
8647 tsubst_function_type (tree t,
8649 tsubst_flags_t complain,
8656 /* The TYPE_CONTEXT is not used for function/method types. */
8657 gcc_assert (TYPE_CONTEXT (t) == NULL_TREE);
8659 /* Substitute the return type. */
8660 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8661 if (return_type == error_mark_node)
8662 return error_mark_node;
8663 /* The standard does not presently indicate that creation of a
8664 function type with an invalid return type is a deduction failure.
8665 However, that is clearly analogous to creating an array of "void"
8666 or a reference to a reference. This is core issue #486. */
8667 if (TREE_CODE (return_type) == ARRAY_TYPE
8668 || TREE_CODE (return_type) == FUNCTION_TYPE)
8670 if (complain & tf_error)
8672 if (TREE_CODE (return_type) == ARRAY_TYPE)
8673 error ("function returning an array");
8675 error ("function returning a function");
8677 return error_mark_node;
8680 /* Substitute the argument types. */
8681 arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args,
8683 if (arg_types == error_mark_node)
8684 return error_mark_node;
8686 if (TYPE_QUALS (return_type) != TYPE_UNQUALIFIED
8687 && in_decl != NULL_TREE
8688 && !TREE_NO_WARNING (in_decl)
8689 && (SCALAR_TYPE_P (return_type) || VOID_TYPE_P (return_type)))
8690 warning (OPT_Wignored_qualifiers,
8691 "type qualifiers ignored on function return type");
8693 /* Construct a new type node and return it. */
8694 if (TREE_CODE (t) == FUNCTION_TYPE)
8695 fntype = build_function_type (return_type, arg_types);
8698 tree r = TREE_TYPE (TREE_VALUE (arg_types));
8699 if (! IS_AGGR_TYPE (r))
8703 Type deduction may fail for any of the following
8706 -- Attempting to create "pointer to member of T" when T
8707 is not a class type. */
8708 if (complain & tf_error)
8709 error ("creating pointer to member function of non-class type %qT",
8711 return error_mark_node;
8714 fntype = build_method_type_directly (r, return_type,
8715 TREE_CHAIN (arg_types));
8717 fntype = cp_build_qualified_type_real (fntype, TYPE_QUALS (t), complain);
8718 fntype = cp_build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t));
8723 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
8724 ARGS into that specification, and return the substituted
8725 specification. If there is no specification, return NULL_TREE. */
8728 tsubst_exception_specification (tree fntype,
8730 tsubst_flags_t complain,
8736 specs = TYPE_RAISES_EXCEPTIONS (fntype);
8737 new_specs = NULL_TREE;
8740 if (! TREE_VALUE (specs))
8747 tree expanded_specs = NULL_TREE;
8749 if (PACK_EXPANSION_P (TREE_VALUE (specs)))
8751 /* Expand the pack expansion type. */
8752 expanded_specs = tsubst_pack_expansion (TREE_VALUE (specs),
8756 if (expanded_specs == error_mark_node)
8757 return error_mark_node;
8758 else if (TREE_CODE (expanded_specs) == TREE_VEC)
8759 len = TREE_VEC_LENGTH (expanded_specs);
8762 /* We're substituting into a member template, so
8763 we got a TYPE_PACK_EXPANSION back. Add that
8764 expansion and move on. */
8765 gcc_assert (TREE_CODE (expanded_specs)
8766 == TYPE_PACK_EXPANSION);
8767 new_specs = add_exception_specifier (new_specs,
8770 specs = TREE_CHAIN (specs);
8775 for (i = 0; i < len; ++i)
8778 spec = TREE_VEC_ELT (expanded_specs, i);
8780 spec = tsubst (TREE_VALUE (specs), args, complain, in_decl);
8781 if (spec == error_mark_node)
8783 new_specs = add_exception_specifier (new_specs, spec,
8787 specs = TREE_CHAIN (specs);
8793 /* Take the tree structure T and replace template parameters used
8794 therein with the argument vector ARGS. IN_DECL is an associated
8795 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
8796 Issue error and warning messages under control of COMPLAIN. Note
8797 that we must be relatively non-tolerant of extensions here, in
8798 order to preserve conformance; if we allow substitutions that
8799 should not be allowed, we may allow argument deductions that should
8800 not succeed, and therefore report ambiguous overload situations
8801 where there are none. In theory, we could allow the substitution,
8802 but indicate that it should have failed, and allow our caller to
8803 make sure that the right thing happens, but we don't try to do this
8806 This function is used for dealing with types, decls and the like;
8807 for expressions, use tsubst_expr or tsubst_copy. */
8810 tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
8814 if (t == NULL_TREE || t == error_mark_node
8815 || t == integer_type_node
8816 || t == void_type_node
8817 || t == char_type_node
8818 || t == unknown_type_node
8819 || TREE_CODE (t) == NAMESPACE_DECL)
8823 return tsubst_decl (t, args, complain);
8825 if (TREE_CODE (t) == IDENTIFIER_NODE)
8826 type = IDENTIFIER_TYPE_VALUE (t);
8828 type = TREE_TYPE (t);
8830 gcc_assert (type != unknown_type_node);
8832 /* Reuse typedefs. We need to do this to handle dependent attributes,
8833 such as attribute aligned. */
8836 && TYPE_NAME (t) != TYPE_MAIN_DECL (t))
8838 tree decl = TYPE_NAME (t);
8840 if (DECL_CLASS_SCOPE_P (decl)
8841 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl)))
8843 tree tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
8844 tree gen_args = tsubst (DECL_TI_ARGS (decl), args, complain, in_decl);
8845 r = retrieve_specialization (tmpl, gen_args, false);
8847 else if (DECL_FUNCTION_SCOPE_P (decl))
8848 r = retrieve_local_specialization (decl);
8855 r = cp_build_qualified_type_real
8856 (r, cp_type_quals (t) | cp_type_quals (r),
8857 complain | tf_ignore_bad_quals);
8860 /* Else we must be instantiating the typedef, so fall through. */
8864 && TREE_CODE (t) != TYPENAME_TYPE
8865 && TREE_CODE (t) != IDENTIFIER_NODE
8866 && TREE_CODE (t) != FUNCTION_TYPE
8867 && TREE_CODE (t) != METHOD_TYPE)
8868 type = tsubst (type, args, complain, in_decl);
8869 if (type == error_mark_node)
8870 return error_mark_node;
8872 switch (TREE_CODE (t))
8877 return tsubst_aggr_type (t, args, complain, in_decl,
8878 /*entering_scope=*/0);
8881 case IDENTIFIER_NODE:
8893 if (t == integer_type_node)
8896 if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
8897 && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
8901 tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);
8903 max = tsubst_expr (omax, args, complain, in_decl,
8904 /*integral_constant_expression_p=*/false);
8905 max = fold_decl_constant_value (max);
8907 if (TREE_CODE (max) != INTEGER_CST
8908 && TREE_CODE (max) != TEMPLATE_PARM_INDEX
8909 && !at_function_scope_p ())
8911 if (complain & tf_error)
8912 error ("array bound is not an integer constant");
8913 return error_mark_node;
8918 Type deduction may fail for any of the following
8921 Attempting to create an array with a size that is
8922 zero or negative. */
8923 if (integer_zerop (max) && !(complain & tf_error))
8924 /* We must fail if performing argument deduction (as
8925 indicated by the state of complain), so that
8926 another substitution can be found. */
8927 return error_mark_node;
8928 else if (TREE_CODE (max) == INTEGER_CST
8929 && INT_CST_LT (max, integer_zero_node))
8931 if (complain & tf_error)
8932 error ("creating array with negative size (%qE)", max);
8934 return error_mark_node;
8937 return compute_array_index_type (NULL_TREE, max);
8940 case TEMPLATE_TYPE_PARM:
8941 case TEMPLATE_TEMPLATE_PARM:
8942 case BOUND_TEMPLATE_TEMPLATE_PARM:
8943 case TEMPLATE_PARM_INDEX:
8948 tree arg = NULL_TREE;
8952 gcc_assert (TREE_VEC_LENGTH (args) > 0);
8953 template_parm_level_and_index (t, &level, &idx);
8955 levels = TMPL_ARGS_DEPTH (args);
8956 if (level <= levels)
8958 arg = TMPL_ARG (args, level, idx);
8960 if (arg && TREE_CODE (arg) == ARGUMENT_PACK_SELECT)
8961 /* See through ARGUMENT_PACK_SELECT arguments. */
8962 arg = ARGUMENT_PACK_SELECT_ARG (arg);
8965 if (arg == error_mark_node)
8966 return error_mark_node;
8967 else if (arg != NULL_TREE)
8969 if (ARGUMENT_PACK_P (arg))
8970 /* If ARG is an argument pack, we don't actually want to
8971 perform a substitution here, because substitutions
8972 for argument packs are only done
8973 element-by-element. We can get to this point when
8974 substituting the type of a non-type template
8975 parameter pack, when that type actually contains
8976 template parameter packs from an outer template, e.g.,
8978 template<typename... Types> struct A {
8979 template<Types... Values> struct B { };
8983 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
8986 gcc_assert (TYPE_P (arg));
8988 /* cv-quals from the template are discarded when
8989 substituting in a function or reference type. */
8990 if (TREE_CODE (arg) == FUNCTION_TYPE
8991 || TREE_CODE (arg) == METHOD_TYPE
8992 || TREE_CODE (arg) == REFERENCE_TYPE)
8993 quals = cp_type_quals (arg);
8995 quals = cp_type_quals (arg) | cp_type_quals (t);
8997 return cp_build_qualified_type_real
8998 (arg, quals, complain | tf_ignore_bad_quals);
9000 else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
9002 /* We are processing a type constructed from a
9003 template template parameter. */
9004 tree argvec = tsubst (TYPE_TI_ARGS (t),
9005 args, complain, in_decl);
9006 if (argvec == error_mark_node)
9007 return error_mark_node;
9009 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
9010 are resolving nested-types in the signature of a
9011 member function templates. Otherwise ARG is a
9012 TEMPLATE_DECL and is the real template to be
9014 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
9015 arg = TYPE_NAME (arg);
9017 r = lookup_template_class (arg,
9020 /*entering_scope=*/0,
9022 return cp_build_qualified_type_real
9023 (r, TYPE_QUALS (t), complain);
9026 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
9031 /* This can happen during the attempted tsubst'ing in
9032 unify. This means that we don't yet have any information
9033 about the template parameter in question. */
9036 /* If we get here, we must have been looking at a parm for a
9037 more deeply nested template. Make a new version of this
9038 template parameter, but with a lower level. */
9039 switch (TREE_CODE (t))
9041 case TEMPLATE_TYPE_PARM:
9042 case TEMPLATE_TEMPLATE_PARM:
9043 case BOUND_TEMPLATE_TEMPLATE_PARM:
9044 if (cp_type_quals (t))
9046 r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
9047 r = cp_build_qualified_type_real
9048 (r, cp_type_quals (t),
9049 complain | (TREE_CODE (t) == TEMPLATE_TYPE_PARM
9050 ? tf_ignore_bad_quals : 0));
9055 TEMPLATE_TYPE_PARM_INDEX (r)
9056 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t),
9057 r, levels, args, complain);
9058 TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r);
9059 TYPE_MAIN_VARIANT (r) = r;
9060 TYPE_POINTER_TO (r) = NULL_TREE;
9061 TYPE_REFERENCE_TO (r) = NULL_TREE;
9063 if (TREE_CODE (r) == TEMPLATE_TEMPLATE_PARM)
9064 /* We have reduced the level of the template
9065 template parameter, but not the levels of its
9066 template parameters, so canonical_type_parameter
9067 will not be able to find the canonical template
9068 template parameter for this level. Thus, we
9069 require structural equality checking to compare
9070 TEMPLATE_TEMPLATE_PARMs. */
9071 SET_TYPE_STRUCTURAL_EQUALITY (r);
9072 else if (TYPE_STRUCTURAL_EQUALITY_P (t))
9073 SET_TYPE_STRUCTURAL_EQUALITY (r);
9075 TYPE_CANONICAL (r) = canonical_type_parameter (r);
9077 if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
9079 tree argvec = tsubst (TYPE_TI_ARGS (t), args,
9081 if (argvec == error_mark_node)
9082 return error_mark_node;
9084 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r)
9085 = tree_cons (TYPE_TI_TEMPLATE (t), argvec, NULL_TREE);
9090 case TEMPLATE_PARM_INDEX:
9091 r = reduce_template_parm_level (t, type, levels, args, complain);
9103 tree purpose, value, chain;
9105 if (t == void_list_node)
9108 purpose = TREE_PURPOSE (t);
9111 purpose = tsubst (purpose, args, complain, in_decl);
9112 if (purpose == error_mark_node)
9113 return error_mark_node;
9115 value = TREE_VALUE (t);
9118 value = tsubst (value, args, complain, in_decl);
9119 if (value == error_mark_node)
9120 return error_mark_node;
9122 chain = TREE_CHAIN (t);
9123 if (chain && chain != void_type_node)
9125 chain = tsubst (chain, args, complain, in_decl);
9126 if (chain == error_mark_node)
9127 return error_mark_node;
9129 if (purpose == TREE_PURPOSE (t)
9130 && value == TREE_VALUE (t)
9131 && chain == TREE_CHAIN (t))
9133 return hash_tree_cons (purpose, value, chain);
9137 /* We should never be tsubsting a binfo. */
9141 /* A vector of template arguments. */
9143 return tsubst_template_args (t, args, complain, in_decl);
9146 case REFERENCE_TYPE:
9148 enum tree_code code;
9150 if (type == TREE_TYPE (t) && TREE_CODE (type) != METHOD_TYPE)
9153 code = TREE_CODE (t);
9158 Type deduction may fail for any of the following
9161 -- Attempting to create a pointer to reference type.
9162 -- Attempting to create a reference to a reference type or
9163 a reference to void.
9165 Core issue 106 says that creating a reference to a reference
9166 during instantiation is no longer a cause for failure. We
9167 only enforce this check in strict C++98 mode. */
9168 if ((TREE_CODE (type) == REFERENCE_TYPE
9169 && (((cxx_dialect == cxx98) && flag_iso) || code != REFERENCE_TYPE))
9170 || (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE))
9172 static location_t last_loc;
9174 /* We keep track of the last time we issued this error
9175 message to avoid spewing a ton of messages during a
9176 single bad template instantiation. */
9177 if (complain & tf_error
9178 #ifdef USE_MAPPED_LOCATION
9179 && last_loc != input_location
9181 && (last_loc.line != input_line
9182 || last_loc.file != input_filename)
9186 if (TREE_CODE (type) == VOID_TYPE)
9187 error ("forming reference to void");
9189 error ("forming %s to reference type %qT",
9190 (code == POINTER_TYPE) ? "pointer" : "reference",
9192 last_loc = input_location;
9195 return error_mark_node;
9197 else if (code == POINTER_TYPE)
9199 r = build_pointer_type (type);
9200 if (TREE_CODE (type) == METHOD_TYPE)
9201 r = build_ptrmemfunc_type (r);
9203 else if (TREE_CODE (type) == REFERENCE_TYPE)
9204 /* In C++0x, during template argument substitution, when there is an
9205 attempt to create a reference to a reference type, reference
9206 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
9208 "If a template-argument for a template-parameter T names a type
9209 that is a reference to a type A, an attempt to create the type
9210 'lvalue reference to cv T' creates the type 'lvalue reference to
9211 A,' while an attempt to create the type type rvalue reference to
9212 cv T' creates the type T"
9214 r = cp_build_reference_type
9216 TYPE_REF_IS_RVALUE (t) && TYPE_REF_IS_RVALUE (type));
9218 r = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
9219 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
9221 if (r != error_mark_node)
9222 /* Will this ever be needed for TYPE_..._TO values? */
9229 r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
9230 if (r == error_mark_node || !IS_AGGR_TYPE (r))
9234 Type deduction may fail for any of the following
9237 -- Attempting to create "pointer to member of T" when T
9238 is not a class type. */
9239 if (complain & tf_error)
9240 error ("creating pointer to member of non-class type %qT", r);
9241 return error_mark_node;
9243 if (TREE_CODE (type) == REFERENCE_TYPE)
9245 if (complain & tf_error)
9246 error ("creating pointer to member reference type %qT", type);
9247 return error_mark_node;
9249 if (TREE_CODE (type) == VOID_TYPE)
9251 if (complain & tf_error)
9252 error ("creating pointer to member of type void");
9253 return error_mark_node;
9255 gcc_assert (TREE_CODE (type) != METHOD_TYPE);
9256 if (TREE_CODE (type) == FUNCTION_TYPE)
9258 /* The type of the implicit object parameter gets its
9259 cv-qualifiers from the FUNCTION_TYPE. */
9261 tree this_type = cp_build_qualified_type (TYPE_MAIN_VARIANT (r),
9262 cp_type_quals (type));
9264 method_type = build_method_type_directly (this_type,
9266 TYPE_ARG_TYPES (type));
9267 memptr = build_ptrmemfunc_type (build_pointer_type (method_type));
9268 return cp_build_qualified_type_real (memptr, cp_type_quals (t),
9272 return cp_build_qualified_type_real (build_ptrmem_type (r, type),
9281 fntype = tsubst_function_type (t, args, complain, in_decl);
9282 if (fntype == error_mark_node)
9283 return error_mark_node;
9285 /* Substitute the exception specification. */
9286 specs = tsubst_exception_specification (t, args, complain,
9288 if (specs == error_mark_node)
9289 return error_mark_node;
9291 fntype = build_exception_variant (fntype, specs);
9296 tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
9297 if (domain == error_mark_node)
9298 return error_mark_node;
9300 /* As an optimization, we avoid regenerating the array type if
9301 it will obviously be the same as T. */
9302 if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
9305 /* These checks should match the ones in grokdeclarator.
9309 The deduction may fail for any of the following reasons:
9311 -- Attempting to create an array with an element type that
9312 is void, a function type, or a reference type, or [DR337]
9313 an abstract class type. */
9314 if (TREE_CODE (type) == VOID_TYPE
9315 || TREE_CODE (type) == FUNCTION_TYPE
9316 || TREE_CODE (type) == REFERENCE_TYPE)
9318 if (complain & tf_error)
9319 error ("creating array of %qT", type);
9320 return error_mark_node;
9322 if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
9324 if (complain & tf_error)
9325 error ("creating array of %qT, which is an abstract class type",
9327 return error_mark_node;
9330 r = build_cplus_array_type (type, domain);
9332 if (TYPE_USER_ALIGN (t))
9334 TYPE_ALIGN (r) = TYPE_ALIGN (t);
9335 TYPE_USER_ALIGN (r) = 1;
9344 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
9345 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
9347 if (e1 == error_mark_node || e2 == error_mark_node)
9348 return error_mark_node;
9350 return fold_build2 (TREE_CODE (t), TREE_TYPE (t), e1, e2);
9356 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
9357 if (e == error_mark_node)
9358 return error_mark_node;
9360 return fold_build1 (TREE_CODE (t), TREE_TYPE (t), e);
9365 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
9366 in_decl, /*entering_scope=*/1);
9367 tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
9370 if (ctx == error_mark_node || f == error_mark_node)
9371 return error_mark_node;
9373 if (!IS_AGGR_TYPE (ctx))
9375 if (complain & tf_error)
9376 error ("%qT is not a class, struct, or union type", ctx);
9377 return error_mark_node;
9379 else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
9381 /* Normally, make_typename_type does not require that the CTX
9382 have complete type in order to allow things like:
9384 template <class T> struct S { typename S<T>::X Y; };
9386 But, such constructs have already been resolved by this
9387 point, so here CTX really should have complete type, unless
9388 it's a partial instantiation. */
9389 ctx = complete_type (ctx);
9390 if (!COMPLETE_TYPE_P (ctx))
9392 if (complain & tf_error)
9393 cxx_incomplete_type_error (NULL_TREE, ctx);
9394 return error_mark_node;
9398 f = make_typename_type (ctx, f, typename_type,
9399 (complain & tf_error) | tf_keep_type_decl);
9400 if (f == error_mark_node)
9402 if (TREE_CODE (f) == TYPE_DECL)
9404 complain |= tf_ignore_bad_quals;
9408 if (TREE_CODE (f) != TYPENAME_TYPE)
9410 if (TYPENAME_IS_ENUM_P (t) && TREE_CODE (f) != ENUMERAL_TYPE)
9411 error ("%qT resolves to %qT, which is not an enumeration type",
9413 else if (TYPENAME_IS_CLASS_P (t) && !CLASS_TYPE_P (f))
9414 error ("%qT resolves to %qT, which is is not a class type",
9418 return cp_build_qualified_type_real
9419 (f, cp_type_quals (f) | cp_type_quals (t), complain);
9422 case UNBOUND_CLASS_TEMPLATE:
9424 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
9425 in_decl, /*entering_scope=*/1);
9426 tree name = TYPE_IDENTIFIER (t);
9427 tree parm_list = DECL_TEMPLATE_PARMS (TYPE_NAME (t));
9429 if (ctx == error_mark_node || name == error_mark_node)
9430 return error_mark_node;
9433 parm_list = tsubst_template_parms (parm_list, args, complain);
9434 return make_unbound_class_template (ctx, name, parm_list, complain);
9444 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
9445 tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl,
9446 /*integral_constant_expression_p=*/false);
9447 if (e1 == error_mark_node || e2 == error_mark_node)
9448 return error_mark_node;
9450 return build_nt (ARRAY_REF, e1, e2, NULL_TREE, NULL_TREE);
9455 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
9456 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
9457 if (e1 == error_mark_node || e2 == error_mark_node)
9458 return error_mark_node;
9460 return build_qualified_name (/*type=*/NULL_TREE,
9461 e1, e2, QUALIFIED_NAME_IS_TEMPLATE (t));
9468 type = finish_typeof (tsubst_expr
9469 (TYPEOF_TYPE_EXPR (t), args,
9471 /*integral_constant_expression_p=*/false));
9472 return cp_build_qualified_type_real (type,
9474 | cp_type_quals (type),
9483 finish_decltype_type (tsubst_expr
9484 (DECLTYPE_TYPE_EXPR (t), args,
9486 /*integral_constant_expression_p=*/false),
9487 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t));
9488 return cp_build_qualified_type_real (type,
9490 | cp_type_quals (type),
9494 case TYPE_ARGUMENT_PACK:
9495 case NONTYPE_ARGUMENT_PACK:
9497 tree r = make_node (TREE_CODE (t));
9499 tsubst_template_args (ARGUMENT_PACK_ARGS (t),
9503 SET_ARGUMENT_PACK_ARGS (r, packed_out);
9505 /* For template nontype argument packs, also substitute into
9507 if (TREE_CODE (t) == NONTYPE_ARGUMENT_PACK)
9508 TREE_TYPE (r) = tsubst (TREE_TYPE (t), args, complain, in_decl);
9515 sorry ("use of %qs in template",
9516 tree_code_name [(int) TREE_CODE (t)]);
9517 return error_mark_node;
9521 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
9522 type of the expression on the left-hand side of the "." or "->"
9526 tsubst_baselink (tree baselink, tree object_type,
9527 tree args, tsubst_flags_t complain, tree in_decl)
9530 tree qualifying_scope;
9533 tree template_args = 0;
9534 bool template_id_p = false;
9536 /* A baselink indicates a function from a base class. Both the
9537 BASELINK_ACCESS_BINFO and the base class referenced may
9538 indicate bases of the template class, rather than the
9539 instantiated class. In addition, lookups that were not
9540 ambiguous before may be ambiguous now. Therefore, we perform
9541 the lookup again. */
9542 qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink));
9543 qualifying_scope = tsubst (qualifying_scope, args,
9545 fns = BASELINK_FUNCTIONS (baselink);
9546 optype = BASELINK_OPTYPE (baselink);
9547 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
9549 template_id_p = true;
9550 template_args = TREE_OPERAND (fns, 1);
9551 fns = TREE_OPERAND (fns, 0);
9553 template_args = tsubst_template_args (template_args, args,
9556 name = DECL_NAME (get_first_fn (fns));
9557 baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1);
9559 /* If lookup found a single function, mark it as used at this
9560 point. (If it lookup found multiple functions the one selected
9561 later by overload resolution will be marked as used at that
9563 if (BASELINK_P (baselink))
9564 fns = BASELINK_FUNCTIONS (baselink);
9565 if (!template_id_p && !really_overloaded_fn (fns))
9566 mark_used (OVL_CURRENT (fns));
9568 /* Add back the template arguments, if present. */
9569 if (BASELINK_P (baselink) && template_id_p)
9570 BASELINK_FUNCTIONS (baselink)
9571 = build_nt (TEMPLATE_ID_EXPR,
9572 BASELINK_FUNCTIONS (baselink),
9574 /* Update the conversion operator type. */
9575 BASELINK_OPTYPE (baselink)
9576 = tsubst (optype, args, complain, in_decl);
9579 object_type = current_class_type;
9580 return adjust_result_of_qualified_name_lookup (baselink,
9585 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
9586 true if the qualified-id will be a postfix-expression in-and-of
9587 itself; false if more of the postfix-expression follows the
9588 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
9592 tsubst_qualified_id (tree qualified_id, tree args,
9593 tsubst_flags_t complain, tree in_decl,
9594 bool done, bool address_p)
9602 gcc_assert (TREE_CODE (qualified_id) == SCOPE_REF);
9604 /* Figure out what name to look up. */
9605 name = TREE_OPERAND (qualified_id, 1);
9606 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
9609 template_args = TREE_OPERAND (name, 1);
9611 template_args = tsubst_template_args (template_args, args,
9613 name = TREE_OPERAND (name, 0);
9617 is_template = false;
9618 template_args = NULL_TREE;
9621 /* Substitute into the qualifying scope. When there are no ARGS, we
9622 are just trying to simplify a non-dependent expression. In that
9623 case the qualifying scope may be dependent, and, in any case,
9624 substituting will not help. */
9625 scope = TREE_OPERAND (qualified_id, 0);
9628 scope = tsubst (scope, args, complain, in_decl);
9629 expr = tsubst_copy (name, args, complain, in_decl);
9634 if (dependent_type_p (scope))
9635 return build_qualified_name (/*type=*/NULL_TREE,
9637 QUALIFIED_NAME_IS_TEMPLATE (qualified_id));
9639 if (!BASELINK_P (name) && !DECL_P (expr))
9641 if (TREE_CODE (expr) == BIT_NOT_EXPR)
9642 /* If this were actually a destructor call, it would have been
9643 parsed as such by the parser. */
9644 expr = error_mark_node;
9646 expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0, false);
9647 if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL
9648 ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL)
9650 if (complain & tf_error)
9652 error ("dependent-name %qE is parsed as a non-type, but "
9653 "instantiation yields a type", qualified_id);
9654 inform ("say %<typename %E%> if a type is meant", qualified_id);
9656 return error_mark_node;
9662 check_accessibility_of_qualified_id (expr, /*object_type=*/NULL_TREE,
9664 /* Remember that there was a reference to this entity. */
9668 if (expr == error_mark_node || TREE_CODE (expr) == TREE_LIST)
9670 if (complain & tf_error)
9671 qualified_name_lookup_error (scope,
9672 TREE_OPERAND (qualified_id, 1),
9674 return error_mark_node;
9678 expr = lookup_template_function (expr, template_args);
9680 if (expr == error_mark_node && complain & tf_error)
9681 qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1),
9683 else if (TYPE_P (scope))
9685 expr = (adjust_result_of_qualified_name_lookup
9686 (expr, scope, current_class_type));
9687 expr = (finish_qualified_id_expr
9688 (scope, expr, done, address_p,
9689 QUALIFIED_NAME_IS_TEMPLATE (qualified_id),
9690 /*template_arg_p=*/false));
9693 /* Expressions do not generally have reference type. */
9694 if (TREE_CODE (expr) != SCOPE_REF
9695 /* However, if we're about to form a pointer-to-member, we just
9696 want the referenced member referenced. */
9697 && TREE_CODE (expr) != OFFSET_REF)
9698 expr = convert_from_reference (expr);
9703 /* Like tsubst, but deals with expressions. This function just replaces
9704 template parms; to finish processing the resultant expression, use
9708 tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
9710 enum tree_code code;
9713 if (t == NULL_TREE || t == error_mark_node)
9716 code = TREE_CODE (t);
9721 r = retrieve_local_specialization (t);
9722 gcc_assert (r != NULL);
9723 if (TREE_CODE (r) == ARGUMENT_PACK_SELECT)
9724 r = ARGUMENT_PACK_SELECT_ARG (r);
9733 if (DECL_TEMPLATE_PARM_P (t))
9734 return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
9735 /* There is no need to substitute into namespace-scope
9737 if (DECL_NAMESPACE_SCOPE_P (t))
9739 /* If ARGS is NULL, then T is known to be non-dependent. */
9740 if (args == NULL_TREE)
9741 return integral_constant_value (t);
9743 /* Unfortunately, we cannot just call lookup_name here.
9746 template <int I> int f() {
9748 struct S { void g() { E e = a; } };
9751 When we instantiate f<7>::S::g(), say, lookup_name is not
9752 clever enough to find f<7>::a. */
9754 = tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl,
9755 /*entering_scope=*/0);
9757 for (v = TYPE_VALUES (enum_type);
9760 if (TREE_PURPOSE (v) == DECL_NAME (t))
9761 return TREE_VALUE (v);
9763 /* We didn't find the name. That should never happen; if
9764 name-lookup found it during preliminary parsing, we
9765 should find it again here during instantiation. */
9771 if (DECL_CONTEXT (t))
9775 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
9776 /*entering_scope=*/1);
9777 if (ctx != DECL_CONTEXT (t))
9779 tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
9782 if (complain & tf_error)
9783 error ("using invalid field %qD", t);
9784 return error_mark_node;
9794 if ((DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
9795 || local_variable_p (t))
9796 t = tsubst (t, args, complain, in_decl);
9801 return tsubst_baselink (t, current_class_type, args, complain, in_decl);
9804 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
9805 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
9806 args, complain, in_decl);
9807 else if (DECL_FUNCTION_TEMPLATE_P (t) && DECL_MEMBER_TEMPLATE_P (t))
9808 return tsubst (t, args, complain, in_decl);
9809 else if (DECL_CLASS_SCOPE_P (t)
9810 && uses_template_parms (DECL_CONTEXT (t)))
9812 /* Template template argument like the following example need
9815 template <template <class> class TT> struct C {};
9816 template <class T> struct D {
9817 template <class U> struct E {};
9822 We are processing the template argument `E' in #1 for
9823 the template instantiation #2. Originally, `E' is a
9824 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
9825 have to substitute this with one having context `D<int>'. */
9827 tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
9828 return lookup_field (context, DECL_NAME(t), 0, false);
9831 /* Ordinary template template argument. */
9835 case REINTERPRET_CAST_EXPR:
9836 case CONST_CAST_EXPR:
9837 case STATIC_CAST_EXPR:
9838 case DYNAMIC_CAST_EXPR:
9841 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
9842 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
9845 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
9847 /* We only want to compute the number of arguments. */
9848 tree expanded = tsubst_pack_expansion (TREE_OPERAND (t, 0), args,
9850 if (expanded == error_mark_node)
9851 return error_mark_node;
9852 return build_int_cst (size_type_node, TREE_VEC_LENGTH (expanded));
9858 case TRUTH_NOT_EXPR:
9861 case UNARY_PLUS_EXPR: /* Unary + */
9869 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
9870 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
9877 object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
9878 name = TREE_OPERAND (t, 1);
9879 if (TREE_CODE (name) == BIT_NOT_EXPR)
9881 name = tsubst_copy (TREE_OPERAND (name, 0), args,
9883 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
9885 else if (TREE_CODE (name) == SCOPE_REF
9886 && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
9888 tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
9890 name = TREE_OPERAND (name, 1);
9891 name = tsubst_copy (TREE_OPERAND (name, 0), args,
9893 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
9894 name = build_qualified_name (/*type=*/NULL_TREE,
9896 /*template_p=*/false);
9898 else if (TREE_CODE (name) == BASELINK)
9899 name = tsubst_baselink (name,
9900 non_reference (TREE_TYPE (object)),
9904 name = tsubst_copy (name, args, complain, in_decl);
9905 return build_nt (COMPONENT_REF, object, name, NULL_TREE);
9911 case TRUNC_DIV_EXPR:
9913 case FLOOR_DIV_EXPR:
9914 case ROUND_DIV_EXPR:
9915 case EXACT_DIV_EXPR:
9919 case TRUNC_MOD_EXPR:
9920 case FLOOR_MOD_EXPR:
9921 case TRUTH_ANDIF_EXPR:
9922 case TRUTH_ORIF_EXPR:
9923 case TRUTH_AND_EXPR:
9940 case PREDECREMENT_EXPR:
9941 case PREINCREMENT_EXPR:
9942 case POSTDECREMENT_EXPR:
9943 case POSTINCREMENT_EXPR:
9945 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9946 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
9949 return build_qualified_name (/*type=*/NULL_TREE,
9950 tsubst_copy (TREE_OPERAND (t, 0),
9951 args, complain, in_decl),
9952 tsubst_copy (TREE_OPERAND (t, 1),
9953 args, complain, in_decl),
9954 QUALIFIED_NAME_IS_TEMPLATE (t));
9959 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9960 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
9961 NULL_TREE, NULL_TREE);
9965 int n = VL_EXP_OPERAND_LENGTH (t);
9966 tree result = build_vl_exp (CALL_EXPR, n);
9968 for (i = 0; i < n; i++)
9969 TREE_OPERAND (t, i) = tsubst_copy (TREE_OPERAND (t, i), args,
9976 case PSEUDO_DTOR_EXPR:
9979 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9980 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
9981 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
9982 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
9989 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
9990 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
9991 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
9992 NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
9999 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
10000 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
10001 DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
10002 DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
10006 case TEMPLATE_ID_EXPR:
10008 /* Substituted template arguments */
10009 tree fn = TREE_OPERAND (t, 0);
10010 tree targs = TREE_OPERAND (t, 1);
10012 fn = tsubst_copy (fn, args, complain, in_decl);
10014 targs = tsubst_template_args (targs, args, complain, in_decl);
10016 return lookup_template_function (fn, targs);
10021 tree purpose, value, chain;
10023 if (t == void_list_node)
10026 purpose = TREE_PURPOSE (t);
10028 purpose = tsubst_copy (purpose, args, complain, in_decl);
10029 value = TREE_VALUE (t);
10031 value = tsubst_copy (value, args, complain, in_decl);
10032 chain = TREE_CHAIN (t);
10033 if (chain && chain != void_type_node)
10034 chain = tsubst_copy (chain, args, complain, in_decl);
10035 if (purpose == TREE_PURPOSE (t)
10036 && value == TREE_VALUE (t)
10037 && chain == TREE_CHAIN (t))
10039 return tree_cons (purpose, value, chain);
10044 case ENUMERAL_TYPE:
10046 case TEMPLATE_TYPE_PARM:
10047 case TEMPLATE_TEMPLATE_PARM:
10048 case BOUND_TEMPLATE_TEMPLATE_PARM:
10049 case TEMPLATE_PARM_INDEX:
10051 case REFERENCE_TYPE:
10053 case FUNCTION_TYPE:
10056 case TYPENAME_TYPE:
10057 case UNBOUND_CLASS_TEMPLATE:
10059 case DECLTYPE_TYPE:
10061 return tsubst (t, args, complain, in_decl);
10063 case IDENTIFIER_NODE:
10064 if (IDENTIFIER_TYPENAME_P (t))
10066 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10067 return mangle_conv_op_name_for_type (new_type);
10073 /* This is handled by tsubst_copy_and_build. */
10074 gcc_unreachable ();
10077 return build_x_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain,
10079 tsubst (TREE_TYPE (t), args, complain, in_decl));
10081 case CLEANUP_POINT_EXPR:
10082 /* We shouldn't have built any of these during initial template
10083 generation. Instead, they should be built during instantiation
10084 in response to the saved STMT_IS_FULL_EXPR_P setting. */
10085 gcc_unreachable ();
10088 mark_used (TREE_OPERAND (t, 1));
10091 case EXPR_PACK_EXPANSION:
10092 error ("invalid use of pack expansion expression");
10093 return error_mark_node;
10095 case NONTYPE_ARGUMENT_PACK:
10096 error ("use %<...%> to expand argument pack");
10097 return error_mark_node;
10104 /* Like tsubst_copy, but specifically for OpenMP clauses. */
10107 tsubst_omp_clauses (tree clauses, tree args, tsubst_flags_t complain,
10110 tree new_clauses = NULL, nc, oc;
10112 for (oc = clauses; oc ; oc = OMP_CLAUSE_CHAIN (oc))
10114 nc = copy_node (oc);
10115 OMP_CLAUSE_CHAIN (nc) = new_clauses;
10118 switch (OMP_CLAUSE_CODE (nc))
10120 case OMP_CLAUSE_PRIVATE:
10121 case OMP_CLAUSE_SHARED:
10122 case OMP_CLAUSE_FIRSTPRIVATE:
10123 case OMP_CLAUSE_LASTPRIVATE:
10124 case OMP_CLAUSE_REDUCTION:
10125 case OMP_CLAUSE_COPYIN:
10126 case OMP_CLAUSE_COPYPRIVATE:
10127 case OMP_CLAUSE_IF:
10128 case OMP_CLAUSE_NUM_THREADS:
10129 case OMP_CLAUSE_SCHEDULE:
10130 OMP_CLAUSE_OPERAND (nc, 0)
10131 = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 0), args, complain,
10132 in_decl, /*integral_constant_expression_p=*/false);
10134 case OMP_CLAUSE_NOWAIT:
10135 case OMP_CLAUSE_ORDERED:
10136 case OMP_CLAUSE_DEFAULT:
10139 gcc_unreachable ();
10143 return finish_omp_clauses (nreverse (new_clauses));
10146 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
10149 tsubst_copy_asm_operands (tree t, tree args, tsubst_flags_t complain,
10152 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
10154 tree purpose, value, chain;
10159 if (TREE_CODE (t) != TREE_LIST)
10160 return tsubst_copy_and_build (t, args, complain, in_decl,
10161 /*function_p=*/false,
10162 /*integral_constant_expression_p=*/false);
10164 if (t == void_list_node)
10167 purpose = TREE_PURPOSE (t);
10169 purpose = RECUR (purpose);
10170 value = TREE_VALUE (t);
10172 value = RECUR (value);
10173 chain = TREE_CHAIN (t);
10174 if (chain && chain != void_type_node)
10175 chain = RECUR (chain);
10176 return tree_cons (purpose, value, chain);
10180 /* Like tsubst_copy for expressions, etc. but also does semantic
10184 tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl,
10185 bool integral_constant_expression_p)
10187 #define RECUR(NODE) \
10188 tsubst_expr ((NODE), args, complain, in_decl, \
10189 integral_constant_expression_p)
10193 if (t == NULL_TREE || t == error_mark_node)
10196 if (EXPR_HAS_LOCATION (t))
10197 input_location = EXPR_LOCATION (t);
10198 if (STATEMENT_CODE_P (TREE_CODE (t)))
10199 current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
10201 switch (TREE_CODE (t))
10203 case STATEMENT_LIST:
10205 tree_stmt_iterator i;
10206 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
10207 RECUR (tsi_stmt (i));
10211 case CTOR_INITIALIZER:
10212 finish_mem_initializers (tsubst_initializer_list
10213 (TREE_OPERAND (t, 0), args));
10217 finish_return_stmt (RECUR (TREE_OPERAND (t, 0)));
10221 tmp = RECUR (EXPR_STMT_EXPR (t));
10222 if (EXPR_STMT_STMT_EXPR_RESULT (t))
10223 finish_stmt_expr_expr (tmp, cur_stmt_expr);
10225 finish_expr_stmt (tmp);
10229 do_using_directive (RECUR (USING_STMT_NAMESPACE (t)));
10237 decl = DECL_EXPR_DECL (t);
10238 if (TREE_CODE (decl) == LABEL_DECL)
10239 finish_label_decl (DECL_NAME (decl));
10240 else if (TREE_CODE (decl) == USING_DECL)
10242 tree scope = USING_DECL_SCOPE (decl);
10243 tree name = DECL_NAME (decl);
10246 scope = RECUR (scope);
10247 decl = lookup_qualified_name (scope, name,
10248 /*is_type_p=*/false,
10249 /*complain=*/false);
10250 if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
10251 qualified_name_lookup_error (scope, name, decl);
10253 do_local_using_decl (decl, scope, name);
10257 init = DECL_INITIAL (decl);
10258 decl = tsubst (decl, args, complain, in_decl);
10259 if (decl != error_mark_node)
10261 /* By marking the declaration as instantiated, we avoid
10262 trying to instantiate it. Since instantiate_decl can't
10263 handle local variables, and since we've already done
10264 all that needs to be done, that's the right thing to
10266 if (TREE_CODE (decl) == VAR_DECL)
10267 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
10268 if (TREE_CODE (decl) == VAR_DECL
10269 && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
10270 /* Anonymous aggregates are a special case. */
10271 finish_anon_union (decl);
10274 maybe_push_decl (decl);
10275 if (TREE_CODE (decl) == VAR_DECL
10276 && DECL_PRETTY_FUNCTION_P (decl))
10278 /* For __PRETTY_FUNCTION__ we have to adjust the
10280 const char *const name
10281 = cxx_printable_name (current_function_decl, 2);
10282 init = cp_fname_init (name, &TREE_TYPE (decl));
10286 tree t = RECUR (init);
10289 /* If we had an initializer but it
10290 instantiated to nothing,
10291 value-initialize the object. This will
10292 only occur when the initializer was a
10293 pack expansion where the parameter packs
10294 used in that expansion were of length
10296 init = build_default_init (TREE_TYPE (decl),
10302 finish_decl (decl, init, NULL_TREE);
10307 /* A DECL_EXPR can also be used as an expression, in the condition
10308 clause of an if/for/while construct. */
10313 stmt = begin_for_stmt ();
10314 RECUR (FOR_INIT_STMT (t));
10315 finish_for_init_stmt (stmt);
10316 tmp = RECUR (FOR_COND (t));
10317 finish_for_cond (tmp, stmt);
10318 tmp = RECUR (FOR_EXPR (t));
10319 finish_for_expr (tmp, stmt);
10320 RECUR (FOR_BODY (t));
10321 finish_for_stmt (stmt);
10325 stmt = begin_while_stmt ();
10326 tmp = RECUR (WHILE_COND (t));
10327 finish_while_stmt_cond (tmp, stmt);
10328 RECUR (WHILE_BODY (t));
10329 finish_while_stmt (stmt);
10333 stmt = begin_do_stmt ();
10334 RECUR (DO_BODY (t));
10335 finish_do_body (stmt);
10336 tmp = RECUR (DO_COND (t));
10337 finish_do_stmt (tmp, stmt);
10341 stmt = begin_if_stmt ();
10342 tmp = RECUR (IF_COND (t));
10343 finish_if_stmt_cond (tmp, stmt);
10344 RECUR (THEN_CLAUSE (t));
10345 finish_then_clause (stmt);
10347 if (ELSE_CLAUSE (t))
10349 begin_else_clause (stmt);
10350 RECUR (ELSE_CLAUSE (t));
10351 finish_else_clause (stmt);
10354 finish_if_stmt (stmt);
10358 if (BIND_EXPR_BODY_BLOCK (t))
10359 stmt = begin_function_body ();
10361 stmt = begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t)
10362 ? BCS_TRY_BLOCK : 0);
10364 RECUR (BIND_EXPR_BODY (t));
10366 if (BIND_EXPR_BODY_BLOCK (t))
10367 finish_function_body (stmt);
10369 finish_compound_stmt (stmt);
10373 finish_break_stmt ();
10376 case CONTINUE_STMT:
10377 finish_continue_stmt ();
10381 stmt = begin_switch_stmt ();
10382 tmp = RECUR (SWITCH_STMT_COND (t));
10383 finish_switch_cond (tmp, stmt);
10384 RECUR (SWITCH_STMT_BODY (t));
10385 finish_switch_stmt (stmt);
10388 case CASE_LABEL_EXPR:
10389 finish_case_label (RECUR (CASE_LOW (t)),
10390 RECUR (CASE_HIGH (t)));
10394 finish_label_stmt (DECL_NAME (LABEL_EXPR_LABEL (t)));
10398 tmp = GOTO_DESTINATION (t);
10399 if (TREE_CODE (tmp) != LABEL_DECL)
10400 /* Computed goto's must be tsubst'd into. On the other hand,
10401 non-computed gotos must not be; the identifier in question
10402 will have no binding. */
10405 tmp = DECL_NAME (tmp);
10406 finish_goto_stmt (tmp);
10410 tmp = finish_asm_stmt
10411 (ASM_VOLATILE_P (t),
10412 RECUR (ASM_STRING (t)),
10413 tsubst_copy_asm_operands (ASM_OUTPUTS (t), args, complain, in_decl),
10414 tsubst_copy_asm_operands (ASM_INPUTS (t), args, complain, in_decl),
10415 tsubst_copy_asm_operands (ASM_CLOBBERS (t), args, complain, in_decl));
10417 tree asm_expr = tmp;
10418 if (TREE_CODE (asm_expr) == CLEANUP_POINT_EXPR)
10419 asm_expr = TREE_OPERAND (asm_expr, 0);
10420 ASM_INPUT_P (asm_expr) = ASM_INPUT_P (t);
10427 stmt = begin_try_block ();
10428 RECUR (TRY_STMTS (t));
10429 finish_cleanup_try_block (stmt);
10430 finish_cleanup (RECUR (TRY_HANDLERS (t)), stmt);
10434 tree compound_stmt = NULL_TREE;
10436 if (FN_TRY_BLOCK_P (t))
10437 stmt = begin_function_try_block (&compound_stmt);
10439 stmt = begin_try_block ();
10441 RECUR (TRY_STMTS (t));
10443 if (FN_TRY_BLOCK_P (t))
10444 finish_function_try_block (stmt);
10446 finish_try_block (stmt);
10448 RECUR (TRY_HANDLERS (t));
10449 if (FN_TRY_BLOCK_P (t))
10450 finish_function_handler_sequence (stmt, compound_stmt);
10452 finish_handler_sequence (stmt);
10458 tree decl = HANDLER_PARMS (t);
10462 decl = tsubst (decl, args, complain, in_decl);
10463 /* Prevent instantiate_decl from trying to instantiate
10464 this variable. We've already done all that needs to be
10466 if (decl != error_mark_node)
10467 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
10469 stmt = begin_handler ();
10470 finish_handler_parms (decl, stmt);
10471 RECUR (HANDLER_BODY (t));
10472 finish_handler (stmt);
10477 tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
10480 case STATIC_ASSERT:
10483 tsubst_expr (STATIC_ASSERT_CONDITION (t),
10486 /*integral_constant_expression_p=*/true);
10487 finish_static_assert (condition,
10488 STATIC_ASSERT_MESSAGE (t),
10489 STATIC_ASSERT_SOURCE_LOCATION (t),
10490 /*member_p=*/false);
10495 tmp = tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t),
10496 args, complain, in_decl);
10497 stmt = begin_omp_parallel ();
10498 RECUR (OMP_PARALLEL_BODY (t));
10499 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp, stmt))
10500 = OMP_PARALLEL_COMBINED (t);
10505 tree clauses, decl, init, cond, incr, body, pre_body;
10507 clauses = tsubst_omp_clauses (OMP_FOR_CLAUSES (t),
10508 args, complain, in_decl);
10509 init = OMP_FOR_INIT (t);
10510 gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
10511 decl = RECUR (TREE_OPERAND (init, 0));
10512 init = RECUR (TREE_OPERAND (init, 1));
10513 cond = RECUR (OMP_FOR_COND (t));
10514 incr = RECUR (OMP_FOR_INCR (t));
10516 stmt = begin_omp_structured_block ();
10518 pre_body = push_stmt_list ();
10519 RECUR (OMP_FOR_PRE_BODY (t));
10520 pre_body = pop_stmt_list (pre_body);
10522 body = push_stmt_list ();
10523 RECUR (OMP_FOR_BODY (t));
10524 body = pop_stmt_list (body);
10526 t = finish_omp_for (EXPR_LOCATION (t), decl, init, cond, incr, body,
10529 OMP_FOR_CLAUSES (t) = clauses;
10531 add_stmt (finish_omp_structured_block (stmt));
10537 tmp = tsubst_omp_clauses (OMP_CLAUSES (t), args, complain, in_decl);
10538 stmt = push_stmt_list ();
10539 RECUR (OMP_BODY (t));
10540 stmt = pop_stmt_list (stmt);
10543 OMP_BODY (t) = stmt;
10544 OMP_CLAUSES (t) = tmp;
10552 stmt = push_stmt_list ();
10553 RECUR (OMP_BODY (t));
10554 stmt = pop_stmt_list (stmt);
10557 OMP_BODY (t) = stmt;
10562 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t));
10564 tree op1 = TREE_OPERAND (t, 1);
10565 tree lhs = RECUR (TREE_OPERAND (op1, 0));
10566 tree rhs = RECUR (TREE_OPERAND (op1, 1));
10567 finish_omp_atomic (TREE_CODE (op1), lhs, rhs);
10571 case EXPR_PACK_EXPANSION:
10572 error ("invalid use of pack expansion expression");
10573 return error_mark_node;
10575 case NONTYPE_ARGUMENT_PACK:
10576 error ("use %<...%> to expand argument pack");
10577 return error_mark_node;
10580 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t)));
10582 return tsubst_copy_and_build (t, args, complain, in_decl,
10583 /*function_p=*/false,
10584 integral_constant_expression_p);
10591 /* T is a postfix-expression that is not being used in a function
10592 call. Return the substituted version of T. */
10595 tsubst_non_call_postfix_expression (tree t, tree args,
10596 tsubst_flags_t complain,
10599 if (TREE_CODE (t) == SCOPE_REF)
10600 t = tsubst_qualified_id (t, args, complain, in_decl,
10601 /*done=*/false, /*address_p=*/false);
10603 t = tsubst_copy_and_build (t, args, complain, in_decl,
10604 /*function_p=*/false,
10605 /*integral_constant_expression_p=*/false);
10610 /* Like tsubst but deals with expressions and performs semantic
10611 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
10614 tsubst_copy_and_build (tree t,
10616 tsubst_flags_t complain,
10619 bool integral_constant_expression_p)
10621 #define RECUR(NODE) \
10622 tsubst_copy_and_build (NODE, args, complain, in_decl, \
10623 /*function_p=*/false, \
10624 integral_constant_expression_p)
10628 if (t == NULL_TREE || t == error_mark_node)
10631 switch (TREE_CODE (t))
10635 /* Fall through. */
10636 case IDENTIFIER_NODE:
10640 bool non_integral_constant_expression_p;
10641 const char *error_msg;
10643 if (IDENTIFIER_TYPENAME_P (t))
10645 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10646 t = mangle_conv_op_name_for_type (new_type);
10649 /* Look up the name. */
10650 decl = lookup_name (t);
10652 /* By convention, expressions use ERROR_MARK_NODE to indicate
10653 failure, not NULL_TREE. */
10654 if (decl == NULL_TREE)
10655 decl = error_mark_node;
10657 decl = finish_id_expression (t, decl, NULL_TREE,
10659 integral_constant_expression_p,
10660 /*allow_non_integral_constant_expression_p=*/false,
10661 &non_integral_constant_expression_p,
10662 /*template_p=*/false,
10664 /*address_p=*/false,
10665 /*template_arg_p=*/false,
10669 if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE)
10670 decl = unqualified_name_lookup_error (decl);
10674 case TEMPLATE_ID_EXPR:
10677 tree template = RECUR (TREE_OPERAND (t, 0));
10678 tree targs = TREE_OPERAND (t, 1);
10681 targs = tsubst_template_args (targs, args, complain, in_decl);
10683 if (TREE_CODE (template) == COMPONENT_REF)
10685 object = TREE_OPERAND (template, 0);
10686 template = TREE_OPERAND (template, 1);
10689 object = NULL_TREE;
10690 template = lookup_template_function (template, targs);
10693 return build3 (COMPONENT_REF, TREE_TYPE (template),
10694 object, template, NULL_TREE);
10696 return baselink_for_fns (template);
10701 tree r = RECUR (TREE_OPERAND (t, 0));
10703 if (REFERENCE_REF_P (t))
10705 /* A type conversion to reference type will be enclosed in
10706 such an indirect ref, but the substitution of the cast
10707 will have also added such an indirect ref. */
10708 if (TREE_CODE (TREE_TYPE (r)) == REFERENCE_TYPE)
10709 r = convert_from_reference (r);
10712 r = build_x_indirect_ref (r, "unary *");
10718 (tsubst (TREE_TYPE (t), args, complain, in_decl),
10719 RECUR (TREE_OPERAND (t, 0)));
10722 case REINTERPRET_CAST_EXPR:
10723 case CONST_CAST_EXPR:
10724 case DYNAMIC_CAST_EXPR:
10725 case STATIC_CAST_EXPR:
10730 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10731 if (integral_constant_expression_p
10732 && !cast_valid_in_integral_constant_expression_p (type))
10734 error ("a cast to a type other than an integral or "
10735 "enumeration type cannot appear in a constant-expression");
10736 return error_mark_node;
10739 op = RECUR (TREE_OPERAND (t, 0));
10741 switch (TREE_CODE (t))
10744 return build_functional_cast (type, op);
10745 case REINTERPRET_CAST_EXPR:
10746 return build_reinterpret_cast (type, op);
10747 case CONST_CAST_EXPR:
10748 return build_const_cast (type, op);
10749 case DYNAMIC_CAST_EXPR:
10750 return build_dynamic_cast (type, op);
10751 case STATIC_CAST_EXPR:
10752 return build_static_cast (type, op);
10754 gcc_unreachable ();
10758 case POSTDECREMENT_EXPR:
10759 case POSTINCREMENT_EXPR:
10760 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
10761 args, complain, in_decl);
10762 return build_x_unary_op (TREE_CODE (t), op1);
10764 case PREDECREMENT_EXPR:
10765 case PREINCREMENT_EXPR:
10769 case TRUTH_NOT_EXPR:
10770 case UNARY_PLUS_EXPR: /* Unary + */
10771 case REALPART_EXPR:
10772 case IMAGPART_EXPR:
10773 return build_x_unary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0)));
10776 op1 = TREE_OPERAND (t, 0);
10777 if (TREE_CODE (op1) == SCOPE_REF)
10778 op1 = tsubst_qualified_id (op1, args, complain, in_decl,
10779 /*done=*/true, /*address_p=*/true);
10781 op1 = tsubst_non_call_postfix_expression (op1, args, complain,
10783 if (TREE_CODE (op1) == LABEL_DECL)
10784 return finish_label_address_expr (DECL_NAME (op1));
10785 return build_x_unary_op (ADDR_EXPR, op1);
10790 case TRUNC_DIV_EXPR:
10791 case CEIL_DIV_EXPR:
10792 case FLOOR_DIV_EXPR:
10793 case ROUND_DIV_EXPR:
10794 case EXACT_DIV_EXPR:
10798 case TRUNC_MOD_EXPR:
10799 case FLOOR_MOD_EXPR:
10800 case TRUTH_ANDIF_EXPR:
10801 case TRUTH_ORIF_EXPR:
10802 case TRUTH_AND_EXPR:
10803 case TRUTH_OR_EXPR:
10818 return build_x_binary_op
10820 RECUR (TREE_OPERAND (t, 0)),
10821 (TREE_NO_WARNING (TREE_OPERAND (t, 0))
10823 : TREE_CODE (TREE_OPERAND (t, 0))),
10824 RECUR (TREE_OPERAND (t, 1)),
10825 (TREE_NO_WARNING (TREE_OPERAND (t, 1))
10827 : TREE_CODE (TREE_OPERAND (t, 1))),
10828 /*overloaded_p=*/NULL);
10831 return tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
10832 /*address_p=*/false);
10834 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
10835 args, complain, in_decl);
10836 return build_x_binary_op (ARRAY_REF, op1,
10837 (TREE_NO_WARNING (TREE_OPERAND (t, 0))
10839 : TREE_CODE (TREE_OPERAND (t, 0))),
10840 RECUR (TREE_OPERAND (t, 1)),
10841 (TREE_NO_WARNING (TREE_OPERAND (t, 1))
10843 : TREE_CODE (TREE_OPERAND (t, 1))),
10844 /*overloaded_p=*/NULL);
10847 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
10849 /* We only want to compute the number of arguments. */
10850 tree expanded = tsubst_pack_expansion (TREE_OPERAND (t, 0), args,
10851 complain, in_decl);
10852 if (expanded == error_mark_node)
10853 return error_mark_node;
10854 return build_int_cst (size_type_node, TREE_VEC_LENGTH (expanded));
10859 op1 = TREE_OPERAND (t, 0);
10862 /* When there are no ARGS, we are trying to evaluate a
10863 non-dependent expression from the parser. Trying to do
10864 the substitutions may not work. */
10866 op1 = TREE_TYPE (op1);
10871 op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
10872 /*function_p=*/false,
10873 /*integral_constant_expression_p=*/false);
10877 return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t), true);
10879 return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t));
10883 tree r = build_x_modify_expr
10884 (RECUR (TREE_OPERAND (t, 0)),
10885 TREE_CODE (TREE_OPERAND (t, 1)),
10886 RECUR (TREE_OPERAND (t, 2)));
10887 /* TREE_NO_WARNING must be set if either the expression was
10888 parenthesized or it uses an operator such as >>= rather
10889 than plain assignment. In the former case, it was already
10890 set and must be copied. In the latter case,
10891 build_x_modify_expr sets it and it must not be reset
10893 if (TREE_NO_WARNING (t))
10894 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
10899 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
10900 args, complain, in_decl);
10901 /* Remember that there was a reference to this entity. */
10904 return build_x_arrow (op1);
10908 tree init = RECUR (TREE_OPERAND (t, 3));
10910 if (TREE_OPERAND (t, 3) && !init)
10911 /* If there was an initializer in the the original tree, but
10912 it instantiated to an empty list, then we should pass on
10913 VOID_ZERO_NODE to tell build_new that it was an empty
10914 initializer () rather than no initializer. This can only
10915 happen when the initializer is a pack expansion whose
10916 parameter packs are of length zero. */
10917 init = void_zero_node;
10920 (RECUR (TREE_OPERAND (t, 0)),
10921 RECUR (TREE_OPERAND (t, 1)),
10922 RECUR (TREE_OPERAND (t, 2)),
10924 NEW_EXPR_USE_GLOBAL (t));
10928 return delete_sanity
10929 (RECUR (TREE_OPERAND (t, 0)),
10930 RECUR (TREE_OPERAND (t, 1)),
10931 DELETE_EXPR_USE_VEC (t),
10932 DELETE_EXPR_USE_GLOBAL (t));
10934 case COMPOUND_EXPR:
10935 return build_x_compound_expr (RECUR (TREE_OPERAND (t, 0)),
10936 RECUR (TREE_OPERAND (t, 1)));
10945 function = CALL_EXPR_FN (t);
10946 /* When we parsed the expression, we determined whether or
10947 not Koenig lookup should be performed. */
10948 koenig_p = KOENIG_LOOKUP_P (t);
10949 if (TREE_CODE (function) == SCOPE_REF)
10951 qualified_p = true;
10952 function = tsubst_qualified_id (function, args, complain, in_decl,
10954 /*address_p=*/false);
10958 if (TREE_CODE (function) == COMPONENT_REF)
10960 tree op = TREE_OPERAND (function, 1);
10962 qualified_p = (TREE_CODE (op) == SCOPE_REF
10963 || (BASELINK_P (op)
10964 && BASELINK_QUALIFIED_P (op)));
10967 qualified_p = false;
10969 function = tsubst_copy_and_build (function, args, complain,
10972 integral_constant_expression_p);
10974 if (BASELINK_P (function))
10975 qualified_p = true;
10978 /* FIXME: Rewrite this so as not to construct an arglist. */
10979 call_args = RECUR (CALL_EXPR_ARGS (t));
10981 /* We do not perform argument-dependent lookup if normal
10982 lookup finds a non-function, in accordance with the
10983 expected resolution of DR 218. */
10985 && ((is_overloaded_fn (function)
10986 /* If lookup found a member function, the Koenig lookup is
10987 not appropriate, even if an unqualified-name was used
10988 to denote the function. */
10989 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function)))
10990 || TREE_CODE (function) == IDENTIFIER_NODE))
10991 function = perform_koenig_lookup (function, call_args);
10993 if (TREE_CODE (function) == IDENTIFIER_NODE)
10995 unqualified_name_lookup_error (function);
10996 return error_mark_node;
10999 /* Remember that there was a reference to this entity. */
11000 if (DECL_P (function))
11001 mark_used (function);
11003 if (TREE_CODE (function) == OFFSET_REF)
11004 return build_offset_ref_call_from_tree (function, call_args);
11005 if (TREE_CODE (function) == COMPONENT_REF)
11007 if (!BASELINK_P (TREE_OPERAND (function, 1)))
11008 return finish_call_expr (function, call_args,
11009 /*disallow_virtual=*/false,
11010 /*koenig_p=*/false);
11012 return (build_new_method_call
11013 (TREE_OPERAND (function, 0),
11014 TREE_OPERAND (function, 1),
11015 call_args, NULL_TREE,
11016 qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL,
11019 return finish_call_expr (function, call_args,
11020 /*disallow_virtual=*/qualified_p,
11025 return build_x_conditional_expr
11026 (RECUR (TREE_OPERAND (t, 0)),
11027 RECUR (TREE_OPERAND (t, 1)),
11028 RECUR (TREE_OPERAND (t, 2)));
11030 case PSEUDO_DTOR_EXPR:
11031 return finish_pseudo_destructor_expr
11032 (RECUR (TREE_OPERAND (t, 0)),
11033 RECUR (TREE_OPERAND (t, 1)),
11034 RECUR (TREE_OPERAND (t, 2)));
11038 tree purpose, value, chain;
11040 if (t == void_list_node)
11043 if ((TREE_PURPOSE (t) && PACK_EXPANSION_P (TREE_PURPOSE (t)))
11044 || (TREE_VALUE (t) && PACK_EXPANSION_P (TREE_VALUE (t))))
11046 /* We have pack expansions, so expand those and
11047 create a new list out of it. */
11048 tree purposevec = NULL_TREE;
11049 tree valuevec = NULL_TREE;
11053 /* Expand the argument expressions. */
11054 if (TREE_PURPOSE (t))
11055 purposevec = tsubst_pack_expansion (TREE_PURPOSE (t), args,
11056 complain, in_decl);
11057 if (TREE_VALUE (t))
11058 valuevec = tsubst_pack_expansion (TREE_VALUE (t), args,
11059 complain, in_decl);
11061 /* Build the rest of the list. */
11062 chain = TREE_CHAIN (t);
11063 if (chain && chain != void_type_node)
11064 chain = RECUR (chain);
11066 /* Determine the number of arguments. */
11067 if (purposevec && TREE_CODE (purposevec) == TREE_VEC)
11069 len = TREE_VEC_LENGTH (purposevec);
11070 gcc_assert (!valuevec || len == TREE_VEC_LENGTH (valuevec));
11072 else if (TREE_CODE (valuevec) == TREE_VEC)
11073 len = TREE_VEC_LENGTH (valuevec);
11076 /* Since we only performed a partial substitution into
11077 the argument pack, we only return a single list
11079 if (purposevec == TREE_PURPOSE (t)
11080 && valuevec == TREE_VALUE (t)
11081 && chain == TREE_CHAIN (t))
11084 return tree_cons (purposevec, valuevec, chain);
11087 /* Convert the argument vectors into a TREE_LIST */
11091 /* Grab the Ith values. */
11093 purpose = purposevec ? TREE_VEC_ELT (purposevec, i)
11096 = valuevec ? convert_from_reference (TREE_VEC_ELT (valuevec, i))
11099 /* Build the list (backwards). */
11100 chain = tree_cons (purpose, value, chain);
11106 purpose = TREE_PURPOSE (t);
11108 purpose = RECUR (purpose);
11109 value = TREE_VALUE (t);
11111 value = RECUR (value);
11112 chain = TREE_CHAIN (t);
11113 if (chain && chain != void_type_node)
11114 chain = RECUR (chain);
11115 if (purpose == TREE_PURPOSE (t)
11116 && value == TREE_VALUE (t)
11117 && chain == TREE_CHAIN (t))
11119 return tree_cons (purpose, value, chain);
11122 case COMPONENT_REF:
11128 object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
11129 args, complain, in_decl);
11130 /* Remember that there was a reference to this entity. */
11131 if (DECL_P (object))
11132 mark_used (object);
11133 object_type = TREE_TYPE (object);
11135 member = TREE_OPERAND (t, 1);
11136 if (BASELINK_P (member))
11137 member = tsubst_baselink (member,
11138 non_reference (TREE_TYPE (object)),
11139 args, complain, in_decl);
11141 member = tsubst_copy (member, args, complain, in_decl);
11142 if (member == error_mark_node)
11143 return error_mark_node;
11145 if (object_type && !CLASS_TYPE_P (object_type))
11147 if (SCALAR_TYPE_P (object_type))
11149 tree s = NULL_TREE;
11150 tree dtor = member;
11152 if (TREE_CODE (dtor) == SCOPE_REF)
11154 s = TREE_OPERAND (dtor, 0);
11155 dtor = TREE_OPERAND (dtor, 1);
11157 if (TREE_CODE (dtor) == BIT_NOT_EXPR)
11159 dtor = TREE_OPERAND (dtor, 0);
11161 return finish_pseudo_destructor_expr (object, s, dtor);
11165 else if (TREE_CODE (member) == SCOPE_REF
11166 && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
11171 /* Lookup the template functions now that we know what the
11173 tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
11174 args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
11175 member = lookup_qualified_name (TREE_OPERAND (member, 0), tmpl,
11176 /*is_type_p=*/false,
11177 /*complain=*/false);
11178 if (BASELINK_P (member))
11180 BASELINK_FUNCTIONS (member)
11181 = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
11183 member = (adjust_result_of_qualified_name_lookup
11184 (member, BINFO_TYPE (BASELINK_BINFO (member)),
11189 qualified_name_lookup_error (object_type, tmpl, member);
11190 return error_mark_node;
11193 else if (TREE_CODE (member) == SCOPE_REF
11194 && !CLASS_TYPE_P (TREE_OPERAND (member, 0))
11195 && TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL)
11197 if (complain & tf_error)
11199 if (TYPE_P (TREE_OPERAND (member, 0)))
11200 error ("%qT is not a class or namespace",
11201 TREE_OPERAND (member, 0));
11203 error ("%qD is not a class or namespace",
11204 TREE_OPERAND (member, 0));
11206 return error_mark_node;
11208 else if (TREE_CODE (member) == FIELD_DECL)
11209 return finish_non_static_data_member (member, object, NULL_TREE);
11211 return finish_class_member_access_expr (object, member,
11212 /*template_p=*/false);
11217 (RECUR (TREE_OPERAND (t, 0)));
11221 VEC(constructor_elt,gc) *n;
11222 constructor_elt *ce;
11223 unsigned HOST_WIDE_INT idx;
11224 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
11225 bool process_index_p;
11227 bool need_copy_p = false;
11229 if (type == error_mark_node)
11230 return error_mark_node;
11232 /* digest_init will do the wrong thing if we let it. */
11233 if (type && TYPE_PTRMEMFUNC_P (type))
11236 /* We do not want to process the index of aggregate
11237 initializers as they are identifier nodes which will be
11238 looked up by digest_init. */
11239 process_index_p = !(type && IS_AGGR_TYPE (type));
11241 n = VEC_copy (constructor_elt, gc, CONSTRUCTOR_ELTS (t));
11242 newlen = VEC_length (constructor_elt, n);
11243 for (idx = 0; VEC_iterate (constructor_elt, n, idx, ce); idx++)
11245 if (ce->index && process_index_p)
11246 ce->index = RECUR (ce->index);
11248 if (PACK_EXPANSION_P (ce->value))
11250 /* Substitute into the pack expansion. */
11251 ce->value = tsubst_pack_expansion (ce->value, args, complain,
11254 if (ce->value == error_mark_node)
11256 else if (TREE_VEC_LENGTH (ce->value) == 1)
11257 /* Just move the argument into place. */
11258 ce->value = TREE_VEC_ELT (ce->value, 0);
11261 /* Update the length of the final CONSTRUCTOR
11262 arguments vector, and note that we will need to
11264 newlen = newlen + TREE_VEC_LENGTH (ce->value) - 1;
11265 need_copy_p = true;
11269 ce->value = RECUR (ce->value);
11274 VEC(constructor_elt,gc) *old_n = n;
11276 n = VEC_alloc (constructor_elt, gc, newlen);
11277 for (idx = 0; VEC_iterate (constructor_elt, old_n, idx, ce);
11280 if (TREE_CODE (ce->value) == TREE_VEC)
11282 int i, len = TREE_VEC_LENGTH (ce->value);
11283 for (i = 0; i < len; ++i)
11284 CONSTRUCTOR_APPEND_ELT (n, 0,
11285 TREE_VEC_ELT (ce->value, i));
11288 CONSTRUCTOR_APPEND_ELT (n, 0, ce->value);
11292 if (TREE_HAS_CONSTRUCTOR (t))
11293 return finish_compound_literal (type, n);
11295 return build_constructor (NULL_TREE, n);
11300 tree operand_0 = RECUR (TREE_OPERAND (t, 0));
11301 if (TYPE_P (operand_0))
11302 return get_typeid (operand_0);
11303 return build_typeid (operand_0);
11313 tree r = tsubst_copy (t, args, complain, in_decl);
11315 if (TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
11316 /* If the original type was a reference, we'll be wrapped in
11317 the appropriate INDIRECT_REF. */
11318 r = convert_from_reference (r);
11323 return build_x_va_arg (RECUR (TREE_OPERAND (t, 0)),
11324 tsubst_copy (TREE_TYPE (t), args, complain,
11327 case OFFSETOF_EXPR:
11328 return finish_offsetof (RECUR (TREE_OPERAND (t, 0)));
11332 tree type1 = tsubst_copy (TRAIT_EXPR_TYPE1 (t), args,
11333 complain, in_decl);
11335 tree type2 = TRAIT_EXPR_TYPE2 (t);
11337 type2 = tsubst_copy (type2, args, complain, in_decl);
11339 return finish_trait_expr (TRAIT_EXPR_KIND (t), type1, type2);
11344 tree old_stmt_expr = cur_stmt_expr;
11345 tree stmt_expr = begin_stmt_expr ();
11347 cur_stmt_expr = stmt_expr;
11348 tsubst_expr (STMT_EXPR_STMT (t), args, complain, in_decl,
11349 integral_constant_expression_p);
11350 stmt_expr = finish_stmt_expr (stmt_expr, false);
11351 cur_stmt_expr = old_stmt_expr;
11357 t = tsubst_copy (t, args, complain, in_decl);
11358 /* As in finish_id_expression, we resolve enumeration constants
11359 to their underlying values. */
11360 if (TREE_CODE (t) == CONST_DECL)
11362 used_types_insert (TREE_TYPE (t));
11363 return DECL_INITIAL (t);
11368 /* Handle Objective-C++ constructs, if appropriate. */
11371 = objcp_tsubst_copy_and_build (t, args, complain,
11372 in_decl, /*function_p=*/false);
11376 return tsubst_copy (t, args, complain, in_decl);
11382 /* Verify that the instantiated ARGS are valid. For type arguments,
11383 make sure that the type's linkage is ok. For non-type arguments,
11384 make sure they are constants if they are integral or enumerations.
11385 Emit an error under control of COMPLAIN, and return TRUE on error. */
11388 check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain)
11390 int ix, len = DECL_NTPARMS (tmpl);
11391 bool result = false;
11393 for (ix = 0; ix != len; ix++)
11395 tree t = TREE_VEC_ELT (args, ix);
11399 /* [basic.link]: A name with no linkage (notably, the name
11400 of a class or enumeration declared in a local scope)
11401 shall not be used to declare an entity with linkage.
11402 This implies that names with no linkage cannot be used as
11403 template arguments. */
11404 tree nt = no_linkage_check (t, /*relaxed_p=*/false);
11408 /* DR 488 makes use of a type with no linkage cause
11409 type deduction to fail. */
11410 if (complain & tf_error)
11412 if (TYPE_ANONYMOUS_P (nt))
11413 error ("%qT is/uses anonymous type", t);
11415 error ("template argument for %qD uses local type %qT",
11420 /* In order to avoid all sorts of complications, we do not
11421 allow variably-modified types as template arguments. */
11422 else if (variably_modified_type_p (t, NULL_TREE))
11424 if (complain & tf_error)
11425 error ("%qT is a variably modified type", t);
11429 /* A non-type argument of integral or enumerated type must be a
11431 else if (TREE_TYPE (t)
11432 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t))
11433 && !TREE_CONSTANT (t))
11435 if (complain & tf_error)
11436 error ("integral expression %qE is not constant", t);
11440 if (result && (complain & tf_error))
11441 error (" trying to instantiate %qD", tmpl);
11445 /* Instantiate the indicated variable or function template TMPL with
11446 the template arguments in TARG_PTR. */
11449 instantiate_template (tree tmpl, tree targ_ptr, tsubst_flags_t complain)
11454 HOST_WIDE_INT saved_processing_template_decl;
11456 if (tmpl == error_mark_node)
11457 return error_mark_node;
11459 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
11461 /* If this function is a clone, handle it specially. */
11462 if (DECL_CLONED_FUNCTION_P (tmpl))
11467 spec = instantiate_template (DECL_CLONED_FUNCTION (tmpl), targ_ptr,
11469 if (spec == error_mark_node)
11470 return error_mark_node;
11472 /* Look for the clone. */
11473 FOR_EACH_CLONE (clone, spec)
11474 if (DECL_NAME (clone) == DECL_NAME (tmpl))
11476 /* We should always have found the clone by now. */
11477 gcc_unreachable ();
11481 /* Check to see if we already have this specialization. */
11482 spec = retrieve_specialization (tmpl, targ_ptr,
11483 /*class_specializations_p=*/false);
11484 if (spec != NULL_TREE)
11487 gen_tmpl = most_general_template (tmpl);
11488 if (tmpl != gen_tmpl)
11490 /* The TMPL is a partial instantiation. To get a full set of
11491 arguments we must add the arguments used to perform the
11492 partial instantiation. */
11493 targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl),
11496 /* Check to see if we already have this specialization. */
11497 spec = retrieve_specialization (gen_tmpl, targ_ptr,
11498 /*class_specializations_p=*/false);
11499 if (spec != NULL_TREE)
11503 if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr),
11505 return error_mark_node;
11507 /* We are building a FUNCTION_DECL, during which the access of its
11508 parameters and return types have to be checked. However this
11509 FUNCTION_DECL which is the desired context for access checking
11510 is not built yet. We solve this chicken-and-egg problem by
11511 deferring all checks until we have the FUNCTION_DECL. */
11512 push_deferring_access_checks (dk_deferred);
11514 /* Although PROCESSING_TEMPLATE_DECL may be true at this point
11515 (because, for example, we have encountered a non-dependent
11516 function call in the body of a template function and must now
11517 determine which of several overloaded functions will be called),
11518 within the instantiation itself we are not processing a
11520 saved_processing_template_decl = processing_template_decl;
11521 processing_template_decl = 0;
11522 /* Substitute template parameters to obtain the specialization. */
11523 fndecl = tsubst (DECL_TEMPLATE_RESULT (gen_tmpl),
11524 targ_ptr, complain, gen_tmpl);
11525 processing_template_decl = saved_processing_template_decl;
11526 if (fndecl == error_mark_node)
11527 return error_mark_node;
11529 /* Now we know the specialization, compute access previously
11531 push_access_scope (fndecl);
11532 perform_deferred_access_checks ();
11533 pop_access_scope (fndecl);
11534 pop_deferring_access_checks ();
11536 /* The DECL_TI_TEMPLATE should always be the immediate parent
11537 template, not the most general template. */
11538 DECL_TI_TEMPLATE (fndecl) = tmpl;
11540 /* If we've just instantiated the main entry point for a function,
11541 instantiate all the alternate entry points as well. We do this
11542 by cloning the instantiation of the main entry point, not by
11543 instantiating the template clones. */
11544 if (TREE_CHAIN (gen_tmpl) && DECL_CLONED_FUNCTION_P (TREE_CHAIN (gen_tmpl)))
11545 clone_function_decl (fndecl, /*update_method_vec_p=*/0);
11550 /* The FN is a TEMPLATE_DECL for a function. The ARGS are the
11551 arguments that are being used when calling it. TARGS is a vector
11552 into which the deduced template arguments are placed.
11554 Return zero for success, 2 for an incomplete match that doesn't resolve
11555 all the types, and 1 for complete failure. An error message will be
11556 printed only for an incomplete match.
11558 If FN is a conversion operator, or we are trying to produce a specific
11559 specialization, RETURN_TYPE is the return type desired.
11561 The EXPLICIT_TARGS are explicit template arguments provided via a
11564 The parameter STRICT is one of:
11567 We are deducing arguments for a function call, as in
11568 [temp.deduct.call].
11571 We are deducing arguments for a conversion function, as in
11572 [temp.deduct.conv].
11575 We are deducing arguments when doing an explicit instantiation
11576 as in [temp.explicit], when determining an explicit specialization
11577 as in [temp.expl.spec], or when taking the address of a function
11578 template, as in [temp.deduct.funcaddr]. */
11581 fn_type_unification (tree fn,
11582 tree explicit_targs,
11586 unification_kind_t strict,
11592 bool incomplete_argument_packs_p = false;
11594 gcc_assert (TREE_CODE (fn) == TEMPLATE_DECL);
11596 fntype = TREE_TYPE (fn);
11597 if (explicit_targs)
11601 The specified template arguments must match the template
11602 parameters in kind (i.e., type, nontype, template), and there
11603 must not be more arguments than there are parameters;
11604 otherwise type deduction fails.
11606 Nontype arguments must match the types of the corresponding
11607 nontype template parameters, or must be convertible to the
11608 types of the corresponding nontype parameters as specified in
11609 _temp.arg.nontype_, otherwise type deduction fails.
11611 All references in the function type of the function template
11612 to the corresponding template parameters are replaced by the
11613 specified template argument values. If a substitution in a
11614 template parameter or in the function type of the function
11615 template results in an invalid type, type deduction fails. */
11616 tree tparms = DECL_INNERMOST_TEMPLATE_PARMS (fn);
11617 int i, len = TREE_VEC_LENGTH (tparms);
11618 tree converted_args;
11619 bool incomplete = false;
11621 if (explicit_targs == error_mark_node)
11625 = (coerce_template_parms (tparms, explicit_targs, NULL_TREE, tf_none,
11626 /*require_all_args=*/false,
11627 /*use_default_args=*/false));
11628 if (converted_args == error_mark_node)
11631 /* Substitute the explicit args into the function type. This is
11632 necessary so that, for instance, explicitly declared function
11633 arguments can match null pointed constants. If we were given
11634 an incomplete set of explicit args, we must not do semantic
11635 processing during substitution as we could create partial
11637 for (i = 0; i < len; i++)
11639 tree parm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
11640 bool parameter_pack = false;
11642 /* Dig out the actual parm. */
11643 if (TREE_CODE (parm) == TYPE_DECL
11644 || TREE_CODE (parm) == TEMPLATE_DECL)
11646 parm = TREE_TYPE (parm);
11647 parameter_pack = TEMPLATE_TYPE_PARAMETER_PACK (parm);
11649 else if (TREE_CODE (parm) == PARM_DECL)
11651 parm = DECL_INITIAL (parm);
11652 parameter_pack = TEMPLATE_PARM_PARAMETER_PACK (parm);
11655 if (parameter_pack)
11659 template_parm_level_and_index (parm, &level, &idx);
11661 /* Mark the argument pack as "incomplete". We could
11662 still deduce more arguments during unification. */
11663 targ = TMPL_ARG (converted_args, level, idx);
11666 ARGUMENT_PACK_INCOMPLETE_P(targ) = 1;
11667 ARGUMENT_PACK_EXPLICIT_ARGS (targ)
11668 = ARGUMENT_PACK_ARGS (targ);
11671 /* We have some incomplete argument packs. */
11672 incomplete_argument_packs_p = true;
11676 if (incomplete_argument_packs_p)
11677 /* Any substitution is guaranteed to be incomplete if there
11678 are incomplete argument packs, because we can still deduce
11682 incomplete = NUM_TMPL_ARGS (explicit_targs) != NUM_TMPL_ARGS (targs);
11684 processing_template_decl += incomplete;
11685 fntype = tsubst (fntype, converted_args, tf_none, NULL_TREE);
11686 processing_template_decl -= incomplete;
11688 if (fntype == error_mark_node)
11691 /* Place the explicitly specified arguments in TARGS. */
11692 for (i = NUM_TMPL_ARGS (converted_args); i--;)
11693 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i);
11696 /* Never do unification on the 'this' parameter. */
11697 parms = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (fntype));
11701 parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms);
11702 args = tree_cons (NULL_TREE, return_type, args);
11705 /* We allow incomplete unification without an error message here
11706 because the standard doesn't seem to explicitly prohibit it. Our
11707 callers must be ready to deal with unification failures in any
11709 result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
11710 targs, parms, args, /*subr=*/0,
11713 if (result == 0 && incomplete_argument_packs_p)
11715 int i, len = NUM_TMPL_ARGS (targs);
11717 /* Clear the "incomplete" flags on all argument packs. */
11718 for (i = 0; i < len; i++)
11720 tree arg = TREE_VEC_ELT (targs, i);
11721 if (ARGUMENT_PACK_P (arg))
11723 ARGUMENT_PACK_INCOMPLETE_P (arg) = 0;
11724 ARGUMENT_PACK_EXPLICIT_ARGS (arg) = NULL_TREE;
11729 /* Now that we have bindings for all of the template arguments,
11730 ensure that the arguments deduced for the template template
11731 parameters have compatible template parameter lists. We cannot
11732 check this property before we have deduced all template
11733 arguments, because the template parameter types of a template
11734 template parameter might depend on prior template parameters
11735 deduced after the template template parameter. The following
11736 ill-formed example illustrates this issue:
11738 template<typename T, template<T> class C> void f(C<5>, T);
11740 template<int N> struct X {};
11743 f(X<5>(), 5l); // error: template argument deduction fails
11746 The template parameter list of 'C' depends on the template type
11747 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
11748 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
11749 time that we deduce 'C'. */
11751 && !template_template_parm_bindings_ok_p
11752 (DECL_INNERMOST_TEMPLATE_PARMS (fn), targs))
11756 /* All is well so far. Now, check:
11760 When all template arguments have been deduced, all uses of
11761 template parameters in nondeduced contexts are replaced with
11762 the corresponding deduced argument values. If the
11763 substitution results in an invalid type, as described above,
11764 type deduction fails. */
11765 if (tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE)
11766 == error_mark_node)
11772 /* Adjust types before performing type deduction, as described in
11773 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
11774 sections are symmetric. PARM is the type of a function parameter
11775 or the return type of the conversion function. ARG is the type of
11776 the argument passed to the call, or the type of the value
11777 initialized with the result of the conversion function.
11778 ARG_EXPR is the original argument expression, which may be null. */
11781 maybe_adjust_types_for_deduction (unification_kind_t strict,
11795 /* Swap PARM and ARG throughout the remainder of this
11796 function; the handling is precisely symmetric since PARM
11797 will initialize ARG rather than vice versa. */
11805 /* There is nothing to do in this case. */
11809 gcc_unreachable ();
11812 if (TREE_CODE (*parm) != REFERENCE_TYPE)
11814 /* [temp.deduct.call]
11816 If P is not a reference type:
11818 --If A is an array type, the pointer type produced by the
11819 array-to-pointer standard conversion (_conv.array_) is
11820 used in place of A for type deduction; otherwise,
11822 --If A is a function type, the pointer type produced by
11823 the function-to-pointer standard conversion
11824 (_conv.func_) is used in place of A for type deduction;
11827 --If A is a cv-qualified type, the top level
11828 cv-qualifiers of A's type are ignored for type
11830 if (TREE_CODE (*arg) == ARRAY_TYPE)
11831 *arg = build_pointer_type (TREE_TYPE (*arg));
11832 else if (TREE_CODE (*arg) == FUNCTION_TYPE)
11833 *arg = build_pointer_type (*arg);
11835 *arg = TYPE_MAIN_VARIANT (*arg);
11838 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
11839 of the form T&&, where T is a template parameter, and the argument
11840 is an lvalue, T is deduced as A& */
11841 if (TREE_CODE (*parm) == REFERENCE_TYPE
11842 && TYPE_REF_IS_RVALUE (*parm)
11843 && TREE_CODE (TREE_TYPE (*parm)) == TEMPLATE_TYPE_PARM
11844 && cp_type_quals (TREE_TYPE (*parm)) == TYPE_UNQUALIFIED
11845 && arg_expr && real_lvalue_p (arg_expr))
11846 *arg = build_reference_type (*arg);
11848 /* [temp.deduct.call]
11850 If P is a cv-qualified type, the top level cv-qualifiers
11851 of P's type are ignored for type deduction. If P is a
11852 reference type, the type referred to by P is used for
11854 *parm = TYPE_MAIN_VARIANT (*parm);
11855 if (TREE_CODE (*parm) == REFERENCE_TYPE)
11857 *parm = TREE_TYPE (*parm);
11858 result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
11861 /* DR 322. For conversion deduction, remove a reference type on parm
11862 too (which has been swapped into ARG). */
11863 if (strict == DEDUCE_CONV && TREE_CODE (*arg) == REFERENCE_TYPE)
11864 *arg = TREE_TYPE (*arg);
11869 /* Most parms like fn_type_unification.
11871 If SUBR is 1, we're being called recursively (to unify the
11872 arguments of a function or method parameter of a function
11876 type_unification_real (tree tparms,
11881 unification_kind_t strict,
11884 tree parm, arg, arg_expr;
11886 int ntparms = TREE_VEC_LENGTH (tparms);
11888 int saw_undeduced = 0;
11891 gcc_assert (TREE_CODE (tparms) == TREE_VEC);
11892 gcc_assert (xparms == NULL_TREE || TREE_CODE (xparms) == TREE_LIST);
11893 gcc_assert (!xargs || TREE_CODE (xargs) == TREE_LIST);
11894 gcc_assert (ntparms > 0);
11899 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL | UNIFY_ALLOW_MORE_CV_QUAL
11900 | UNIFY_ALLOW_DERIVED);
11904 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
11908 sub_strict = UNIFY_ALLOW_NONE;
11912 gcc_unreachable ();
11919 while (parms && parms != void_list_node
11920 && args && args != void_list_node)
11922 if (TREE_CODE (TREE_VALUE (parms)) == TYPE_PACK_EXPANSION)
11925 parm = TREE_VALUE (parms);
11926 parms = TREE_CHAIN (parms);
11927 arg = TREE_VALUE (args);
11928 args = TREE_CHAIN (args);
11931 if (arg == error_mark_node)
11933 if (arg == unknown_type_node)
11934 /* We can't deduce anything from this, but we might get all the
11935 template args from other function args. */
11938 /* Conversions will be performed on a function argument that
11939 corresponds with a function parameter that contains only
11940 non-deducible template parameters and explicitly specified
11941 template parameters. */
11942 if (!uses_template_parms (parm))
11947 type = TREE_TYPE (arg);
11951 if (same_type_p (parm, type))
11953 if (strict != DEDUCE_EXACT
11954 && can_convert_arg (parm, type, TYPE_P (arg) ? NULL_TREE : arg,
11963 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
11964 if (type_unknown_p (arg))
11966 /* [temp.deduct.type]
11968 A template-argument can be deduced from a pointer to
11969 function or pointer to member function argument if
11970 the set of overloaded functions does not contain
11971 function templates and at most one of a set of
11972 overloaded functions provides a unique match. */
11973 if (resolve_overloaded_unification
11974 (tparms, targs, parm, arg, strict, sub_strict))
11980 arg = unlowered_expr_type (arg);
11981 if (arg == error_mark_node)
11986 int arg_strict = sub_strict;
11989 arg_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg,
11992 if (unify (tparms, targs, parm, arg, arg_strict))
11999 && parms != void_list_node
12000 && TREE_CODE (TREE_VALUE (parms)) == TYPE_PACK_EXPANSION)
12002 /* Unify the remaining arguments with the pack expansion type. */
12004 tree parmvec = make_tree_vec (1);
12008 /* Count the number of arguments that remain. */
12009 for (t = args; t && t != void_list_node; t = TREE_CHAIN (t))
12012 /* Allocate a TREE_VEC and copy in all of the arguments */
12013 argvec = make_tree_vec (len);
12014 for (i = 0; args && args != void_list_node; args = TREE_CHAIN (args))
12016 TREE_VEC_ELT (argvec, i) = TREE_VALUE (args);
12020 /* Copy the parameter into parmvec. */
12021 TREE_VEC_ELT (parmvec, 0) = TREE_VALUE (parms);
12022 if (unify_pack_expansion (tparms, targs, parmvec, argvec, strict,
12023 /*call_args_p=*/true, /*subr=*/subr))
12026 /* Advance to the end of the list of parameters. */
12027 parms = TREE_CHAIN (parms);
12030 /* Fail if we've reached the end of the parm list, and more args
12031 are present, and the parm list isn't variadic. */
12032 if (args && args != void_list_node && parms == void_list_node)
12034 /* Fail if parms are left and they don't have default values. */
12035 if (parms && parms != void_list_node
12036 && TREE_PURPOSE (parms) == NULL_TREE)
12040 for (i = 0; i < ntparms; i++)
12041 if (!TREE_VEC_ELT (targs, i))
12045 if (TREE_VEC_ELT (tparms, i) == error_mark_node)
12048 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
12050 /* If this is an undeduced nontype parameter that depends on
12051 a type parameter, try another pass; its type may have been
12052 deduced from a later argument than the one from which
12053 this parameter can be deduced. */
12054 if (TREE_CODE (tparm) == PARM_DECL
12055 && uses_template_parms (TREE_TYPE (tparm))
12056 && !saw_undeduced++)
12059 /* Core issue #226 (C++0x) [temp.deduct]:
12061 If a template argument has not been deduced, its
12062 default template argument, if any, is used.
12064 When we are in C++98 mode, TREE_PURPOSE will either
12065 be NULL_TREE or ERROR_MARK_NODE, so we do not need
12066 to explicitly check cxx_dialect here. */
12067 if (TREE_PURPOSE (TREE_VEC_ELT (tparms, i)))
12069 tree arg = tsubst (TREE_PURPOSE (TREE_VEC_ELT (tparms, i)),
12070 targs, tf_none, NULL_TREE);
12071 if (arg == error_mark_node)
12075 TREE_VEC_ELT (targs, i) = arg;
12080 /* If the type parameter is a parameter pack, then it will
12081 be deduced to an empty parameter pack. */
12082 if (template_parameter_pack_p (tparm))
12086 if (TREE_CODE (tparm) == TEMPLATE_PARM_INDEX)
12088 arg = make_node (NONTYPE_ARGUMENT_PACK);
12089 TREE_TYPE (arg) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm));
12090 TREE_CONSTANT (arg) = 1;
12093 arg = make_node (TYPE_ARGUMENT_PACK);
12095 SET_ARGUMENT_PACK_ARGS (arg, make_tree_vec (0));
12097 TREE_VEC_ELT (targs, i) = arg;
12107 /* Subroutine of type_unification_real. Args are like the variables
12108 at the call site. ARG is an overloaded function (or template-id);
12109 we try deducing template args from each of the overloads, and if
12110 only one succeeds, we go with that. Modifies TARGS and returns
12111 true on success. */
12114 resolve_overloaded_unification (tree tparms,
12118 unification_kind_t strict,
12121 tree tempargs = copy_node (targs);
12125 if (TREE_CODE (arg) == ADDR_EXPR)
12127 arg = TREE_OPERAND (arg, 0);
12133 if (TREE_CODE (arg) == COMPONENT_REF)
12134 /* Handle `&x' where `x' is some static or non-static member
12136 arg = TREE_OPERAND (arg, 1);
12138 if (TREE_CODE (arg) == OFFSET_REF)
12139 arg = TREE_OPERAND (arg, 1);
12141 /* Strip baselink information. */
12142 if (BASELINK_P (arg))
12143 arg = BASELINK_FUNCTIONS (arg);
12145 if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
12147 /* If we got some explicit template args, we need to plug them into
12148 the affected templates before we try to unify, in case the
12149 explicit args will completely resolve the templates in question. */
12151 tree expl_subargs = TREE_OPERAND (arg, 1);
12152 arg = TREE_OPERAND (arg, 0);
12154 for (; arg; arg = OVL_NEXT (arg))
12156 tree fn = OVL_CURRENT (arg);
12157 tree subargs, elem;
12159 if (TREE_CODE (fn) != TEMPLATE_DECL)
12162 subargs = get_bindings (fn, DECL_TEMPLATE_RESULT (fn),
12163 expl_subargs, /*check_ret=*/false);
12166 elem = tsubst (TREE_TYPE (fn), subargs, tf_none, NULL_TREE);
12167 good += try_one_overload (tparms, targs, tempargs, parm,
12168 elem, strict, sub_strict, addr_p);
12172 else if (TREE_CODE (arg) != OVERLOAD
12173 && TREE_CODE (arg) != FUNCTION_DECL)
12174 /* If ARG is, for example, "(0, &f)" then its type will be unknown
12175 -- but the deduction does not succeed because the expression is
12176 not just the function on its own. */
12179 for (; arg; arg = OVL_NEXT (arg))
12180 good += try_one_overload (tparms, targs, tempargs, parm,
12181 TREE_TYPE (OVL_CURRENT (arg)),
12182 strict, sub_strict, addr_p);
12184 /* [temp.deduct.type] A template-argument can be deduced from a pointer
12185 to function or pointer to member function argument if the set of
12186 overloaded functions does not contain function templates and at most
12187 one of a set of overloaded functions provides a unique match.
12189 So if we found multiple possibilities, we return success but don't
12190 deduce anything. */
12194 int i = TREE_VEC_LENGTH (targs);
12196 if (TREE_VEC_ELT (tempargs, i))
12197 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i);
12205 /* Subroutine of resolve_overloaded_unification; does deduction for a single
12206 overload. Fills TARGS with any deduced arguments, or error_mark_node if
12207 different overloads deduce different arguments for a given parm.
12208 ADDR_P is true if the expression for which deduction is being
12209 performed was of the form "& fn" rather than simply "fn".
12211 Returns 1 on success. */
12214 try_one_overload (tree tparms,
12219 unification_kind_t strict,
12227 /* [temp.deduct.type] A template-argument can be deduced from a pointer
12228 to function or pointer to member function argument if the set of
12229 overloaded functions does not contain function templates and at most
12230 one of a set of overloaded functions provides a unique match.
12232 So if this is a template, just return success. */
12234 if (uses_template_parms (arg))
12237 if (TREE_CODE (arg) == METHOD_TYPE)
12238 arg = build_ptrmemfunc_type (build_pointer_type (arg));
12240 arg = build_pointer_type (arg);
12242 sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg, NULL);
12244 /* We don't copy orig_targs for this because if we have already deduced
12245 some template args from previous args, unify would complain when we
12246 try to deduce a template parameter for the same argument, even though
12247 there isn't really a conflict. */
12248 nargs = TREE_VEC_LENGTH (targs);
12249 tempargs = make_tree_vec (nargs);
12251 if (unify (tparms, tempargs, parm, arg, sub_strict) != 0)
12254 /* First make sure we didn't deduce anything that conflicts with
12255 explicitly specified args. */
12256 for (i = nargs; i--; )
12258 tree elt = TREE_VEC_ELT (tempargs, i);
12259 tree oldelt = TREE_VEC_ELT (orig_targs, i);
12263 else if (uses_template_parms (elt))
12264 /* Since we're unifying against ourselves, we will fill in
12265 template args used in the function parm list with our own
12266 template parms. Discard them. */
12267 TREE_VEC_ELT (tempargs, i) = NULL_TREE;
12268 else if (oldelt && !template_args_equal (oldelt, elt))
12272 for (i = nargs; i--; )
12274 tree elt = TREE_VEC_ELT (tempargs, i);
12277 TREE_VEC_ELT (targs, i) = elt;
12283 /* PARM is a template class (perhaps with unbound template
12284 parameters). ARG is a fully instantiated type. If ARG can be
12285 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
12286 TARGS are as for unify. */
12289 try_class_unification (tree tparms, tree targs, tree parm, tree arg)
12291 tree copy_of_targs;
12293 if (!CLASSTYPE_TEMPLATE_INFO (arg)
12294 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg))
12295 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm))))
12298 /* We need to make a new template argument vector for the call to
12299 unify. If we used TARGS, we'd clutter it up with the result of
12300 the attempted unification, even if this class didn't work out.
12301 We also don't want to commit ourselves to all the unifications
12302 we've already done, since unification is supposed to be done on
12303 an argument-by-argument basis. In other words, consider the
12304 following pathological case:
12306 template <int I, int J, int K>
12309 template <int I, int J>
12310 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
12312 template <int I, int J, int K>
12313 void f(S<I, J, K>, S<I, I, I>);
12322 Now, by the time we consider the unification involving `s2', we
12323 already know that we must have `f<0, 0, 0>'. But, even though
12324 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
12325 because there are two ways to unify base classes of S<0, 1, 2>
12326 with S<I, I, I>. If we kept the already deduced knowledge, we
12327 would reject the possibility I=1. */
12328 copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs));
12330 /* If unification failed, we're done. */
12331 if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm),
12332 CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE))
12338 /* Given a template type PARM and a class type ARG, find the unique
12339 base type in ARG that is an instance of PARM. We do not examine
12340 ARG itself; only its base-classes. If there is not exactly one
12341 appropriate base class, return NULL_TREE. PARM may be the type of
12342 a partial specialization, as well as a plain template type. Used
12346 get_template_base (tree tparms, tree targs, tree parm, tree arg)
12348 tree rval = NULL_TREE;
12351 gcc_assert (IS_AGGR_TYPE_CODE (TREE_CODE (arg)));
12353 binfo = TYPE_BINFO (complete_type (arg));
12355 /* The type could not be completed. */
12358 /* Walk in inheritance graph order. The search order is not
12359 important, and this avoids multiple walks of virtual bases. */
12360 for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo))
12362 tree r = try_class_unification (tparms, targs, parm, BINFO_TYPE (binfo));
12366 /* If there is more than one satisfactory baseclass, then:
12370 If they yield more than one possible deduced A, the type
12374 if (rval && !same_type_p (r, rval))
12384 /* Returns the level of DECL, which declares a template parameter. */
12387 template_decl_level (tree decl)
12389 switch (TREE_CODE (decl))
12392 case TEMPLATE_DECL:
12393 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl));
12396 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
12399 gcc_unreachable ();
12404 /* Decide whether ARG can be unified with PARM, considering only the
12405 cv-qualifiers of each type, given STRICT as documented for unify.
12406 Returns nonzero iff the unification is OK on that basis. */
12409 check_cv_quals_for_unify (int strict, tree arg, tree parm)
12411 int arg_quals = cp_type_quals (arg);
12412 int parm_quals = cp_type_quals (parm);
12414 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
12415 && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
12417 /* Although a CVR qualifier is ignored when being applied to a
12418 substituted template parameter ([8.3.2]/1 for example), that
12419 does not apply during deduction [14.8.2.4]/1, (even though
12420 that is not explicitly mentioned, [14.8.2.4]/9 indicates
12421 this). Except when we're allowing additional CV qualifiers
12422 at the outer level [14.8.2.1]/3,1st bullet. */
12423 if ((TREE_CODE (arg) == REFERENCE_TYPE
12424 || TREE_CODE (arg) == FUNCTION_TYPE
12425 || TREE_CODE (arg) == METHOD_TYPE)
12426 && (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)))
12429 if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
12430 && (parm_quals & TYPE_QUAL_RESTRICT))
12434 if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
12435 && (arg_quals & parm_quals) != parm_quals)
12438 if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL))
12439 && (parm_quals & arg_quals) != arg_quals)
12445 /* Determines the LEVEL and INDEX for the template parameter PARM. */
12447 template_parm_level_and_index (tree parm, int* level, int* index)
12449 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
12450 || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
12451 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
12453 *index = TEMPLATE_TYPE_IDX (parm);
12454 *level = TEMPLATE_TYPE_LEVEL (parm);
12458 *index = TEMPLATE_PARM_IDX (parm);
12459 *level = TEMPLATE_PARM_LEVEL (parm);
12463 /* Unifies the remaining arguments in PACKED_ARGS with the pack
12464 expansion at the end of PACKED_PARMS. Returns 0 if the type
12465 deduction succeeds, 1 otherwise. STRICT is the same as in
12466 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
12467 call argument list. We'll need to adjust the arguments to make them
12468 types. SUBR tells us if this is from a recursive call to
12469 type_unification_real. */
12471 unify_pack_expansion (tree tparms, tree targs, tree packed_parms,
12472 tree packed_args, int strict, bool call_args_p,
12476 = TREE_VEC_ELT (packed_parms, TREE_VEC_LENGTH (packed_parms) - 1);
12477 tree pattern = PACK_EXPANSION_PATTERN (parm);
12478 tree pack, packs = NULL_TREE;
12479 int i, start = TREE_VEC_LENGTH (packed_parms) - 1;
12480 int len = TREE_VEC_LENGTH (packed_args);
12482 /* Determine the parameter packs we will be deducing from the
12483 pattern, and record their current deductions. */
12484 for (pack = PACK_EXPANSION_PARAMETER_PACKS (parm);
12485 pack; pack = TREE_CHAIN (pack))
12487 tree parm_pack = TREE_VALUE (pack);
12490 /* Determine the index and level of this parameter pack. */
12491 template_parm_level_and_index (parm_pack, &level, &idx);
12493 /* Keep track of the parameter packs and their corresponding
12495 packs = tree_cons (parm_pack, TMPL_ARG (targs, level, idx), packs);
12496 TREE_TYPE (packs) = make_tree_vec (len - start);
12499 /* Loop through all of the arguments that have not yet been
12500 unified and unify each with the pattern. */
12501 for (i = start; i < len; i++)
12503 tree parm = pattern;
12505 /* For each parameter pack, clear out the deduced value so that
12506 we can deduce it again. */
12507 for (pack = packs; pack; pack = TREE_CHAIN (pack))
12510 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12512 TMPL_ARG (targs, level, idx) = NULL_TREE;
12515 /* Unify the pattern with the current argument. */
12517 tree arg = TREE_VEC_ELT (packed_args, i);
12518 tree arg_expr = NULL_TREE;
12519 int arg_strict = strict;
12520 bool skip_arg_p = false;
12526 /* This mirrors what we do in type_unification_real. */
12530 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL
12531 | UNIFY_ALLOW_MORE_CV_QUAL
12532 | UNIFY_ALLOW_DERIVED);
12536 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
12540 sub_strict = UNIFY_ALLOW_NONE;
12544 gcc_unreachable ();
12549 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
12550 if (type_unknown_p (arg))
12552 /* [temp.deduct.type] A template-argument can be
12553 deduced from a pointer to function or pointer
12554 to member function argument if the set of
12555 overloaded functions does not contain function
12556 templates and at most one of a set of
12557 overloaded functions provides a unique
12560 if (resolve_overloaded_unification
12561 (tparms, targs, parm, arg, strict, sub_strict)
12570 arg = unlowered_expr_type (arg);
12571 if (arg == error_mark_node)
12576 arg_strict = sub_strict;
12580 maybe_adjust_types_for_deduction (strict, &parm, &arg,
12586 if (unify (tparms, targs, parm, arg, arg_strict))
12591 /* For each parameter pack, collect the deduced value. */
12592 for (pack = packs; pack; pack = TREE_CHAIN (pack))
12595 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12597 TREE_VEC_ELT (TREE_TYPE (pack), i - start) =
12598 TMPL_ARG (targs, level, idx);
12602 /* Verify that the results of unification with the parameter packs
12603 produce results consistent with what we've seen before, and make
12604 the deduced argument packs available. */
12605 for (pack = packs; pack; pack = TREE_CHAIN (pack))
12607 tree old_pack = TREE_VALUE (pack);
12608 tree new_args = TREE_TYPE (pack);
12609 int i, len = TREE_VEC_LENGTH (new_args);
12610 bool nondeduced_p = false;
12612 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
12613 actually deduce anything. */
12614 for (i = 0; i < len && !nondeduced_p; ++i)
12615 if (TREE_VEC_ELT (new_args, i) == NULL_TREE)
12616 nondeduced_p = true;
12620 if (old_pack && ARGUMENT_PACK_INCOMPLETE_P (old_pack))
12622 /* Prepend the explicit arguments onto NEW_ARGS. */
12623 tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
12624 tree old_args = new_args;
12625 int i, explicit_len = TREE_VEC_LENGTH (explicit_args);
12626 int len = explicit_len + TREE_VEC_LENGTH (old_args);
12628 /* Copy the explicit arguments. */
12629 new_args = make_tree_vec (len);
12630 for (i = 0; i < explicit_len; i++)
12631 TREE_VEC_ELT (new_args, i) = TREE_VEC_ELT (explicit_args, i);
12633 /* Copy the deduced arguments. */
12634 for (; i < len; i++)
12635 TREE_VEC_ELT (new_args, i) =
12636 TREE_VEC_ELT (old_args, i - explicit_len);
12644 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12646 /* Build the deduced *_ARGUMENT_PACK. */
12647 if (TREE_CODE (TREE_PURPOSE (pack)) == TEMPLATE_PARM_INDEX)
12649 result = make_node (NONTYPE_ARGUMENT_PACK);
12650 TREE_TYPE (result) =
12651 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack)));
12652 TREE_CONSTANT (result) = 1;
12655 result = make_node (TYPE_ARGUMENT_PACK);
12657 SET_ARGUMENT_PACK_ARGS (result, new_args);
12659 /* Note the deduced argument packs for this parameter
12661 TMPL_ARG (targs, level, idx) = result;
12663 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack)
12664 && (ARGUMENT_PACK_ARGS (old_pack)
12665 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack)))
12667 /* We only had the explicitly-provided arguments before, but
12668 now we have a complete set of arguments. */
12670 tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
12671 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12673 /* Keep the original deduced argument pack. */
12674 TMPL_ARG (targs, level, idx) = old_pack;
12676 SET_ARGUMENT_PACK_ARGS (old_pack, new_args);
12677 ARGUMENT_PACK_INCOMPLETE_P (old_pack) = 1;
12678 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack) = explicit_args;
12680 else if (!comp_template_args (ARGUMENT_PACK_ARGS (old_pack),
12682 /* Inconsistent unification of this parameter pack. */
12688 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
12690 /* Keep the original deduced argument pack. */
12691 TMPL_ARG (targs, level, idx) = old_pack;
12698 /* Deduce the value of template parameters. TPARMS is the (innermost)
12699 set of template parameters to a template. TARGS is the bindings
12700 for those template parameters, as determined thus far; TARGS may
12701 include template arguments for outer levels of template parameters
12702 as well. PARM is a parameter to a template function, or a
12703 subcomponent of that parameter; ARG is the corresponding argument.
12704 This function attempts to match PARM with ARG in a manner
12705 consistent with the existing assignments in TARGS. If more values
12706 are deduced, then TARGS is updated.
12708 Returns 0 if the type deduction succeeds, 1 otherwise. The
12709 parameter STRICT is a bitwise or of the following flags:
12712 Require an exact match between PARM and ARG.
12713 UNIFY_ALLOW_MORE_CV_QUAL:
12714 Allow the deduced ARG to be more cv-qualified (by qualification
12715 conversion) than ARG.
12716 UNIFY_ALLOW_LESS_CV_QUAL:
12717 Allow the deduced ARG to be less cv-qualified than ARG.
12718 UNIFY_ALLOW_DERIVED:
12719 Allow the deduced ARG to be a template base class of ARG,
12720 or a pointer to a template base class of the type pointed to by
12722 UNIFY_ALLOW_INTEGER:
12723 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
12724 case for more information.
12725 UNIFY_ALLOW_OUTER_LEVEL:
12726 This is the outermost level of a deduction. Used to determine validity
12727 of qualification conversions. A valid qualification conversion must
12728 have const qualified pointers leading up to the inner type which
12729 requires additional CV quals, except at the outer level, where const
12730 is not required [conv.qual]. It would be normal to set this flag in
12731 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
12732 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
12733 This is the outermost level of a deduction, and PARM can be more CV
12734 qualified at this point.
12735 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
12736 This is the outermost level of a deduction, and PARM can be less CV
12737 qualified at this point. */
12740 unify (tree tparms, tree targs, tree parm, tree arg, int strict)
12745 int strict_in = strict;
12747 /* I don't think this will do the right thing with respect to types.
12748 But the only case I've seen it in so far has been array bounds, where
12749 signedness is the only information lost, and I think that will be
12751 while (TREE_CODE (parm) == NOP_EXPR)
12752 parm = TREE_OPERAND (parm, 0);
12754 if (arg == error_mark_node)
12756 if (arg == unknown_type_node)
12757 /* We can't deduce anything from this, but we might get all the
12758 template args from other function args. */
12761 /* If PARM uses template parameters, then we can't bail out here,
12762 even if ARG == PARM, since we won't record unifications for the
12763 template parameters. We might need them if we're trying to
12764 figure out which of two things is more specialized. */
12765 if (arg == parm && !uses_template_parms (parm))
12768 /* Immediately reject some pairs that won't unify because of
12769 cv-qualification mismatches. */
12770 if (TREE_CODE (arg) == TREE_CODE (parm)
12772 /* It is the elements of the array which hold the cv quals of an array
12773 type, and the elements might be template type parms. We'll check
12774 when we recurse. */
12775 && TREE_CODE (arg) != ARRAY_TYPE
12776 /* We check the cv-qualifiers when unifying with template type
12777 parameters below. We want to allow ARG `const T' to unify with
12778 PARM `T' for example, when computing which of two templates
12779 is more specialized, for example. */
12780 && TREE_CODE (arg) != TEMPLATE_TYPE_PARM
12781 && !check_cv_quals_for_unify (strict_in, arg, parm))
12784 if (!(strict & UNIFY_ALLOW_OUTER_LEVEL)
12785 && TYPE_P (parm) && !CP_TYPE_CONST_P (parm))
12786 strict &= ~UNIFY_ALLOW_MORE_CV_QUAL;
12787 strict &= ~UNIFY_ALLOW_OUTER_LEVEL;
12788 strict &= ~UNIFY_ALLOW_DERIVED;
12789 strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
12790 strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL;
12792 switch (TREE_CODE (parm))
12794 case TYPENAME_TYPE:
12796 case UNBOUND_CLASS_TEMPLATE:
12797 /* In a type which contains a nested-name-specifier, template
12798 argument values cannot be deduced for template parameters used
12799 within the nested-name-specifier. */
12802 case TEMPLATE_TYPE_PARM:
12803 case TEMPLATE_TEMPLATE_PARM:
12804 case BOUND_TEMPLATE_TEMPLATE_PARM:
12805 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
12806 if (tparm == error_mark_node)
12809 if (TEMPLATE_TYPE_LEVEL (parm)
12810 != template_decl_level (tparm))
12811 /* The PARM is not one we're trying to unify. Just check
12812 to see if it matches ARG. */
12813 return (TREE_CODE (arg) == TREE_CODE (parm)
12814 && same_type_p (parm, arg)) ? 0 : 1;
12815 idx = TEMPLATE_TYPE_IDX (parm);
12816 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
12817 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx));
12819 /* Check for mixed types and values. */
12820 if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
12821 && TREE_CODE (tparm) != TYPE_DECL)
12822 || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
12823 && TREE_CODE (tparm) != TEMPLATE_DECL))
12826 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
12828 /* ARG must be constructed from a template class or a template
12829 template parameter. */
12830 if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM
12831 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg))
12835 tree parmvec = TYPE_TI_ARGS (parm);
12836 tree argvec = INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg));
12838 = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_TI_TEMPLATE (arg));
12840 int parm_variadic_p = 0;
12842 /* The resolution to DR150 makes clear that default
12843 arguments for an N-argument may not be used to bind T
12844 to a template template parameter with fewer than N
12845 parameters. It is not safe to permit the binding of
12846 default arguments as an extension, as that may change
12847 the meaning of a conforming program. Consider:
12849 struct Dense { static const unsigned int dim = 1; };
12851 template <template <typename> class View,
12853 void operator+(float, View<Block> const&);
12855 template <typename Block,
12856 unsigned int Dim = Block::dim>
12857 struct Lvalue_proxy { operator float() const; };
12861 Lvalue_proxy<Dense> p;
12866 Here, if Lvalue_proxy is permitted to bind to View, then
12867 the global operator+ will be used; if they are not, the
12868 Lvalue_proxy will be converted to float. */
12869 if (coerce_template_parms (argtmplvec, parmvec,
12870 TYPE_TI_TEMPLATE (parm),
12872 /*require_all_args=*/true,
12873 /*use_default_args=*/false)
12874 == error_mark_node)
12877 /* Deduce arguments T, i from TT<T> or TT<i>.
12878 We check each element of PARMVEC and ARGVEC individually
12879 rather than the whole TREE_VEC since they can have
12880 different number of elements. */
12882 parmvec = expand_template_argument_pack (parmvec);
12883 argvec = expand_template_argument_pack (argvec);
12885 len = TREE_VEC_LENGTH (parmvec);
12887 /* Check if the parameters end in a pack, making them
12890 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec, len - 1)))
12891 parm_variadic_p = 1;
12893 if (TREE_VEC_LENGTH (argvec) < len - parm_variadic_p)
12896 for (i = 0; i < len - parm_variadic_p; ++i)
12898 if (unify (tparms, targs,
12899 TREE_VEC_ELT (parmvec, i),
12900 TREE_VEC_ELT (argvec, i),
12905 if (parm_variadic_p
12906 && unify_pack_expansion (tparms, targs,
12909 /*call_args_p=*/false,
12913 arg = TYPE_TI_TEMPLATE (arg);
12915 /* Fall through to deduce template name. */
12918 if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
12919 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
12921 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
12923 /* Simple cases: Value already set, does match or doesn't. */
12924 if (targ != NULL_TREE && template_args_equal (targ, arg))
12931 /* If PARM is `const T' and ARG is only `int', we don't have
12932 a match unless we are allowing additional qualification.
12933 If ARG is `const int' and PARM is just `T' that's OK;
12934 that binds `const int' to `T'. */
12935 if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL,
12939 /* Consider the case where ARG is `const volatile int' and
12940 PARM is `const T'. Then, T should be `volatile int'. */
12941 arg = cp_build_qualified_type_real
12942 (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
12943 if (arg == error_mark_node)
12946 /* Simple cases: Value already set, does match or doesn't. */
12947 if (targ != NULL_TREE && same_type_p (targ, arg))
12952 /* Make sure that ARG is not a variable-sized array. (Note
12953 that were talking about variable-sized arrays (like
12954 `int[n]'), rather than arrays of unknown size (like
12955 `int[]').) We'll get very confused by such a type since
12956 the bound of the array will not be computable in an
12957 instantiation. Besides, such types are not allowed in
12958 ISO C++, so we can do as we please here. */
12959 if (variably_modified_type_p (arg, NULL_TREE))
12963 /* If ARG is a parameter pack or an expansion, we cannot unify
12964 against it unless PARM is also a parameter pack. */
12965 if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
12966 && !template_parameter_pack_p (parm))
12969 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
12972 case TEMPLATE_PARM_INDEX:
12973 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
12974 if (tparm == error_mark_node)
12977 if (TEMPLATE_PARM_LEVEL (parm)
12978 != template_decl_level (tparm))
12979 /* The PARM is not one we're trying to unify. Just check
12980 to see if it matches ARG. */
12981 return !(TREE_CODE (arg) == TREE_CODE (parm)
12982 && cp_tree_equal (parm, arg));
12984 idx = TEMPLATE_PARM_IDX (parm);
12985 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
12988 return !cp_tree_equal (targ, arg);
12990 /* [temp.deduct.type] If, in the declaration of a function template
12991 with a non-type template-parameter, the non-type
12992 template-parameter is used in an expression in the function
12993 parameter-list and, if the corresponding template-argument is
12994 deduced, the template-argument type shall match the type of the
12995 template-parameter exactly, except that a template-argument
12996 deduced from an array bound may be of any integral type.
12997 The non-type parameter might use already deduced type parameters. */
12998 tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE);
12999 if (!TREE_TYPE (arg))
13000 /* Template-parameter dependent expression. Just accept it for now.
13001 It will later be processed in convert_template_argument. */
13003 else if (same_type_p (TREE_TYPE (arg), tparm))
13005 else if ((strict & UNIFY_ALLOW_INTEGER)
13006 && (TREE_CODE (tparm) == INTEGER_TYPE
13007 || TREE_CODE (tparm) == BOOLEAN_TYPE))
13008 /* Convert the ARG to the type of PARM; the deduced non-type
13009 template argument must exactly match the types of the
13010 corresponding parameter. */
13011 arg = fold (build_nop (TREE_TYPE (parm), arg));
13012 else if (uses_template_parms (tparm))
13013 /* We haven't deduced the type of this parameter yet. Try again
13019 /* If ARG is a parameter pack or an expansion, we cannot unify
13020 against it unless PARM is also a parameter pack. */
13021 if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
13022 && !TEMPLATE_PARM_PARAMETER_PACK (parm))
13025 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
13030 /* A pointer-to-member constant can be unified only with
13031 another constant. */
13032 if (TREE_CODE (arg) != PTRMEM_CST)
13035 /* Just unify the class member. It would be useless (and possibly
13036 wrong, depending on the strict flags) to unify also
13037 PTRMEM_CST_CLASS, because we want to be sure that both parm and
13038 arg refer to the same variable, even if through different
13039 classes. For instance:
13041 struct A { int x; };
13044 Unification of &A::x and &B::x must succeed. */
13045 return unify (tparms, targs, PTRMEM_CST_MEMBER (parm),
13046 PTRMEM_CST_MEMBER (arg), strict);
13051 if (TREE_CODE (arg) != POINTER_TYPE)
13054 /* [temp.deduct.call]
13056 A can be another pointer or pointer to member type that can
13057 be converted to the deduced A via a qualification
13058 conversion (_conv.qual_).
13060 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
13061 This will allow for additional cv-qualification of the
13062 pointed-to types if appropriate. */
13064 if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
13065 /* The derived-to-base conversion only persists through one
13066 level of pointers. */
13067 strict |= (strict_in & UNIFY_ALLOW_DERIVED);
13069 return unify (tparms, targs, TREE_TYPE (parm),
13070 TREE_TYPE (arg), strict);
13073 case REFERENCE_TYPE:
13074 if (TREE_CODE (arg) != REFERENCE_TYPE)
13076 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
13077 strict & UNIFY_ALLOW_MORE_CV_QUAL);
13080 if (TREE_CODE (arg) != ARRAY_TYPE)
13082 if ((TYPE_DOMAIN (parm) == NULL_TREE)
13083 != (TYPE_DOMAIN (arg) == NULL_TREE))
13085 if (TYPE_DOMAIN (parm) != NULL_TREE)
13092 /* Our representation of array types uses "N - 1" as the
13093 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
13094 not an integer constant. We cannot unify arbitrarily
13095 complex expressions, so we eliminate the MINUS_EXPRs
13097 parm_max = TYPE_MAX_VALUE (TYPE_DOMAIN (parm));
13098 parm_cst = TREE_CODE (parm_max) == INTEGER_CST;
13101 gcc_assert (TREE_CODE (parm_max) == MINUS_EXPR);
13102 parm_max = TREE_OPERAND (parm_max, 0);
13104 arg_max = TYPE_MAX_VALUE (TYPE_DOMAIN (arg));
13105 arg_cst = TREE_CODE (arg_max) == INTEGER_CST;
13108 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
13109 trying to unify the type of a variable with the type
13110 of a template parameter. For example:
13112 template <unsigned int N>
13113 void f (char (&) [N]);
13120 Here, the type of the ARG will be "int [g(i)]", and
13121 may be a SAVE_EXPR, etc. */
13122 if (TREE_CODE (arg_max) != MINUS_EXPR)
13124 arg_max = TREE_OPERAND (arg_max, 0);
13127 /* If only one of the bounds used a MINUS_EXPR, compensate
13128 by adding one to the other bound. */
13129 if (parm_cst && !arg_cst)
13130 parm_max = fold_build2 (PLUS_EXPR,
13134 else if (arg_cst && !parm_cst)
13135 arg_max = fold_build2 (PLUS_EXPR,
13140 if (unify (tparms, targs, parm_max, arg_max, UNIFY_ALLOW_INTEGER))
13143 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
13144 strict & UNIFY_ALLOW_MORE_CV_QUAL);
13151 case ENUMERAL_TYPE:
13153 if (TREE_CODE (arg) != TREE_CODE (parm))
13156 /* We have already checked cv-qualification at the top of the
13158 if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
13161 /* As far as unification is concerned, this wins. Later checks
13162 will invalidate it if necessary. */
13165 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
13166 /* Type INTEGER_CST can come from ordinary constant template args. */
13168 while (TREE_CODE (arg) == NOP_EXPR)
13169 arg = TREE_OPERAND (arg, 0);
13171 if (TREE_CODE (arg) != INTEGER_CST)
13173 return !tree_int_cst_equal (parm, arg);
13178 if (TREE_CODE (arg) != TREE_VEC)
13180 if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
13182 for (i = 0; i < TREE_VEC_LENGTH (parm); ++i)
13183 if (unify (tparms, targs,
13184 TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
13192 if (TREE_CODE (arg) != TREE_CODE (parm))
13195 if (TYPE_PTRMEMFUNC_P (parm))
13197 if (!TYPE_PTRMEMFUNC_P (arg))
13200 return unify (tparms, targs,
13201 TYPE_PTRMEMFUNC_FN_TYPE (parm),
13202 TYPE_PTRMEMFUNC_FN_TYPE (arg),
13206 if (CLASSTYPE_TEMPLATE_INFO (parm))
13208 tree t = NULL_TREE;
13210 if (strict_in & UNIFY_ALLOW_DERIVED)
13212 /* First, we try to unify the PARM and ARG directly. */
13213 t = try_class_unification (tparms, targs,
13218 /* Fallback to the special case allowed in
13219 [temp.deduct.call]:
13221 If P is a class, and P has the form
13222 template-id, then A can be a derived class of
13223 the deduced A. Likewise, if P is a pointer to
13224 a class of the form template-id, A can be a
13225 pointer to a derived class pointed to by the
13227 t = get_template_base (tparms, targs, parm, arg);
13233 else if (CLASSTYPE_TEMPLATE_INFO (arg)
13234 && (CLASSTYPE_TI_TEMPLATE (parm)
13235 == CLASSTYPE_TI_TEMPLATE (arg)))
13236 /* Perhaps PARM is something like S<U> and ARG is S<int>.
13237 Then, we should unify `int' and `U'. */
13240 /* There's no chance of unification succeeding. */
13243 return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
13244 CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE);
13246 else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
13251 case FUNCTION_TYPE:
13252 if (TREE_CODE (arg) != TREE_CODE (parm))
13255 /* CV qualifications for methods can never be deduced, they must
13256 match exactly. We need to check them explicitly here,
13257 because type_unification_real treats them as any other
13258 cvqualified parameter. */
13259 if (TREE_CODE (parm) == METHOD_TYPE
13260 && (!check_cv_quals_for_unify
13262 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (arg))),
13263 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (parm))))))
13266 if (unify (tparms, targs, TREE_TYPE (parm),
13267 TREE_TYPE (arg), UNIFY_ALLOW_NONE))
13269 return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
13270 TYPE_ARG_TYPES (arg), 1, DEDUCE_EXACT,
13274 /* Unify a pointer to member with a pointer to member function, which
13275 deduces the type of the member as a function type. */
13276 if (TYPE_PTRMEMFUNC_P (arg))
13280 cp_cv_quals cv_quals;
13282 /* Check top-level cv qualifiers */
13283 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE, arg, parm))
13286 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
13287 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg), UNIFY_ALLOW_NONE))
13290 /* Determine the type of the function we are unifying against. */
13291 method_type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (arg));
13293 build_function_type (TREE_TYPE (method_type),
13294 TREE_CHAIN (TYPE_ARG_TYPES (method_type)));
13296 /* Extract the cv-qualifiers of the member function from the
13297 implicit object parameter and place them on the function
13298 type to be restored later. */
13300 cp_type_quals(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (method_type))));
13301 fntype = build_qualified_type (fntype, cv_quals);
13302 return unify (tparms, targs, TREE_TYPE (parm), fntype, strict);
13305 if (TREE_CODE (arg) != OFFSET_TYPE)
13307 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
13308 TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE))
13310 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
13314 if (DECL_TEMPLATE_PARM_P (parm))
13315 return unify (tparms, targs, DECL_INITIAL (parm), arg, strict);
13316 if (arg != integral_constant_value (parm))
13321 case TEMPLATE_DECL:
13322 /* Matched cases are handled by the ARG == PARM test above. */
13325 case TYPE_ARGUMENT_PACK:
13326 case NONTYPE_ARGUMENT_PACK:
13328 tree packed_parms = ARGUMENT_PACK_ARGS (parm);
13329 tree packed_args = ARGUMENT_PACK_ARGS (arg);
13330 int i, len = TREE_VEC_LENGTH (packed_parms);
13331 int argslen = TREE_VEC_LENGTH (packed_args);
13332 int parm_variadic_p = 0;
13334 for (i = 0; i < len; ++i)
13336 if (PACK_EXPANSION_P (TREE_VEC_ELT (packed_parms, i)))
13339 /* We can unify against something with a trailing
13341 parm_variadic_p = 1;
13343 /* Since there is something following the pack
13344 expansion, we cannot unify this template argument
13351 /* If we don't have enough arguments to satisfy the parameters
13352 (not counting the pack expression at the end), or we have
13353 too many arguments for a parameter list that doesn't end in
13354 a pack expression, we can't unify. */
13355 if (argslen < (len - parm_variadic_p)
13356 || (argslen > len && !parm_variadic_p))
13359 /* Unify all of the parameters that precede the (optional)
13360 pack expression. */
13361 for (i = 0; i < len - parm_variadic_p; ++i)
13363 if (unify (tparms, targs, TREE_VEC_ELT (packed_parms, i),
13364 TREE_VEC_ELT (packed_args, i), strict))
13368 if (parm_variadic_p)
13369 return unify_pack_expansion (tparms, targs,
13370 packed_parms, packed_args,
13371 strict, /*call_args_p=*/false,
13379 case DECLTYPE_TYPE:
13380 /* Cannot deduce anything from TYPEOF_TYPE or DECLTYPE_TYPE
13385 /* Unification fails if we hit an error node. */
13389 gcc_assert (EXPR_P (parm));
13391 /* We must be looking at an expression. This can happen with
13395 void foo(S<I>, S<I + 2>);
13397 This is a "nondeduced context":
13401 The nondeduced contexts are:
13403 --A type that is a template-id in which one or more of
13404 the template-arguments is an expression that references
13405 a template-parameter.
13407 In these cases, we assume deduction succeeded, but don't
13408 actually infer any unifications. */
13410 if (!uses_template_parms (parm)
13411 && !template_args_equal (parm, arg))
13418 /* Note that DECL can be defined in this translation unit, if
13422 mark_definable (tree decl)
13425 DECL_NOT_REALLY_EXTERN (decl) = 1;
13426 FOR_EACH_CLONE (clone, decl)
13427 DECL_NOT_REALLY_EXTERN (clone) = 1;
13430 /* Called if RESULT is explicitly instantiated, or is a member of an
13431 explicitly instantiated class. */
13434 mark_decl_instantiated (tree result, int extern_p)
13436 SET_DECL_EXPLICIT_INSTANTIATION (result);
13438 /* If this entity has already been written out, it's too late to
13439 make any modifications. */
13440 if (TREE_ASM_WRITTEN (result))
13443 if (TREE_CODE (result) != FUNCTION_DECL)
13444 /* The TREE_PUBLIC flag for function declarations will have been
13445 set correctly by tsubst. */
13446 TREE_PUBLIC (result) = 1;
13448 /* This might have been set by an earlier implicit instantiation. */
13449 DECL_COMDAT (result) = 0;
13452 DECL_NOT_REALLY_EXTERN (result) = 0;
13455 mark_definable (result);
13456 /* Always make artificials weak. */
13457 if (DECL_ARTIFICIAL (result) && flag_weak)
13458 comdat_linkage (result);
13459 /* For WIN32 we also want to put explicit instantiations in
13460 linkonce sections. */
13461 else if (TREE_PUBLIC (result))
13462 maybe_make_one_only (result);
13465 /* If EXTERN_P, then this function will not be emitted -- unless
13466 followed by an explicit instantiation, at which point its linkage
13467 will be adjusted. If !EXTERN_P, then this function will be
13468 emitted here. In neither circumstance do we want
13469 import_export_decl to adjust the linkage. */
13470 DECL_INTERFACE_KNOWN (result) = 1;
13473 /* Given two function templates PAT1 and PAT2, return:
13475 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
13476 -1 if PAT2 is more specialized than PAT1.
13477 0 if neither is more specialized.
13479 LEN indicates the number of parameters we should consider
13480 (defaulted parameters should not be considered).
13482 The 1998 std underspecified function template partial ordering, and
13483 DR214 addresses the issue. We take pairs of arguments, one from
13484 each of the templates, and deduce them against each other. One of
13485 the templates will be more specialized if all the *other*
13486 template's arguments deduce against its arguments and at least one
13487 of its arguments *does* *not* deduce against the other template's
13488 corresponding argument. Deduction is done as for class templates.
13489 The arguments used in deduction have reference and top level cv
13490 qualifiers removed. Iff both arguments were originally reference
13491 types *and* deduction succeeds in both directions, the template
13492 with the more cv-qualified argument wins for that pairing (if
13493 neither is more cv-qualified, they both are equal). Unlike regular
13494 deduction, after all the arguments have been deduced in this way,
13495 we do *not* verify the deduced template argument values can be
13496 substituted into non-deduced contexts, nor do we have to verify
13497 that all template arguments have been deduced. */
13500 more_specialized_fn (tree pat1, tree pat2, int len)
13502 tree decl1 = DECL_TEMPLATE_RESULT (pat1);
13503 tree decl2 = DECL_TEMPLATE_RESULT (pat2);
13504 tree targs1 = make_tree_vec (DECL_NTPARMS (pat1));
13505 tree targs2 = make_tree_vec (DECL_NTPARMS (pat2));
13506 tree tparms1 = DECL_INNERMOST_TEMPLATE_PARMS (pat1);
13507 tree tparms2 = DECL_INNERMOST_TEMPLATE_PARMS (pat2);
13508 tree args1 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
13509 tree args2 = TYPE_ARG_TYPES (TREE_TYPE (decl2));
13513 /* Remove the this parameter from non-static member functions. If
13514 one is a non-static member function and the other is not a static
13515 member function, remove the first parameter from that function
13516 also. This situation occurs for operator functions where we
13517 locate both a member function (with this pointer) and non-member
13518 operator (with explicit first operand). */
13519 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1))
13521 len--; /* LEN is the number of significant arguments for DECL1 */
13522 args1 = TREE_CHAIN (args1);
13523 if (!DECL_STATIC_FUNCTION_P (decl2))
13524 args2 = TREE_CHAIN (args2);
13526 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2))
13528 args2 = TREE_CHAIN (args2);
13529 if (!DECL_STATIC_FUNCTION_P (decl1))
13532 args1 = TREE_CHAIN (args1);
13536 /* If only one is a conversion operator, they are unordered. */
13537 if (DECL_CONV_FN_P (decl1) != DECL_CONV_FN_P (decl2))
13540 /* Consider the return type for a conversion function */
13541 if (DECL_CONV_FN_P (decl1))
13543 args1 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl1)), args1);
13544 args2 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl2)), args2);
13548 processing_template_decl++;
13552 tree arg1 = TREE_VALUE (args1);
13553 tree arg2 = TREE_VALUE (args2);
13554 int deduce1, deduce2;
13558 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
13559 && TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
13561 /* When both arguments are pack expansions, we need only
13562 unify the patterns themselves. */
13563 arg1 = PACK_EXPANSION_PATTERN (arg1);
13564 arg2 = PACK_EXPANSION_PATTERN (arg2);
13566 /* This is the last comparison we need to do. */
13570 if (TREE_CODE (arg1) == REFERENCE_TYPE)
13572 arg1 = TREE_TYPE (arg1);
13573 quals1 = cp_type_quals (arg1);
13576 if (TREE_CODE (arg2) == REFERENCE_TYPE)
13578 arg2 = TREE_TYPE (arg2);
13579 quals2 = cp_type_quals (arg2);
13582 if ((quals1 < 0) != (quals2 < 0))
13584 /* Only of the args is a reference, see if we should apply
13585 array/function pointer decay to it. This is not part of
13586 DR214, but is, IMHO, consistent with the deduction rules
13587 for the function call itself, and with our earlier
13588 implementation of the underspecified partial ordering
13589 rules. (nathan). */
13592 switch (TREE_CODE (arg1))
13595 arg1 = TREE_TYPE (arg1);
13597 case FUNCTION_TYPE:
13598 arg1 = build_pointer_type (arg1);
13607 switch (TREE_CODE (arg2))
13610 arg2 = TREE_TYPE (arg2);
13612 case FUNCTION_TYPE:
13613 arg2 = build_pointer_type (arg2);
13622 arg1 = TYPE_MAIN_VARIANT (arg1);
13623 arg2 = TYPE_MAIN_VARIANT (arg2);
13625 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION)
13627 int i, len2 = list_length (args2);
13628 tree parmvec = make_tree_vec (1);
13629 tree argvec = make_tree_vec (len2);
13632 /* Setup the parameter vector, which contains only ARG1. */
13633 TREE_VEC_ELT (parmvec, 0) = arg1;
13635 /* Setup the argument vector, which contains the remaining
13637 for (i = 0; i < len2; i++, ta = TREE_CHAIN (ta))
13638 TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
13640 deduce1 = !unify_pack_expansion (tparms1, targs1, parmvec,
13641 argvec, UNIFY_ALLOW_NONE,
13642 /*call_args_p=*/false,
13645 /* We cannot deduce in the other direction, because ARG1 is
13646 a pack expansion but ARG2 is not. */
13649 else if (TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
13651 int i, len1 = list_length (args1);
13652 tree parmvec = make_tree_vec (1);
13653 tree argvec = make_tree_vec (len1);
13656 /* Setup the parameter vector, which contains only ARG1. */
13657 TREE_VEC_ELT (parmvec, 0) = arg2;
13659 /* Setup the argument vector, which contains the remaining
13661 for (i = 0; i < len1; i++, ta = TREE_CHAIN (ta))
13662 TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
13664 deduce2 = !unify_pack_expansion (tparms2, targs2, parmvec,
13665 argvec, UNIFY_ALLOW_NONE,
13666 /*call_args_p=*/false,
13669 /* We cannot deduce in the other direction, because ARG2 is
13670 a pack expansion but ARG1 is not.*/
13676 /* The normal case, where neither argument is a pack
13678 deduce1 = !unify (tparms1, targs1, arg1, arg2, UNIFY_ALLOW_NONE);
13679 deduce2 = !unify (tparms2, targs2, arg2, arg1, UNIFY_ALLOW_NONE);
13686 if (better1 < 0 && better2 < 0)
13687 /* We've failed to deduce something in either direction.
13688 These must be unordered. */
13691 if (deduce1 && deduce2 && quals1 >= 0 && quals2 >= 0)
13693 /* Deduces in both directions, see if quals can
13694 disambiguate. Pretend the worse one failed to deduce. */
13695 if ((quals1 & quals2) == quals2)
13697 if ((quals1 & quals2) == quals1)
13700 if (deduce1 && !deduce2 && !better2)
13702 if (deduce2 && !deduce1 && !better1)
13705 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
13706 || TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
13707 /* We have already processed all of the arguments in our
13708 handing of the pack expansion type. */
13711 args1 = TREE_CHAIN (args1);
13712 args2 = TREE_CHAIN (args2);
13714 /* Stop when an ellipsis is seen. */
13715 if (args1 == NULL_TREE || args2 == NULL_TREE)
13719 processing_template_decl--;
13721 /* All things being equal, if the next argument is a pack expansion
13722 for one function but not for the other, prefer the
13723 non-variadic function. */
13724 if ((better1 > 0) - (better2 > 0) == 0
13725 && args1 && TREE_VALUE (args1)
13726 && args2 && TREE_VALUE (args2))
13728 if (TREE_CODE (TREE_VALUE (args1)) == TYPE_PACK_EXPANSION)
13729 return TREE_CODE (TREE_VALUE (args2)) == TYPE_PACK_EXPANSION ? 0 : -1;
13730 else if (TREE_CODE (TREE_VALUE (args2)) == TYPE_PACK_EXPANSION)
13734 return (better1 > 0) - (better2 > 0);
13737 /* Determine which of two partial specializations is more specialized.
13739 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
13740 to the first partial specialization. The TREE_VALUE is the
13741 innermost set of template parameters for the partial
13742 specialization. PAT2 is similar, but for the second template.
13744 Return 1 if the first partial specialization is more specialized;
13745 -1 if the second is more specialized; 0 if neither is more
13748 See [temp.class.order] for information about determining which of
13749 two templates is more specialized. */
13752 more_specialized_class (tree pat1, tree pat2)
13757 bool any_deductions = false;
13759 tmpl1 = TREE_TYPE (pat1);
13760 tmpl2 = TREE_TYPE (pat2);
13762 /* Just like what happens for functions, if we are ordering between
13763 different class template specializations, we may encounter dependent
13764 types in the arguments, and we need our dependency check functions
13765 to behave correctly. */
13766 ++processing_template_decl;
13767 targs = get_class_bindings (TREE_VALUE (pat1),
13768 CLASSTYPE_TI_ARGS (tmpl1),
13769 CLASSTYPE_TI_ARGS (tmpl2));
13773 any_deductions = true;
13776 targs = get_class_bindings (TREE_VALUE (pat2),
13777 CLASSTYPE_TI_ARGS (tmpl2),
13778 CLASSTYPE_TI_ARGS (tmpl1));
13782 any_deductions = true;
13784 --processing_template_decl;
13786 /* In the case of a tie where at least one of the class templates
13787 has a parameter pack at the end, the template with the most
13788 non-packed parameters wins. */
13791 && (template_args_variadic_p (TREE_PURPOSE (pat1))
13792 || template_args_variadic_p (TREE_PURPOSE (pat2))))
13794 tree args1 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1));
13795 tree args2 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2));
13796 int len1 = TREE_VEC_LENGTH (args1);
13797 int len2 = TREE_VEC_LENGTH (args2);
13799 /* We don't count the pack expansion at the end. */
13800 if (template_args_variadic_p (TREE_PURPOSE (pat1)))
13802 if (template_args_variadic_p (TREE_PURPOSE (pat2)))
13807 else if (len1 < len2)
13814 /* Return the template arguments that will produce the function signature
13815 DECL from the function template FN, with the explicit template
13816 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
13817 also match. Return NULL_TREE if no satisfactory arguments could be
13821 get_bindings (tree fn, tree decl, tree explicit_args, bool check_rettype)
13823 int ntparms = DECL_NTPARMS (fn);
13824 tree targs = make_tree_vec (ntparms);
13826 tree decl_arg_types;
13828 /* Substitute the explicit template arguments into the type of DECL.
13829 The call to fn_type_unification will handle substitution into the
13831 decl_type = TREE_TYPE (decl);
13832 if (explicit_args && uses_template_parms (decl_type))
13835 tree converted_args;
13837 if (DECL_TEMPLATE_INFO (decl))
13838 tmpl = DECL_TI_TEMPLATE (decl);
13840 /* We can get here for some invalid specializations. */
13844 = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
13845 explicit_args, NULL_TREE,
13847 /*require_all_args=*/false,
13848 /*use_default_args=*/false);
13849 if (converted_args == error_mark_node)
13852 decl_type = tsubst (decl_type, converted_args, tf_none, NULL_TREE);
13853 if (decl_type == error_mark_node)
13857 /* Never do unification on the 'this' parameter. */
13858 decl_arg_types = skip_artificial_parms_for (decl,
13859 TYPE_ARG_TYPES (decl_type));
13861 if (fn_type_unification (fn, explicit_args, targs,
13863 (check_rettype || DECL_CONV_FN_P (fn)
13864 ? TREE_TYPE (decl_type) : NULL_TREE),
13865 DEDUCE_EXACT, LOOKUP_NORMAL))
13871 /* Return the innermost template arguments that, when applied to a
13872 template specialization whose innermost template parameters are
13873 TPARMS, and whose specialization arguments are PARMS, yield the
13876 For example, suppose we have:
13878 template <class T, class U> struct S {};
13879 template <class T> struct S<T*, int> {};
13881 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
13882 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
13883 int}. The resulting vector will be {double}, indicating that `T'
13884 is bound to `double'. */
13887 get_class_bindings (tree tparms, tree spec_args, tree args)
13889 int i, ntparms = TREE_VEC_LENGTH (tparms);
13891 tree innermost_deduced_args;
13893 innermost_deduced_args = make_tree_vec (ntparms);
13894 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
13896 deduced_args = copy_node (args);
13897 SET_TMPL_ARGS_LEVEL (deduced_args,
13898 TMPL_ARGS_DEPTH (deduced_args),
13899 innermost_deduced_args);
13902 deduced_args = innermost_deduced_args;
13904 if (unify (tparms, deduced_args,
13905 INNERMOST_TEMPLATE_ARGS (spec_args),
13906 INNERMOST_TEMPLATE_ARGS (args),
13910 for (i = 0; i < ntparms; ++i)
13911 if (! TREE_VEC_ELT (innermost_deduced_args, i))
13914 /* Verify that nondeduced template arguments agree with the type
13915 obtained from argument deduction.
13919 struct A { typedef int X; };
13920 template <class T, class U> struct C {};
13921 template <class T> struct C<T, typename T::X> {};
13923 Then with the instantiation `C<A, int>', we can deduce that
13924 `T' is `A' but unify () does not check whether `typename T::X'
13926 spec_args = tsubst (spec_args, deduced_args, tf_none, NULL_TREE);
13927 if (spec_args == error_mark_node
13928 /* We only need to check the innermost arguments; the other
13929 arguments will always agree. */
13930 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args),
13931 INNERMOST_TEMPLATE_ARGS (args)))
13934 /* Now that we have bindings for all of the template arguments,
13935 ensure that the arguments deduced for the template template
13936 parameters have compatible template parameter lists. See the use
13937 of template_template_parm_bindings_ok_p in fn_type_unification
13938 for more information. */
13939 if (!template_template_parm_bindings_ok_p (tparms, deduced_args))
13942 return deduced_args;
13945 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
13946 Return the TREE_LIST node with the most specialized template, if
13947 any. If there is no most specialized template, the error_mark_node
13950 Note that this function does not look at, or modify, the
13951 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
13952 returned is one of the elements of INSTANTIATIONS, callers may
13953 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
13954 and retrieve it from the value returned. */
13957 most_specialized_instantiation (tree templates)
13961 ++processing_template_decl;
13964 for (fn = TREE_CHAIN (templates); fn; fn = TREE_CHAIN (fn))
13968 if (get_bindings (TREE_VALUE (champ),
13969 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
13970 NULL_TREE, /*check_ret=*/false))
13973 if (get_bindings (TREE_VALUE (fn),
13974 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
13975 NULL_TREE, /*check_ret=*/false))
13982 /* Equally specialized, move to next function. If there
13983 is no next function, nothing's most specialized. */
13984 fn = TREE_CHAIN (fn);
13992 /* Now verify that champ is better than everything earlier in the
13993 instantiation list. */
13994 for (fn = templates; fn != champ; fn = TREE_CHAIN (fn))
13995 if (get_bindings (TREE_VALUE (champ),
13996 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
13997 NULL_TREE, /*check_ret=*/false)
13998 || !get_bindings (TREE_VALUE (fn),
13999 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
14000 NULL_TREE, /*check_ret=*/false))
14006 processing_template_decl--;
14009 return error_mark_node;
14014 /* If DECL is a specialization of some template, return the most
14015 general such template. Otherwise, returns NULL_TREE.
14017 For example, given:
14019 template <class T> struct S { template <class U> void f(U); };
14021 if TMPL is `template <class U> void S<int>::f(U)' this will return
14022 the full template. This function will not trace past partial
14023 specializations, however. For example, given in addition:
14025 template <class T> struct S<T*> { template <class U> void f(U); };
14027 if TMPL is `template <class U> void S<int*>::f(U)' this will return
14028 `template <class T> template <class U> S<T*>::f(U)'. */
14031 most_general_template (tree decl)
14033 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
14034 an immediate specialization. */
14035 if (TREE_CODE (decl) == FUNCTION_DECL)
14037 if (DECL_TEMPLATE_INFO (decl)) {
14038 decl = DECL_TI_TEMPLATE (decl);
14040 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
14041 template friend. */
14042 if (TREE_CODE (decl) != TEMPLATE_DECL)
14048 /* Look for more and more general templates. */
14049 while (DECL_TEMPLATE_INFO (decl))
14051 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
14052 (See cp-tree.h for details.) */
14053 if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
14056 if (CLASS_TYPE_P (TREE_TYPE (decl))
14057 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
14060 /* Stop if we run into an explicitly specialized class template. */
14061 if (!DECL_NAMESPACE_SCOPE_P (decl)
14062 && DECL_CONTEXT (decl)
14063 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl)))
14066 decl = DECL_TI_TEMPLATE (decl);
14072 /* Return the most specialized of the class template partial
14073 specializations of TMPL which can produce TYPE, a specialization of
14074 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
14075 a _TYPE node corresponding to the partial specialization, while the
14076 TREE_PURPOSE is the set of template arguments that must be
14077 substituted into the TREE_TYPE in order to generate TYPE.
14079 If the choice of partial specialization is ambiguous, a diagnostic
14080 is issued, and the error_mark_node is returned. If there are no
14081 partial specializations of TMPL matching TYPE, then NULL_TREE is
14085 most_specialized_class (tree type, tree tmpl)
14087 tree list = NULL_TREE;
14093 tree outer_args = NULL_TREE;
14095 tmpl = most_general_template (tmpl);
14096 args = CLASSTYPE_TI_ARGS (type);
14098 /* For determining which partial specialization to use, only the
14099 innermost args are interesting. */
14100 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
14102 outer_args = strip_innermost_template_args (args, 1);
14103 args = INNERMOST_TEMPLATE_ARGS (args);
14106 for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t))
14108 tree partial_spec_args;
14110 tree parms = TREE_VALUE (t);
14112 partial_spec_args = CLASSTYPE_TI_ARGS (TREE_TYPE (t));
14117 ++processing_template_decl;
14119 /* Discard the outer levels of args, and then substitute in the
14120 template args from the enclosing class. */
14121 partial_spec_args = INNERMOST_TEMPLATE_ARGS (partial_spec_args);
14122 partial_spec_args = tsubst_template_args
14123 (partial_spec_args, outer_args, tf_none, NULL_TREE);
14125 /* PARMS already refers to just the innermost parms, but the
14126 template parms in partial_spec_args had their levels lowered
14127 by tsubst, so we need to do the same for the parm list. We
14128 can't just tsubst the TREE_VEC itself, as tsubst wants to
14129 treat a TREE_VEC as an argument vector. */
14130 parms = copy_node (parms);
14131 for (i = TREE_VEC_LENGTH (parms) - 1; i >= 0; --i)
14132 TREE_VEC_ELT (parms, i) =
14133 tsubst (TREE_VEC_ELT (parms, i), outer_args, tf_none, NULL_TREE);
14135 --processing_template_decl;
14137 spec_args = get_class_bindings (parms,
14143 spec_args = add_to_template_args (outer_args, spec_args);
14144 list = tree_cons (spec_args, TREE_VALUE (t), list);
14145 TREE_TYPE (list) = TREE_TYPE (t);
14152 ambiguous_p = false;
14155 t = TREE_CHAIN (t);
14156 for (; t; t = TREE_CHAIN (t))
14158 fate = more_specialized_class (champ, t);
14165 t = TREE_CHAIN (t);
14168 ambiguous_p = true;
14177 for (t = list; t && t != champ; t = TREE_CHAIN (t))
14179 fate = more_specialized_class (champ, t);
14182 ambiguous_p = true;
14189 const char *str = "candidates are:";
14190 error ("ambiguous class template instantiation for %q#T", type);
14191 for (t = list; t; t = TREE_CHAIN (t))
14193 error ("%s %+#T", str, TREE_TYPE (t));
14196 return error_mark_node;
14202 /* Explicitly instantiate DECL. */
14205 do_decl_instantiation (tree decl, tree storage)
14207 tree result = NULL_TREE;
14210 if (!decl || decl == error_mark_node)
14211 /* An error occurred, for which grokdeclarator has already issued
14212 an appropriate message. */
14214 else if (! DECL_LANG_SPECIFIC (decl))
14216 error ("explicit instantiation of non-template %q#D", decl);
14219 else if (TREE_CODE (decl) == VAR_DECL)
14221 /* There is an asymmetry here in the way VAR_DECLs and
14222 FUNCTION_DECLs are handled by grokdeclarator. In the case of
14223 the latter, the DECL we get back will be marked as a
14224 template instantiation, and the appropriate
14225 DECL_TEMPLATE_INFO will be set up. This does not happen for
14226 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
14227 should handle VAR_DECLs as it currently handles
14229 if (!DECL_CLASS_SCOPE_P (decl))
14231 error ("%qD is not a static data member of a class template", decl);
14234 result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false);
14235 if (!result || TREE_CODE (result) != VAR_DECL)
14237 error ("no matching template for %qD found", decl);
14240 if (!same_type_p (TREE_TYPE (result), TREE_TYPE (decl)))
14242 error ("type %qT for explicit instantiation %qD does not match "
14243 "declared type %qT", TREE_TYPE (result), decl,
14248 else if (TREE_CODE (decl) != FUNCTION_DECL)
14250 error ("explicit instantiation of %q#D", decl);
14256 /* Check for various error cases. Note that if the explicit
14257 instantiation is valid the RESULT will currently be marked as an
14258 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
14259 until we get here. */
14261 if (DECL_TEMPLATE_SPECIALIZATION (result))
14263 /* DR 259 [temp.spec].
14265 Both an explicit instantiation and a declaration of an explicit
14266 specialization shall not appear in a program unless the explicit
14267 instantiation follows a declaration of the explicit specialization.
14269 For a given set of template parameters, if an explicit
14270 instantiation of a template appears after a declaration of an
14271 explicit specialization for that template, the explicit
14272 instantiation has no effect. */
14275 else if (DECL_EXPLICIT_INSTANTIATION (result))
14279 No program shall explicitly instantiate any template more
14282 We check DECL_NOT_REALLY_EXTERN so as not to complain when
14283 the first instantiation was `extern' and the second is not,
14284 and EXTERN_P for the opposite case. */
14285 if (DECL_NOT_REALLY_EXTERN (result) && !extern_p)
14286 pedwarn ("duplicate explicit instantiation of %q#D", result);
14287 /* If an "extern" explicit instantiation follows an ordinary
14288 explicit instantiation, the template is instantiated. */
14292 else if (!DECL_IMPLICIT_INSTANTIATION (result))
14294 error ("no matching template for %qD found", result);
14297 else if (!DECL_TEMPLATE_INFO (result))
14299 pedwarn ("explicit instantiation of non-template %q#D", result);
14303 if (storage == NULL_TREE)
14305 else if (storage == ridpointers[(int) RID_EXTERN])
14307 if (pedantic && !in_system_header)
14308 pedwarn ("ISO C++ forbids the use of %<extern%> on explicit "
14313 error ("storage class %qD applied to template instantiation", storage);
14315 check_explicit_instantiation_namespace (result);
14316 mark_decl_instantiated (result, extern_p);
14318 instantiate_decl (result, /*defer_ok=*/1,
14319 /*expl_inst_class_mem_p=*/false);
14323 mark_class_instantiated (tree t, int extern_p)
14325 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
14326 SET_CLASSTYPE_INTERFACE_KNOWN (t);
14327 CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
14328 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
14331 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
14332 rest_of_type_compilation (t, 1);
14336 /* Called from do_type_instantiation through binding_table_foreach to
14337 do recursive instantiation for the type bound in ENTRY. */
14339 bt_instantiate_type_proc (binding_entry entry, void *data)
14341 tree storage = *(tree *) data;
14343 if (IS_AGGR_TYPE (entry->type)
14344 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type)))
14345 do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0);
14348 /* Called from do_type_instantiation to instantiate a member
14349 (a member function or a static member variable) of an
14350 explicitly instantiated class template. */
14352 instantiate_class_member (tree decl, int extern_p)
14354 mark_decl_instantiated (decl, extern_p);
14356 instantiate_decl (decl, /*defer_ok=*/1,
14357 /*expl_inst_class_mem_p=*/true);
14360 /* Perform an explicit instantiation of template class T. STORAGE, if
14361 non-null, is the RID for extern, inline or static. COMPLAIN is
14362 nonzero if this is called from the parser, zero if called recursively,
14363 since the standard is unclear (as detailed below). */
14366 do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
14371 int previous_instantiation_extern_p = 0;
14373 if (TREE_CODE (t) == TYPE_DECL)
14376 if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t))
14378 error ("explicit instantiation of non-template type %qT", t);
14384 if (!COMPLETE_TYPE_P (t))
14386 if (complain & tf_error)
14387 error ("explicit instantiation of %q#T before definition of template",
14392 if (storage != NULL_TREE)
14394 if (pedantic && !in_system_header)
14395 pedwarn("ISO C++ forbids the use of %qE on explicit instantiations",
14398 if (storage == ridpointers[(int) RID_INLINE])
14400 else if (storage == ridpointers[(int) RID_EXTERN])
14402 else if (storage == ridpointers[(int) RID_STATIC])
14406 error ("storage class %qD applied to template instantiation",
14412 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
14414 /* DR 259 [temp.spec].
14416 Both an explicit instantiation and a declaration of an explicit
14417 specialization shall not appear in a program unless the explicit
14418 instantiation follows a declaration of the explicit specialization.
14420 For a given set of template parameters, if an explicit
14421 instantiation of a template appears after a declaration of an
14422 explicit specialization for that template, the explicit
14423 instantiation has no effect. */
14426 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t))
14430 No program shall explicitly instantiate any template more
14433 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
14434 instantiation was `extern'. If EXTERN_P then the second is.
14435 These cases are OK. */
14436 previous_instantiation_extern_p = CLASSTYPE_INTERFACE_ONLY (t);
14438 if (!previous_instantiation_extern_p && !extern_p
14439 && (complain & tf_error))
14440 pedwarn ("duplicate explicit instantiation of %q#T", t);
14442 /* If we've already instantiated the template, just return now. */
14443 if (!CLASSTYPE_INTERFACE_ONLY (t))
14447 check_explicit_instantiation_namespace (TYPE_NAME (t));
14448 mark_class_instantiated (t, extern_p);
14456 /* In contrast to implicit instantiation, where only the
14457 declarations, and not the definitions, of members are
14458 instantiated, we have here:
14462 The explicit instantiation of a class template specialization
14463 implies the instantiation of all of its members not
14464 previously explicitly specialized in the translation unit
14465 containing the explicit instantiation.
14467 Of course, we can't instantiate member template classes, since
14468 we don't have any arguments for them. Note that the standard
14469 is unclear on whether the instantiation of the members are
14470 *explicit* instantiations or not. However, the most natural
14471 interpretation is that it should be an explicit instantiation. */
14474 for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp))
14475 if (TREE_CODE (tmp) == FUNCTION_DECL
14476 && DECL_TEMPLATE_INSTANTIATION (tmp))
14477 instantiate_class_member (tmp, extern_p);
14479 for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp))
14480 if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp))
14481 instantiate_class_member (tmp, extern_p);
14483 if (CLASSTYPE_NESTED_UTDS (t))
14484 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t),
14485 bt_instantiate_type_proc, &storage);
14489 /* Given a function DECL, which is a specialization of TMPL, modify
14490 DECL to be a re-instantiation of TMPL with the same template
14491 arguments. TMPL should be the template into which tsubst'ing
14492 should occur for DECL, not the most general template.
14494 One reason for doing this is a scenario like this:
14497 void f(const T&, int i);
14499 void g() { f(3, 7); }
14502 void f(const T& t, const int i) { }
14504 Note that when the template is first instantiated, with
14505 instantiate_template, the resulting DECL will have no name for the
14506 first parameter, and the wrong type for the second. So, when we go
14507 to instantiate the DECL, we regenerate it. */
14510 regenerate_decl_from_template (tree decl, tree tmpl)
14512 /* The arguments used to instantiate DECL, from the most general
14517 args = DECL_TI_ARGS (decl);
14518 code_pattern = DECL_TEMPLATE_RESULT (tmpl);
14520 /* Make sure that we can see identifiers, and compute access
14522 push_access_scope (decl);
14524 if (TREE_CODE (decl) == FUNCTION_DECL)
14532 args_depth = TMPL_ARGS_DEPTH (args);
14533 parms_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
14534 if (args_depth > parms_depth)
14535 args = get_innermost_template_args (args, parms_depth);
14537 specs = tsubst_exception_specification (TREE_TYPE (code_pattern),
14538 args, tf_error, NULL_TREE);
14540 TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl),
14543 /* Merge parameter declarations. */
14544 decl_parm = skip_artificial_parms_for (decl,
14545 DECL_ARGUMENTS (decl));
14547 = skip_artificial_parms_for (code_pattern,
14548 DECL_ARGUMENTS (code_pattern));
14549 while (decl_parm && !FUNCTION_PARAMETER_PACK_P (pattern_parm))
14554 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
14555 DECL_NAME (decl_parm) = DECL_NAME (pattern_parm);
14556 parm_type = tsubst (TREE_TYPE (pattern_parm), args, tf_error,
14558 parm_type = type_decays_to (parm_type);
14559 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
14560 TREE_TYPE (decl_parm) = parm_type;
14561 attributes = DECL_ATTRIBUTES (pattern_parm);
14562 if (DECL_ATTRIBUTES (decl_parm) != attributes)
14564 DECL_ATTRIBUTES (decl_parm) = attributes;
14565 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
14567 decl_parm = TREE_CHAIN (decl_parm);
14568 pattern_parm = TREE_CHAIN (pattern_parm);
14570 /* Merge any parameters that match with the function parameter
14572 if (pattern_parm && FUNCTION_PARAMETER_PACK_P (pattern_parm))
14575 tree expanded_types;
14576 /* Expand the TYPE_PACK_EXPANSION that provides the types for
14577 the parameters in this function parameter pack. */
14578 expanded_types = tsubst_pack_expansion (TREE_TYPE (pattern_parm),
14579 args, tf_error, NULL_TREE);
14580 len = TREE_VEC_LENGTH (expanded_types);
14581 for (i = 0; i < len; i++)
14586 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
14587 /* Rename the parameter to include the index. */
14588 DECL_NAME (decl_parm) =
14589 make_ith_pack_parameter_name (DECL_NAME (pattern_parm), i);
14590 parm_type = TREE_VEC_ELT (expanded_types, i);
14591 parm_type = type_decays_to (parm_type);
14592 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
14593 TREE_TYPE (decl_parm) = parm_type;
14594 attributes = DECL_ATTRIBUTES (pattern_parm);
14595 if (DECL_ATTRIBUTES (decl_parm) != attributes)
14597 DECL_ATTRIBUTES (decl_parm) = attributes;
14598 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
14600 decl_parm = TREE_CHAIN (decl_parm);
14603 /* Merge additional specifiers from the CODE_PATTERN. */
14604 if (DECL_DECLARED_INLINE_P (code_pattern)
14605 && !DECL_DECLARED_INLINE_P (decl))
14606 DECL_DECLARED_INLINE_P (decl) = 1;
14607 if (DECL_INLINE (code_pattern) && !DECL_INLINE (decl))
14608 DECL_INLINE (decl) = 1;
14610 else if (TREE_CODE (decl) == VAR_DECL)
14611 DECL_INITIAL (decl) =
14612 tsubst_expr (DECL_INITIAL (code_pattern), args,
14613 tf_error, DECL_TI_TEMPLATE (decl),
14614 /*integral_constant_expression_p=*/false);
14616 gcc_unreachable ();
14618 pop_access_scope (decl);
14621 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
14622 substituted to get DECL. */
14625 template_for_substitution (tree decl)
14627 tree tmpl = DECL_TI_TEMPLATE (decl);
14629 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
14630 for the instantiation. This is not always the most general
14631 template. Consider, for example:
14634 struct S { template <class U> void f();
14635 template <> void f<int>(); };
14637 and an instantiation of S<double>::f<int>. We want TD to be the
14638 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
14639 while (/* An instantiation cannot have a definition, so we need a
14640 more general template. */
14641 DECL_TEMPLATE_INSTANTIATION (tmpl)
14642 /* We must also deal with friend templates. Given:
14644 template <class T> struct S {
14645 template <class U> friend void f() {};
14648 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
14649 so far as the language is concerned, but that's still
14650 where we get the pattern for the instantiation from. On
14651 other hand, if the definition comes outside the class, say:
14653 template <class T> struct S {
14654 template <class U> friend void f();
14656 template <class U> friend void f() {}
14658 we don't need to look any further. That's what the check for
14659 DECL_INITIAL is for. */
14660 || (TREE_CODE (decl) == FUNCTION_DECL
14661 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl)
14662 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl))))
14664 /* The present template, TD, should not be a definition. If it
14665 were a definition, we should be using it! Note that we
14666 cannot restructure the loop to just keep going until we find
14667 a template with a definition, since that might go too far if
14668 a specialization was declared, but not defined. */
14669 gcc_assert (TREE_CODE (decl) != VAR_DECL
14670 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl)));
14672 /* Fetch the more general template. */
14673 tmpl = DECL_TI_TEMPLATE (tmpl);
14679 /* Produce the definition of D, a _DECL generated from a template. If
14680 DEFER_OK is nonzero, then we don't have to actually do the
14681 instantiation now; we just have to do it sometime. Normally it is
14682 an error if this is an explicit instantiation but D is undefined.
14683 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
14684 explicitly instantiated class template. */
14687 instantiate_decl (tree d, int defer_ok,
14688 bool expl_inst_class_mem_p)
14690 tree tmpl = DECL_TI_TEMPLATE (d);
14697 bool pattern_defined;
14699 location_t saved_loc = input_location;
14700 int saved_in_system_header = in_system_header;
14703 /* This function should only be used to instantiate templates for
14704 functions and static member variables. */
14705 gcc_assert (TREE_CODE (d) == FUNCTION_DECL
14706 || TREE_CODE (d) == VAR_DECL);
14708 /* Variables are never deferred; if instantiation is required, they
14709 are instantiated right away. That allows for better code in the
14710 case that an expression refers to the value of the variable --
14711 if the variable has a constant value the referring expression can
14712 take advantage of that fact. */
14713 if (TREE_CODE (d) == VAR_DECL)
14716 /* Don't instantiate cloned functions. Instead, instantiate the
14717 functions they cloned. */
14718 if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d))
14719 d = DECL_CLONED_FUNCTION (d);
14721 if (DECL_TEMPLATE_INSTANTIATED (d))
14722 /* D has already been instantiated. It might seem reasonable to
14723 check whether or not D is an explicit instantiation, and, if so,
14724 stop here. But when an explicit instantiation is deferred
14725 until the end of the compilation, DECL_EXPLICIT_INSTANTIATION
14726 is set, even though we still need to do the instantiation. */
14729 /* If we already have a specialization of this declaration, then
14730 there's no reason to instantiate it. Note that
14731 retrieve_specialization gives us both instantiations and
14732 specializations, so we must explicitly check
14733 DECL_TEMPLATE_SPECIALIZATION. */
14734 gen_tmpl = most_general_template (tmpl);
14735 gen_args = DECL_TI_ARGS (d);
14736 spec = retrieve_specialization (gen_tmpl, gen_args,
14737 /*class_specializations_p=*/false);
14738 if (spec != NULL_TREE && DECL_TEMPLATE_SPECIALIZATION (spec))
14741 /* This needs to happen before any tsubsting. */
14742 if (! push_tinst_level (d))
14745 timevar_push (TV_PARSE);
14747 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
14748 for the instantiation. */
14749 td = template_for_substitution (d);
14750 code_pattern = DECL_TEMPLATE_RESULT (td);
14752 /* We should never be trying to instantiate a member of a class
14753 template or partial specialization. */
14754 gcc_assert (d != code_pattern);
14756 if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d))
14757 || DECL_TEMPLATE_SPECIALIZATION (td))
14758 /* In the case of a friend template whose definition is provided
14759 outside the class, we may have too many arguments. Drop the
14760 ones we don't need. The same is true for specializations. */
14761 args = get_innermost_template_args
14762 (gen_args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td)));
14766 if (TREE_CODE (d) == FUNCTION_DECL)
14767 pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE);
14769 pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
14771 /* We may be in the middle of deferred access check. Disable it now. */
14772 push_deferring_access_checks (dk_no_deferred);
14774 /* Unless an explicit instantiation directive has already determined
14775 the linkage of D, remember that a definition is available for
14777 if (pattern_defined
14778 && !DECL_INTERFACE_KNOWN (d)
14779 && !DECL_NOT_REALLY_EXTERN (d))
14780 mark_definable (d);
14782 input_location = DECL_SOURCE_LOCATION (d);
14783 in_system_header = DECL_IN_SYSTEM_HEADER (d);
14785 /* If D is a member of an explicitly instantiated class template,
14786 and no definition is available, treat it like an implicit
14788 if (!pattern_defined && expl_inst_class_mem_p
14789 && DECL_EXPLICIT_INSTANTIATION (d))
14791 DECL_NOT_REALLY_EXTERN (d) = 0;
14792 DECL_INTERFACE_KNOWN (d) = 0;
14793 SET_DECL_IMPLICIT_INSTANTIATION (d);
14798 /* Recheck the substitutions to obtain any warning messages
14799 about ignoring cv qualifiers. */
14800 tree gen = DECL_TEMPLATE_RESULT (gen_tmpl);
14801 tree type = TREE_TYPE (gen);
14803 /* Make sure that we can see identifiers, and compute access
14804 correctly. D is already the target FUNCTION_DECL with the
14806 push_access_scope (d);
14808 if (TREE_CODE (gen) == FUNCTION_DECL)
14810 tsubst (DECL_ARGUMENTS (gen), gen_args, tf_warning_or_error, d);
14811 tsubst_exception_specification (type, gen_args, tf_warning_or_error,
14813 /* Don't simply tsubst the function type, as that will give
14814 duplicate warnings about poor parameter qualifications.
14815 The function arguments are the same as the decl_arguments
14816 without the top level cv qualifiers. */
14817 type = TREE_TYPE (type);
14819 tsubst (type, gen_args, tf_warning_or_error, d);
14821 pop_access_scope (d);
14824 /* Check to see whether we know that this template will be
14825 instantiated in some other file, as with "extern template"
14827 external_p = (DECL_INTERFACE_KNOWN (d) && DECL_REALLY_EXTERN (d));
14828 /* In general, we do not instantiate such templates... */
14830 /* ... but we instantiate inline functions so that we can inline
14832 && ! (TREE_CODE (d) == FUNCTION_DECL && DECL_INLINE (d))
14833 /* ... we instantiate static data members whose values are
14834 needed in integral constant expressions. */
14835 && ! (TREE_CODE (d) == VAR_DECL
14836 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (d)))
14838 /* Defer all other templates, unless we have been explicitly
14839 forbidden from doing so. */
14840 if (/* If there is no definition, we cannot instantiate the
14843 /* If it's OK to postpone instantiation, do so. */
14845 /* If this is a static data member that will be defined
14846 elsewhere, we don't want to instantiate the entire data
14847 member, but we do want to instantiate the initializer so that
14848 we can substitute that elsewhere. */
14849 || (external_p && TREE_CODE (d) == VAR_DECL))
14851 /* The definition of the static data member is now required so
14852 we must substitute the initializer. */
14853 if (TREE_CODE (d) == VAR_DECL
14854 && !DECL_INITIAL (d)
14855 && DECL_INITIAL (code_pattern))
14860 ns = decl_namespace_context (d);
14861 push_nested_namespace (ns);
14862 push_nested_class (DECL_CONTEXT (d));
14863 init = tsubst_expr (DECL_INITIAL (code_pattern),
14865 tf_warning_or_error, NULL_TREE,
14866 /*integral_constant_expression_p=*/false);
14867 cp_finish_decl (d, init, /*init_const_expr_p=*/false,
14868 /*asmspec_tree=*/NULL_TREE,
14869 LOOKUP_ONLYCONVERTING);
14870 pop_nested_class ();
14871 pop_nested_namespace (ns);
14874 /* We restore the source position here because it's used by
14875 add_pending_template. */
14876 input_location = saved_loc;
14878 if (at_eof && !pattern_defined
14879 && DECL_EXPLICIT_INSTANTIATION (d))
14882 The definition of a non-exported function template, a
14883 non-exported member function template, or a non-exported
14884 member function or static data member of a class template
14885 shall be present in every translation unit in which it is
14886 explicitly instantiated. */
14888 ("explicit instantiation of %qD but no definition available", d);
14890 /* ??? Historically, we have instantiated inline functions, even
14891 when marked as "extern template". */
14892 if (!(external_p && TREE_CODE (d) == VAR_DECL))
14893 add_pending_template (d);
14896 /* Tell the repository that D is available in this translation unit
14897 -- and see if it is supposed to be instantiated here. */
14898 if (TREE_PUBLIC (d) && !DECL_REALLY_EXTERN (d) && !repo_emit_p (d))
14900 /* In a PCH file, despite the fact that the repository hasn't
14901 requested instantiation in the PCH it is still possible that
14902 an instantiation will be required in a file that includes the
14905 add_pending_template (d);
14906 /* Instantiate inline functions so that the inliner can do its
14907 job, even though we'll not be emitting a copy of this
14909 if (!(TREE_CODE (d) == FUNCTION_DECL
14910 && flag_inline_trees
14911 && DECL_DECLARED_INLINE_P (d)))
14915 need_push = !cfun || !global_bindings_p ();
14917 push_to_top_level ();
14919 /* Mark D as instantiated so that recursive calls to
14920 instantiate_decl do not try to instantiate it again. */
14921 DECL_TEMPLATE_INSTANTIATED (d) = 1;
14923 /* Regenerate the declaration in case the template has been modified
14924 by a subsequent redeclaration. */
14925 regenerate_decl_from_template (d, td);
14927 /* We already set the file and line above. Reset them now in case
14928 they changed as a result of calling regenerate_decl_from_template. */
14929 input_location = DECL_SOURCE_LOCATION (d);
14931 if (TREE_CODE (d) == VAR_DECL)
14935 /* Clear out DECL_RTL; whatever was there before may not be right
14936 since we've reset the type of the declaration. */
14937 SET_DECL_RTL (d, NULL_RTX);
14938 DECL_IN_AGGR_P (d) = 0;
14940 /* The initializer is placed in DECL_INITIAL by
14941 regenerate_decl_from_template. Pull it out so that
14942 finish_decl can process it. */
14943 init = DECL_INITIAL (d);
14944 DECL_INITIAL (d) = NULL_TREE;
14945 DECL_INITIALIZED_P (d) = 0;
14947 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
14948 initializer. That function will defer actual emission until
14949 we have a chance to determine linkage. */
14950 DECL_EXTERNAL (d) = 0;
14952 /* Enter the scope of D so that access-checking works correctly. */
14953 push_nested_class (DECL_CONTEXT (d));
14954 finish_decl (d, init, NULL_TREE);
14955 pop_nested_class ();
14957 else if (TREE_CODE (d) == FUNCTION_DECL)
14959 htab_t saved_local_specializations;
14964 /* Save away the current list, in case we are instantiating one
14965 template from within the body of another. */
14966 saved_local_specializations = local_specializations;
14968 /* Set up the list of local specializations. */
14969 local_specializations = htab_create (37,
14970 hash_local_specialization,
14971 eq_local_specializations,
14974 /* Set up context. */
14975 start_preparsed_function (d, NULL_TREE, SF_PRE_PARSED);
14977 /* Create substitution entries for the parameters. */
14978 subst_decl = DECL_TEMPLATE_RESULT (template_for_substitution (d));
14979 tmpl_parm = DECL_ARGUMENTS (subst_decl);
14980 spec_parm = DECL_ARGUMENTS (d);
14981 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d))
14983 register_local_specialization (spec_parm, tmpl_parm);
14984 spec_parm = skip_artificial_parms_for (d, spec_parm);
14985 tmpl_parm = skip_artificial_parms_for (subst_decl, tmpl_parm);
14987 while (tmpl_parm && !FUNCTION_PARAMETER_PACK_P (tmpl_parm))
14989 register_local_specialization (spec_parm, tmpl_parm);
14990 tmpl_parm = TREE_CHAIN (tmpl_parm);
14991 spec_parm = TREE_CHAIN (spec_parm);
14993 if (tmpl_parm && FUNCTION_PARAMETER_PACK_P (tmpl_parm))
14995 /* Collect all of the extra "packed" parameters into an
14999 tree argpack = make_node (NONTYPE_ARGUMENT_PACK);
15000 tree argtypepack = make_node (TYPE_ARGUMENT_PACK);
15004 /* Count how many parameters remain. */
15005 for (t = spec_parm; t; t = TREE_CHAIN (t))
15008 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
15009 parmvec = make_tree_vec (len);
15010 parmtypevec = make_tree_vec (len);
15011 for(i = 0; i < len; i++, spec_parm = TREE_CHAIN (spec_parm))
15013 TREE_VEC_ELT (parmvec, i) = spec_parm;
15014 TREE_VEC_ELT (parmtypevec, i) = TREE_TYPE (spec_parm);
15017 /* Build the argument packs. */
15018 SET_ARGUMENT_PACK_ARGS (argpack, parmvec);
15019 SET_ARGUMENT_PACK_ARGS (argtypepack, parmtypevec);
15020 TREE_TYPE (argpack) = argtypepack;
15022 /* Register the (value) argument pack as a specialization of
15023 TMPL_PARM, then move on. */
15024 register_local_specialization (argpack, tmpl_parm);
15025 tmpl_parm = TREE_CHAIN (tmpl_parm);
15027 gcc_assert (!spec_parm);
15029 /* Substitute into the body of the function. */
15030 tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
15031 tf_warning_or_error, tmpl,
15032 /*integral_constant_expression_p=*/false);
15034 /* Set the current input_location to the end of the function
15035 so that finish_function knows where we are. */
15036 input_location = DECL_STRUCT_FUNCTION (code_pattern)->function_end_locus;
15038 /* We don't need the local specializations any more. */
15039 htab_delete (local_specializations);
15040 local_specializations = saved_local_specializations;
15042 /* Finish the function. */
15043 d = finish_function (0);
15044 expand_or_defer_fn (d);
15047 /* We're not deferring instantiation any more. */
15048 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
15051 pop_from_top_level ();
15054 input_location = saved_loc;
15055 in_system_header = saved_in_system_header;
15056 pop_deferring_access_checks ();
15057 pop_tinst_level ();
15059 timevar_pop (TV_PARSE);
15064 /* Run through the list of templates that we wish we could
15065 instantiate, and instantiate any we can. RETRIES is the
15066 number of times we retry pending template instantiation. */
15069 instantiate_pending_templates (int retries)
15072 location_t saved_loc = input_location;
15073 int saved_in_system_header = in_system_header;
15075 /* Instantiating templates may trigger vtable generation. This in turn
15076 may require further template instantiations. We place a limit here
15077 to avoid infinite loop. */
15078 if (pending_templates && retries >= max_tinst_depth)
15080 tree decl = pending_templates->tinst->decl;
15082 error ("template instantiation depth exceeds maximum of %d"
15083 " instantiating %q+D, possibly from virtual table generation"
15084 " (use -ftemplate-depth-NN to increase the maximum)",
15085 max_tinst_depth, decl);
15086 if (TREE_CODE (decl) == FUNCTION_DECL)
15087 /* Pretend that we defined it. */
15088 DECL_INITIAL (decl) = error_mark_node;
15094 struct pending_template **t = &pending_templates;
15095 struct pending_template *last = NULL;
15099 tree instantiation = reopen_tinst_level ((*t)->tinst);
15100 bool complete = false;
15102 if (TYPE_P (instantiation))
15106 if (!COMPLETE_TYPE_P (instantiation))
15108 instantiate_class_template (instantiation);
15109 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
15110 for (fn = TYPE_METHODS (instantiation);
15112 fn = TREE_CHAIN (fn))
15113 if (! DECL_ARTIFICIAL (fn))
15114 instantiate_decl (fn,
15116 /*expl_inst_class_mem_p=*/false);
15117 if (COMPLETE_TYPE_P (instantiation))
15121 complete = COMPLETE_TYPE_P (instantiation);
15125 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation)
15126 && !DECL_TEMPLATE_INSTANTIATED (instantiation))
15129 = instantiate_decl (instantiation,
15131 /*expl_inst_class_mem_p=*/false);
15132 if (DECL_TEMPLATE_INSTANTIATED (instantiation))
15136 complete = (DECL_TEMPLATE_SPECIALIZATION (instantiation)
15137 || DECL_TEMPLATE_INSTANTIATED (instantiation));
15141 /* If INSTANTIATION has been instantiated, then we don't
15142 need to consider it again in the future. */
15150 current_tinst_level = NULL;
15152 last_pending_template = last;
15154 while (reconsider);
15156 input_location = saved_loc;
15157 in_system_header = saved_in_system_header;
15160 /* Substitute ARGVEC into T, which is a list of initializers for
15161 either base class or a non-static data member. The TREE_PURPOSEs
15162 are DECLs, and the TREE_VALUEs are the initializer values. Used by
15163 instantiate_decl. */
15166 tsubst_initializer_list (tree t, tree argvec)
15168 tree inits = NULL_TREE;
15170 for (; t; t = TREE_CHAIN (t))
15174 tree expanded_bases = NULL_TREE;
15175 tree expanded_arguments = NULL_TREE;
15178 if (TREE_CODE (TREE_PURPOSE (t)) == TYPE_PACK_EXPANSION)
15183 /* Expand the base class expansion type into separate base
15185 expanded_bases = tsubst_pack_expansion (TREE_PURPOSE (t), argvec,
15186 tf_warning_or_error,
15188 if (expanded_bases == error_mark_node)
15191 /* We'll be building separate TREE_LISTs of arguments for
15193 len = TREE_VEC_LENGTH (expanded_bases);
15194 expanded_arguments = make_tree_vec (len);
15195 for (i = 0; i < len; i++)
15196 TREE_VEC_ELT (expanded_arguments, i) = NULL_TREE;
15198 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
15199 expand each argument in the TREE_VALUE of t. */
15200 expr = make_node (EXPR_PACK_EXPANSION);
15201 PACK_EXPANSION_PARAMETER_PACKS (expr) =
15202 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t));
15204 /* Substitute parameter packs into each argument in the
15206 in_base_initializer = 1;
15207 for (arg = TREE_VALUE (t); arg; arg = TREE_CHAIN (arg))
15209 tree expanded_exprs;
15211 /* Expand the argument. */
15212 SET_PACK_EXPANSION_PATTERN (expr, TREE_VALUE (arg));
15213 expanded_exprs = tsubst_pack_expansion (expr, argvec,
15214 tf_warning_or_error,
15217 /* Prepend each of the expanded expressions to the
15218 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
15219 for (i = 0; i < len; i++)
15221 TREE_VEC_ELT (expanded_arguments, i) =
15222 tree_cons (NULL_TREE, TREE_VEC_ELT (expanded_exprs, i),
15223 TREE_VEC_ELT (expanded_arguments, i));
15226 in_base_initializer = 0;
15228 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
15229 since we built them backwards. */
15230 for (i = 0; i < len; i++)
15232 TREE_VEC_ELT (expanded_arguments, i) =
15233 nreverse (TREE_VEC_ELT (expanded_arguments, i));
15237 for (i = 0; i < len; ++i)
15239 if (expanded_bases)
15241 decl = TREE_VEC_ELT (expanded_bases, i);
15242 decl = expand_member_init (decl);
15243 init = TREE_VEC_ELT (expanded_arguments, i);
15247 decl = tsubst_copy (TREE_PURPOSE (t), argvec,
15248 tf_warning_or_error, NULL_TREE);
15250 decl = expand_member_init (decl);
15251 if (decl && !DECL_P (decl))
15252 in_base_initializer = 1;
15254 init = tsubst_expr (TREE_VALUE (t), argvec,
15255 tf_warning_or_error, NULL_TREE,
15256 /*integral_constant_expression_p=*/false);
15257 in_base_initializer = 0;
15262 init = build_tree_list (decl, init);
15263 TREE_CHAIN (init) = inits;
15271 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
15274 set_current_access_from_decl (tree decl)
15276 if (TREE_PRIVATE (decl))
15277 current_access_specifier = access_private_node;
15278 else if (TREE_PROTECTED (decl))
15279 current_access_specifier = access_protected_node;
15281 current_access_specifier = access_public_node;
15284 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
15285 is the instantiation (which should have been created with
15286 start_enum) and ARGS are the template arguments to use. */
15289 tsubst_enum (tree tag, tree newtag, tree args)
15293 for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
15298 decl = TREE_VALUE (e);
15299 /* Note that in a template enum, the TREE_VALUE is the
15300 CONST_DECL, not the corresponding INTEGER_CST. */
15301 value = tsubst_expr (DECL_INITIAL (decl),
15302 args, tf_warning_or_error, NULL_TREE,
15303 /*integral_constant_expression_p=*/true);
15305 /* Give this enumeration constant the correct access. */
15306 set_current_access_from_decl (decl);
15308 /* Actually build the enumerator itself. */
15309 build_enumerator (DECL_NAME (decl), value, newtag);
15312 finish_enum (newtag);
15313 DECL_SOURCE_LOCATION (TYPE_NAME (newtag))
15314 = DECL_SOURCE_LOCATION (TYPE_NAME (tag));
15317 /* DECL is a FUNCTION_DECL that is a template specialization. Return
15318 its type -- but without substituting the innermost set of template
15319 arguments. So, innermost set of template parameters will appear in
15323 get_mostly_instantiated_function_type (tree decl)
15331 tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
15332 targs = DECL_TI_ARGS (decl);
15333 tparms = DECL_TEMPLATE_PARMS (tmpl);
15334 parm_depth = TMPL_PARMS_DEPTH (tparms);
15336 /* There should be as many levels of arguments as there are levels
15338 gcc_assert (parm_depth == TMPL_ARGS_DEPTH (targs));
15340 fn_type = TREE_TYPE (tmpl);
15342 if (parm_depth == 1)
15343 /* No substitution is necessary. */
15347 int i, save_access_control;
15350 /* Replace the innermost level of the TARGS with NULL_TREEs to
15351 let tsubst know not to substitute for those parameters. */
15352 partial_args = make_tree_vec (TREE_VEC_LENGTH (targs));
15353 for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i)
15354 SET_TMPL_ARGS_LEVEL (partial_args, i,
15355 TMPL_ARGS_LEVEL (targs, i));
15356 SET_TMPL_ARGS_LEVEL (partial_args,
15357 TMPL_ARGS_DEPTH (targs),
15358 make_tree_vec (DECL_NTPARMS (tmpl)));
15360 /* Disable access control as this function is used only during
15362 save_access_control = flag_access_control;
15363 flag_access_control = 0;
15365 ++processing_template_decl;
15366 /* Now, do the (partial) substitution to figure out the
15367 appropriate function type. */
15368 fn_type = tsubst (fn_type, partial_args, tf_error, NULL_TREE);
15369 --processing_template_decl;
15371 /* Substitute into the template parameters to obtain the real
15372 innermost set of parameters. This step is important if the
15373 innermost set of template parameters contains value
15374 parameters whose types depend on outer template parameters. */
15375 TREE_VEC_LENGTH (partial_args)--;
15376 tparms = tsubst_template_parms (tparms, partial_args, tf_error);
15378 flag_access_control = save_access_control;
15384 /* Return truthvalue if we're processing a template different from
15385 the last one involved in diagnostics. */
15387 problematic_instantiation_changed (void)
15389 return last_template_error_tick != tinst_level_tick;
15392 /* Remember current template involved in diagnostics. */
15394 record_last_problematic_instantiation (void)
15396 last_template_error_tick = tinst_level_tick;
15399 struct tinst_level *
15400 current_instantiation (void)
15402 return current_tinst_level;
15405 /* [temp.param] Check that template non-type parm TYPE is of an allowable
15406 type. Return zero for ok, nonzero for disallowed. Issue error and
15407 warning messages under control of COMPLAIN. */
15410 invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain)
15412 if (INTEGRAL_TYPE_P (type))
15414 else if (POINTER_TYPE_P (type))
15416 else if (TYPE_PTR_TO_MEMBER_P (type))
15418 else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
15420 else if (TREE_CODE (type) == TYPENAME_TYPE)
15423 if (complain & tf_error)
15424 error ("%q#T is not a valid type for a template constant parameter", type);
15428 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
15429 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
15432 dependent_type_p_r (tree type)
15438 A type is dependent if it is:
15440 -- a template parameter. Template template parameters are types
15441 for us (since TYPE_P holds true for them) so we handle
15443 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
15444 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
15446 /* -- a qualified-id with a nested-name-specifier which contains a
15447 class-name that names a dependent type or whose unqualified-id
15448 names a dependent type. */
15449 if (TREE_CODE (type) == TYPENAME_TYPE)
15451 /* -- a cv-qualified type where the cv-unqualified type is
15453 type = TYPE_MAIN_VARIANT (type);
15454 /* -- a compound type constructed from any dependent type. */
15455 if (TYPE_PTR_TO_MEMBER_P (type))
15456 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type))
15457 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
15459 else if (TREE_CODE (type) == POINTER_TYPE
15460 || TREE_CODE (type) == REFERENCE_TYPE)
15461 return dependent_type_p (TREE_TYPE (type));
15462 else if (TREE_CODE (type) == FUNCTION_TYPE
15463 || TREE_CODE (type) == METHOD_TYPE)
15467 if (dependent_type_p (TREE_TYPE (type)))
15469 for (arg_type = TYPE_ARG_TYPES (type);
15471 arg_type = TREE_CHAIN (arg_type))
15472 if (dependent_type_p (TREE_VALUE (arg_type)))
15476 /* -- an array type constructed from any dependent type or whose
15477 size is specified by a constant expression that is
15478 value-dependent. */
15479 if (TREE_CODE (type) == ARRAY_TYPE)
15481 if (TYPE_DOMAIN (type)
15482 && dependent_type_p (TYPE_DOMAIN (type)))
15484 return dependent_type_p (TREE_TYPE (type));
15486 else if (TREE_CODE (type) == INTEGER_TYPE
15487 && !TREE_CONSTANT (TYPE_MAX_VALUE (type)))
15489 /* If this is the TYPE_DOMAIN of an array type, consider it
15491 return (value_dependent_expression_p (TYPE_MAX_VALUE (type))
15492 || type_dependent_expression_p (TYPE_MAX_VALUE (type)));
15495 /* -- a template-id in which either the template name is a template
15497 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
15499 /* ... or any of the template arguments is a dependent type or
15500 an expression that is type-dependent or value-dependent. */
15501 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
15502 && (any_dependent_template_arguments_p
15503 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
15506 /* All TYPEOF_TYPEs and DECLTYPE_TYPEs are dependent; if the
15507 argument of the `typeof' expression is not type-dependent, then
15508 it should already been have resolved. */
15509 if (TREE_CODE (type) == TYPEOF_TYPE
15510 || TREE_CODE (type) == DECLTYPE_TYPE)
15513 /* A template argument pack is dependent if any of its packed
15515 if (TREE_CODE (type) == TYPE_ARGUMENT_PACK)
15517 tree args = ARGUMENT_PACK_ARGS (type);
15518 int i, len = TREE_VEC_LENGTH (args);
15519 for (i = 0; i < len; ++i)
15520 if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
15524 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
15525 be template parameters. */
15526 if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
15529 /* The standard does not specifically mention types that are local
15530 to template functions or local classes, but they should be
15531 considered dependent too. For example:
15533 template <int I> void f() {
15538 The size of `E' cannot be known until the value of `I' has been
15539 determined. Therefore, `E' must be considered dependent. */
15540 scope = TYPE_CONTEXT (type);
15541 if (scope && TYPE_P (scope))
15542 return dependent_type_p (scope);
15543 else if (scope && TREE_CODE (scope) == FUNCTION_DECL)
15544 return type_dependent_expression_p (scope);
15546 /* Other types are non-dependent. */
15550 /* Returns TRUE if TYPE is dependent, in the sense of
15551 [temp.dep.type]. */
15554 dependent_type_p (tree type)
15556 /* If there are no template parameters in scope, then there can't be
15557 any dependent types. */
15558 if (!processing_template_decl)
15560 /* If we are not processing a template, then nobody should be
15561 providing us with a dependent type. */
15563 gcc_assert (TREE_CODE (type) != TEMPLATE_TYPE_PARM);
15567 /* If the type is NULL, we have not computed a type for the entity
15568 in question; in that case, the type is dependent. */
15572 /* Erroneous types can be considered non-dependent. */
15573 if (type == error_mark_node)
15576 /* If we have not already computed the appropriate value for TYPE,
15578 if (!TYPE_DEPENDENT_P_VALID (type))
15580 TYPE_DEPENDENT_P (type) = dependent_type_p_r (type);
15581 TYPE_DEPENDENT_P_VALID (type) = 1;
15584 return TYPE_DEPENDENT_P (type);
15587 /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
15590 dependent_scope_ref_p (tree expression, bool criterion (tree))
15595 gcc_assert (TREE_CODE (expression) == SCOPE_REF);
15597 if (!TYPE_P (TREE_OPERAND (expression, 0)))
15600 scope = TREE_OPERAND (expression, 0);
15601 name = TREE_OPERAND (expression, 1);
15605 An id-expression is type-dependent if it contains a
15606 nested-name-specifier that contains a class-name that names a
15608 /* The suggested resolution to Core Issue 2 implies that if the
15609 qualifying type is the current class, then we must peek
15612 && currently_open_class (scope)
15613 && !criterion (name))
15615 if (dependent_type_p (scope))
15621 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
15622 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
15626 value_dependent_expression_p (tree expression)
15628 if (!processing_template_decl)
15631 /* A name declared with a dependent type. */
15632 if (DECL_P (expression) && type_dependent_expression_p (expression))
15635 switch (TREE_CODE (expression))
15637 case IDENTIFIER_NODE:
15638 /* A name that has not been looked up -- must be dependent. */
15641 case TEMPLATE_PARM_INDEX:
15642 /* A non-type template parm. */
15646 /* A non-type template parm. */
15647 if (DECL_TEMPLATE_PARM_P (expression))
15652 /* A constant with integral or enumeration type and is initialized
15653 with an expression that is value-dependent. */
15654 if (DECL_INITIAL (expression)
15655 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression))
15656 && value_dependent_expression_p (DECL_INITIAL (expression)))
15660 case DYNAMIC_CAST_EXPR:
15661 case STATIC_CAST_EXPR:
15662 case CONST_CAST_EXPR:
15663 case REINTERPRET_CAST_EXPR:
15665 /* These expressions are value-dependent if the type to which
15666 the cast occurs is dependent or the expression being casted
15667 is value-dependent. */
15669 tree type = TREE_TYPE (expression);
15671 if (dependent_type_p (type))
15674 /* A functional cast has a list of operands. */
15675 expression = TREE_OPERAND (expression, 0);
15678 /* If there are no operands, it must be an expression such
15679 as "int()". This should not happen for aggregate types
15680 because it would form non-constant expressions. */
15681 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
15686 if (TREE_CODE (expression) == TREE_LIST)
15687 return any_value_dependent_elements_p (expression);
15689 return value_dependent_expression_p (expression);
15694 /* A `sizeof' expression is value-dependent if the operand is
15695 type-dependent or is a pack expansion. */
15696 expression = TREE_OPERAND (expression, 0);
15697 if (PACK_EXPANSION_P (expression))
15699 else if (TYPE_P (expression))
15700 return dependent_type_p (expression);
15701 return type_dependent_expression_p (expression);
15704 return dependent_scope_ref_p (expression, value_dependent_expression_p);
15706 case COMPONENT_REF:
15707 return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
15708 || value_dependent_expression_p (TREE_OPERAND (expression, 1)));
15711 /* A CALL_EXPR may appear in a constant expression if it is a
15712 call to a builtin function, e.g., __builtin_constant_p. All
15713 such calls are value-dependent. */
15716 case NONTYPE_ARGUMENT_PACK:
15717 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
15718 is value-dependent. */
15720 tree values = ARGUMENT_PACK_ARGS (expression);
15721 int i, len = TREE_VEC_LENGTH (values);
15723 for (i = 0; i < len; ++i)
15724 if (value_dependent_expression_p (TREE_VEC_ELT (values, i)))
15732 tree type2 = TRAIT_EXPR_TYPE2 (expression);
15733 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression))
15734 || (type2 ? dependent_type_p (type2) : false));
15738 return ((value_dependent_expression_p (TREE_OPERAND (expression, 0)))
15739 || (value_dependent_expression_p (TREE_OPERAND (expression, 2))));
15742 /* A constant expression is value-dependent if any subexpression is
15743 value-dependent. */
15744 switch (TREE_CODE_CLASS (TREE_CODE (expression)))
15746 case tcc_reference:
15748 return (value_dependent_expression_p
15749 (TREE_OPERAND (expression, 0)));
15751 case tcc_comparison:
15753 return ((value_dependent_expression_p
15754 (TREE_OPERAND (expression, 0)))
15755 || (value_dependent_expression_p
15756 (TREE_OPERAND (expression, 1))));
15758 case tcc_expression:
15762 for (i = 0; i < TREE_OPERAND_LENGTH (expression); ++i)
15763 /* In some cases, some of the operands may be missing.
15764 (For example, in the case of PREDECREMENT_EXPR, the
15765 amount to increment by may be missing.) That doesn't
15766 make the expression dependent. */
15767 if (TREE_OPERAND (expression, i)
15768 && (value_dependent_expression_p
15769 (TREE_OPERAND (expression, i))))
15779 /* The expression is not value-dependent. */
15783 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
15784 [temp.dep.expr]. */
15787 type_dependent_expression_p (tree expression)
15789 if (!processing_template_decl)
15792 if (expression == error_mark_node)
15795 /* An unresolved name is always dependent. */
15796 if (TREE_CODE (expression) == IDENTIFIER_NODE
15797 || TREE_CODE (expression) == USING_DECL)
15800 /* Some expression forms are never type-dependent. */
15801 if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR
15802 || TREE_CODE (expression) == SIZEOF_EXPR
15803 || TREE_CODE (expression) == ALIGNOF_EXPR
15804 || TREE_CODE (expression) == TRAIT_EXPR
15805 || TREE_CODE (expression) == TYPEID_EXPR
15806 || TREE_CODE (expression) == DELETE_EXPR
15807 || TREE_CODE (expression) == VEC_DELETE_EXPR
15808 || TREE_CODE (expression) == THROW_EXPR)
15811 /* The types of these expressions depends only on the type to which
15812 the cast occurs. */
15813 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
15814 || TREE_CODE (expression) == STATIC_CAST_EXPR
15815 || TREE_CODE (expression) == CONST_CAST_EXPR
15816 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
15817 || TREE_CODE (expression) == CAST_EXPR)
15818 return dependent_type_p (TREE_TYPE (expression));
15820 /* The types of these expressions depends only on the type created
15821 by the expression. */
15822 if (TREE_CODE (expression) == NEW_EXPR
15823 || TREE_CODE (expression) == VEC_NEW_EXPR)
15825 /* For NEW_EXPR tree nodes created inside a template, either
15826 the object type itself or a TREE_LIST may appear as the
15828 tree type = TREE_OPERAND (expression, 1);
15829 if (TREE_CODE (type) == TREE_LIST)
15830 /* This is an array type. We need to check array dimensions
15832 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type)))
15833 || value_dependent_expression_p
15834 (TREE_OPERAND (TREE_VALUE (type), 1));
15836 return dependent_type_p (type);
15839 if (TREE_CODE (expression) == SCOPE_REF
15840 && dependent_scope_ref_p (expression,
15841 type_dependent_expression_p))
15844 if (TREE_CODE (expression) == FUNCTION_DECL
15845 && DECL_LANG_SPECIFIC (expression)
15846 && DECL_TEMPLATE_INFO (expression)
15847 && (any_dependent_template_arguments_p
15848 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
15851 if (TREE_CODE (expression) == TEMPLATE_DECL
15852 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression))
15855 if (TREE_CODE (expression) == STMT_EXPR)
15856 expression = stmt_expr_value_expr (expression);
15858 if (TREE_TYPE (expression) == unknown_type_node)
15860 if (TREE_CODE (expression) == ADDR_EXPR)
15861 return type_dependent_expression_p (TREE_OPERAND (expression, 0));
15862 if (TREE_CODE (expression) == COMPONENT_REF
15863 || TREE_CODE (expression) == OFFSET_REF)
15865 if (type_dependent_expression_p (TREE_OPERAND (expression, 0)))
15867 expression = TREE_OPERAND (expression, 1);
15868 if (TREE_CODE (expression) == IDENTIFIER_NODE)
15871 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
15872 if (TREE_CODE (expression) == SCOPE_REF)
15875 if (TREE_CODE (expression) == BASELINK)
15876 expression = BASELINK_FUNCTIONS (expression);
15878 if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
15880 if (any_dependent_template_arguments_p
15881 (TREE_OPERAND (expression, 1)))
15883 expression = TREE_OPERAND (expression, 0);
15885 gcc_assert (TREE_CODE (expression) == OVERLOAD
15886 || TREE_CODE (expression) == FUNCTION_DECL);
15890 if (type_dependent_expression_p (OVL_CURRENT (expression)))
15892 expression = OVL_NEXT (expression);
15897 gcc_assert (TREE_CODE (expression) != TYPE_DECL);
15899 return (dependent_type_p (TREE_TYPE (expression)));
15902 /* Returns TRUE if ARGS (a TREE_LIST of arguments to a function call)
15903 contains a type-dependent expression. */
15906 any_type_dependent_arguments_p (const_tree args)
15910 tree arg = TREE_VALUE (args);
15912 if (type_dependent_expression_p (arg))
15914 args = TREE_CHAIN (args);
15919 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
15920 expressions) contains any value-dependent expressions. */
15923 any_value_dependent_elements_p (const_tree list)
15925 for (; list; list = TREE_CHAIN (list))
15926 if (value_dependent_expression_p (TREE_VALUE (list)))
15932 /* Returns TRUE if the ARG (a template argument) is dependent. */
15935 dependent_template_arg_p (tree arg)
15937 if (!processing_template_decl)
15940 if (TREE_CODE (arg) == TEMPLATE_DECL
15941 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
15942 return dependent_template_p (arg);
15943 else if (ARGUMENT_PACK_P (arg))
15945 tree args = ARGUMENT_PACK_ARGS (arg);
15946 int i, len = TREE_VEC_LENGTH (args);
15947 for (i = 0; i < len; ++i)
15949 if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
15955 else if (TYPE_P (arg))
15956 return dependent_type_p (arg);
15958 return (type_dependent_expression_p (arg)
15959 || value_dependent_expression_p (arg));
15962 /* Returns true if ARGS (a collection of template arguments) contains
15963 any types that require structural equality testing. */
15966 any_template_arguments_need_structural_equality_p (tree args)
15973 if (args == error_mark_node)
15976 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
15978 tree level = TMPL_ARGS_LEVEL (args, i + 1);
15979 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
15981 tree arg = TREE_VEC_ELT (level, j);
15982 tree packed_args = NULL_TREE;
15985 if (ARGUMENT_PACK_P (arg))
15987 /* Look inside the argument pack. */
15988 packed_args = ARGUMENT_PACK_ARGS (arg);
15989 len = TREE_VEC_LENGTH (packed_args);
15992 for (k = 0; k < len; ++k)
15995 arg = TREE_VEC_ELT (packed_args, k);
15997 if (error_operand_p (arg))
15999 else if (TREE_CODE (arg) == TEMPLATE_DECL
16000 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
16002 else if (TYPE_P (arg) && TYPE_STRUCTURAL_EQUALITY_P (arg))
16004 else if (!TYPE_P (arg) && TREE_TYPE (arg)
16005 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg)))
16014 /* Returns true if ARGS (a collection of template arguments) contains
16015 any dependent arguments. */
16018 any_dependent_template_arguments_p (const_tree args)
16025 if (args == error_mark_node)
16028 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
16030 const_tree level = TMPL_ARGS_LEVEL (args, i + 1);
16031 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
16032 if (dependent_template_arg_p (TREE_VEC_ELT (level, j)))
16039 /* Returns TRUE if the template TMPL is dependent. */
16042 dependent_template_p (tree tmpl)
16044 if (TREE_CODE (tmpl) == OVERLOAD)
16048 if (dependent_template_p (OVL_FUNCTION (tmpl)))
16050 tmpl = OVL_CHAIN (tmpl);
16055 /* Template template parameters are dependent. */
16056 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
16057 || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
16059 /* So are names that have not been looked up. */
16060 if (TREE_CODE (tmpl) == SCOPE_REF
16061 || TREE_CODE (tmpl) == IDENTIFIER_NODE)
16063 /* So are member templates of dependent classes. */
16064 if (TYPE_P (CP_DECL_CONTEXT (tmpl)))
16065 return dependent_type_p (DECL_CONTEXT (tmpl));
16069 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
16072 dependent_template_id_p (tree tmpl, tree args)
16074 return (dependent_template_p (tmpl)
16075 || any_dependent_template_arguments_p (args));
16078 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
16079 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
16080 no such TYPE can be found. Note that this function peers inside
16081 uninstantiated templates and therefore should be used only in
16082 extremely limited situations. ONLY_CURRENT_P restricts this
16083 peering to the currently open classes hierarchy (which is required
16084 when comparing types). */
16087 resolve_typename_type (tree type, bool only_current_p)
16096 gcc_assert (TREE_CODE (type) == TYPENAME_TYPE);
16098 scope = TYPE_CONTEXT (type);
16099 name = TYPE_IDENTIFIER (type);
16101 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
16102 it first before we can figure out what NAME refers to. */
16103 if (TREE_CODE (scope) == TYPENAME_TYPE)
16104 scope = resolve_typename_type (scope, only_current_p);
16105 /* If we don't know what SCOPE refers to, then we cannot resolve the
16107 if (TREE_CODE (scope) == TYPENAME_TYPE)
16109 /* If the SCOPE is a template type parameter, we have no way of
16110 resolving the name. */
16111 if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
16113 /* If the SCOPE is not the current instantiation, there's no reason
16114 to look inside it. */
16115 if (only_current_p && !currently_open_class (scope))
16117 /* If SCOPE isn't the template itself, it will not have a valid
16118 TYPE_FIELDS list. */
16119 if (same_type_p (scope, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope)))
16120 /* scope is either the template itself or a compatible instantiation
16121 like X<T>, so look up the name in the original template. */
16122 scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope);
16124 /* scope is a partial instantiation, so we can't do the lookup or we
16125 will lose the template arguments. */
16127 /* Enter the SCOPE so that name lookup will be resolved as if we
16128 were in the class definition. In particular, SCOPE will no
16129 longer be considered a dependent type. */
16130 pushed_scope = push_scope (scope);
16131 /* Look up the declaration. */
16132 decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true);
16134 result = NULL_TREE;
16136 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
16137 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
16140 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE
16141 && TREE_CODE (decl) == TYPE_DECL)
16143 result = TREE_TYPE (decl);
16144 if (result == error_mark_node)
16145 result = NULL_TREE;
16147 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR
16148 && DECL_CLASS_TEMPLATE_P (decl))
16152 /* Obtain the template and the arguments. */
16153 tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0);
16154 args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1);
16155 /* Instantiate the template. */
16156 result = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE,
16157 /*entering_scope=*/0,
16158 tf_error | tf_user);
16159 if (result == error_mark_node)
16160 result = NULL_TREE;
16163 /* Leave the SCOPE. */
16165 pop_scope (pushed_scope);
16167 /* If we failed to resolve it, return the original typename. */
16171 /* If lookup found a typename type, resolve that too. */
16172 if (TREE_CODE (result) == TYPENAME_TYPE && !TYPENAME_IS_RESOLVING_P (result))
16174 /* Ill-formed programs can cause infinite recursion here, so we
16175 must catch that. */
16176 TYPENAME_IS_RESOLVING_P (type) = 1;
16177 result = resolve_typename_type (result, only_current_p);
16178 TYPENAME_IS_RESOLVING_P (type) = 0;
16181 /* Qualify the resulting type. */
16182 quals = cp_type_quals (type);
16184 result = cp_build_qualified_type (result, cp_type_quals (result) | quals);
16189 /* EXPR is an expression which is not type-dependent. Return a proxy
16190 for EXPR that can be used to compute the types of larger
16191 expressions containing EXPR. */
16194 build_non_dependent_expr (tree expr)
16198 /* Preserve null pointer constants so that the type of things like
16199 "p == 0" where "p" is a pointer can be determined. */
16200 if (null_ptr_cst_p (expr))
16202 /* Preserve OVERLOADs; the functions must be available to resolve
16205 if (TREE_CODE (inner_expr) == STMT_EXPR)
16206 inner_expr = stmt_expr_value_expr (inner_expr);
16207 if (TREE_CODE (inner_expr) == ADDR_EXPR)
16208 inner_expr = TREE_OPERAND (inner_expr, 0);
16209 if (TREE_CODE (inner_expr) == COMPONENT_REF)
16210 inner_expr = TREE_OPERAND (inner_expr, 1);
16211 if (is_overloaded_fn (inner_expr)
16212 || TREE_CODE (inner_expr) == OFFSET_REF)
16214 /* There is no need to return a proxy for a variable. */
16215 if (TREE_CODE (expr) == VAR_DECL)
16217 /* Preserve string constants; conversions from string constants to
16218 "char *" are allowed, even though normally a "const char *"
16219 cannot be used to initialize a "char *". */
16220 if (TREE_CODE (expr) == STRING_CST)
16222 /* Preserve arithmetic constants, as an optimization -- there is no
16223 reason to create a new node. */
16224 if (TREE_CODE (expr) == INTEGER_CST || TREE_CODE (expr) == REAL_CST)
16226 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
16227 There is at least one place where we want to know that a
16228 particular expression is a throw-expression: when checking a ?:
16229 expression, there are special rules if the second or third
16230 argument is a throw-expression. */
16231 if (TREE_CODE (expr) == THROW_EXPR)
16234 if (TREE_CODE (expr) == COND_EXPR)
16235 return build3 (COND_EXPR,
16237 TREE_OPERAND (expr, 0),
16238 (TREE_OPERAND (expr, 1)
16239 ? build_non_dependent_expr (TREE_OPERAND (expr, 1))
16240 : build_non_dependent_expr (TREE_OPERAND (expr, 0))),
16241 build_non_dependent_expr (TREE_OPERAND (expr, 2)));
16242 if (TREE_CODE (expr) == COMPOUND_EXPR
16243 && !COMPOUND_EXPR_OVERLOADED (expr))
16244 return build2 (COMPOUND_EXPR,
16246 TREE_OPERAND (expr, 0),
16247 build_non_dependent_expr (TREE_OPERAND (expr, 1)));
16249 /* If the type is unknown, it can't really be non-dependent */
16250 gcc_assert (TREE_TYPE (expr) != unknown_type_node);
16252 /* Otherwise, build a NON_DEPENDENT_EXPR.
16254 REFERENCE_TYPEs are not stripped for expressions in templates
16255 because doing so would play havoc with mangling. Consider, for
16258 template <typename T> void f<T& g>() { g(); }
16260 In the body of "f", the expression for "g" will have
16261 REFERENCE_TYPE, even though the standard says that it should
16262 not. The reason is that we must preserve the syntactic form of
16263 the expression so that mangling (say) "f<g>" inside the body of
16264 "f" works out correctly. Therefore, the REFERENCE_TYPE is
16266 return build1 (NON_DEPENDENT_EXPR, non_reference (TREE_TYPE (expr)), expr);
16269 /* ARGS is a TREE_LIST of expressions as arguments to a function call.
16270 Return a new TREE_LIST with the various arguments replaced with
16271 equivalent non-dependent expressions. */
16274 build_non_dependent_args (tree args)
16279 new_args = NULL_TREE;
16280 for (a = args; a; a = TREE_CHAIN (a))
16281 new_args = tree_cons (NULL_TREE,
16282 build_non_dependent_expr (TREE_VALUE (a)),
16284 return nreverse (new_args);
16287 #include "gt-cp-pt.h"