1 /* Handle parameterized types (templates) for GNU C++.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
4 Free Software Foundation, Inc.
5 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
6 Rewritten by Jason Merrill (jason@cygnus.com).
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
15 GCC is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
24 /* Known bugs or deficiencies include:
26 all methods must be provided in header files; can't use a source
27 file that contains only the method templates and "just win". */
31 #include "coretypes.h"
36 #include "pointer-set.h"
40 #include "cp-objcp-common.h"
41 #include "tree-inline.h"
48 #include "tree-iterator.h"
51 /* The type of functions taking a tree, and some additional data, and
53 typedef int (*tree_fn_t) (tree, void*);
55 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
56 instantiations have been deferred, either because their definitions
57 were not yet available, or because we were putting off doing the work. */
58 struct GTY (()) pending_template {
59 struct pending_template *next;
60 struct tinst_level *tinst;
63 static GTY(()) struct pending_template *pending_templates;
64 static GTY(()) struct pending_template *last_pending_template;
66 int processing_template_parmlist;
67 static int template_header_count;
69 static GTY(()) tree saved_trees;
70 static VEC(int,heap) *inline_parm_levels;
72 static GTY(()) struct tinst_level *current_tinst_level;
74 static GTY(()) tree saved_access_scope;
76 /* Live only within one (recursive) call to tsubst_expr. We use
77 this to pass the statement expression node from the STMT_EXPR
78 to the EXPR_STMT that is its result. */
79 static tree cur_stmt_expr;
81 /* A map from local variable declarations in the body of the template
82 presently being instantiated to the corresponding instantiated
84 static htab_t local_specializations;
86 typedef struct GTY(()) spec_entry
93 static GTY ((param_is (spec_entry)))
94 htab_t decl_specializations;
96 static GTY ((param_is (spec_entry)))
97 htab_t type_specializations;
99 /* Contains canonical template parameter types. The vector is indexed by
100 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
101 TREE_LIST, whose TREE_VALUEs contain the canonical template
102 parameters of various types and levels. */
103 static GTY(()) VEC(tree,gc) *canonical_template_parms;
105 #define UNIFY_ALLOW_NONE 0
106 #define UNIFY_ALLOW_MORE_CV_QUAL 1
107 #define UNIFY_ALLOW_LESS_CV_QUAL 2
108 #define UNIFY_ALLOW_DERIVED 4
109 #define UNIFY_ALLOW_INTEGER 8
110 #define UNIFY_ALLOW_OUTER_LEVEL 16
111 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
112 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
114 static void push_access_scope (tree);
115 static void pop_access_scope (tree);
116 static bool resolve_overloaded_unification (tree, tree, tree, tree,
117 unification_kind_t, int);
118 static int try_one_overload (tree, tree, tree, tree, tree,
119 unification_kind_t, int, bool);
120 static int unify (tree, tree, tree, tree, int);
121 static void add_pending_template (tree);
122 static tree reopen_tinst_level (struct tinst_level *);
123 static tree tsubst_initializer_list (tree, tree);
124 static tree get_class_bindings (tree, tree, tree);
125 static tree coerce_template_parms (tree, tree, tree, tsubst_flags_t,
127 static void tsubst_enum (tree, tree, tree);
128 static tree add_to_template_args (tree, tree);
129 static tree add_outermost_template_args (tree, tree);
130 static bool check_instantiated_args (tree, tree, tsubst_flags_t);
131 static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*,
133 static int type_unification_real (tree, tree, tree, const tree *,
134 unsigned int, int, unification_kind_t, int);
135 static void note_template_header (int);
136 static tree convert_nontype_argument_function (tree, tree);
137 static tree convert_nontype_argument (tree, tree);
138 static tree convert_template_argument (tree, tree, tree,
139 tsubst_flags_t, int, tree);
140 static int for_each_template_parm (tree, tree_fn_t, void*,
141 struct pointer_set_t*, bool);
142 static tree expand_template_argument_pack (tree);
143 static tree build_template_parm_index (int, int, int, tree, tree);
144 static bool inline_needs_template_parms (tree);
145 static void push_inline_template_parms_recursive (tree, int);
146 static tree retrieve_local_specialization (tree);
147 static void register_local_specialization (tree, tree);
148 static hashval_t hash_specialization (const void *p);
149 static tree reduce_template_parm_level (tree, tree, int, tree, tsubst_flags_t);
150 static int mark_template_parm (tree, void *);
151 static int template_parm_this_level_p (tree, void *);
152 static tree tsubst_friend_function (tree, tree);
153 static tree tsubst_friend_class (tree, tree);
154 static int can_complete_type_without_circularity (tree);
155 static tree get_bindings (tree, tree, tree, bool);
156 static int template_decl_level (tree);
157 static int check_cv_quals_for_unify (int, tree, tree);
158 static void template_parm_level_and_index (tree, int*, int*);
159 static int unify_pack_expansion (tree, tree, tree, tree, int, bool, bool);
160 static tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree);
161 static tree tsubst_template_args (tree, tree, tsubst_flags_t, tree);
162 static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
163 static void regenerate_decl_from_template (tree, tree);
164 static tree most_specialized_class (tree, tree);
165 static tree tsubst_aggr_type (tree, tree, tsubst_flags_t, tree, int);
166 static tree tsubst_arg_types (tree, tree, tsubst_flags_t, tree);
167 static tree tsubst_function_type (tree, tree, tsubst_flags_t, tree);
168 static bool check_specialization_scope (void);
169 static tree process_partial_specialization (tree);
170 static void set_current_access_from_decl (tree);
171 static tree get_template_base (tree, tree, tree, tree);
172 static tree try_class_unification (tree, tree, tree, tree);
173 static int coerce_template_template_parms (tree, tree, tsubst_flags_t,
175 static bool template_template_parm_bindings_ok_p (tree, tree);
176 static int template_args_equal (tree, tree);
177 static void tsubst_default_arguments (tree);
178 static tree for_each_template_parm_r (tree *, int *, void *);
179 static tree copy_default_args_to_explicit_spec_1 (tree, tree);
180 static void copy_default_args_to_explicit_spec (tree);
181 static int invalid_nontype_parm_type_p (tree, tsubst_flags_t);
182 static int eq_local_specializations (const void *, const void *);
183 static bool dependent_template_arg_p (tree);
184 static bool any_template_arguments_need_structural_equality_p (tree);
185 static bool dependent_type_p_r (tree);
186 static tree tsubst_expr (tree, tree, tsubst_flags_t, tree, bool);
187 static tree tsubst_copy (tree, tree, tsubst_flags_t, tree);
188 static tree tsubst_pack_expansion (tree, tree, tsubst_flags_t, tree);
189 static tree tsubst_decl (tree, tree, tsubst_flags_t);
190 static void perform_typedefs_access_check (tree tmpl, tree targs);
191 static void append_type_to_template_for_access_check_1 (tree, tree, tree,
193 static hashval_t iterative_hash_template_arg (tree arg, hashval_t val);
194 static tree listify (tree);
195 static tree listify_autos (tree, tree);
197 /* Make the current scope suitable for access checking when we are
198 processing T. T can be FUNCTION_DECL for instantiated function
199 template, or VAR_DECL for static member variable (need by
200 instantiate_decl). */
203 push_access_scope (tree t)
205 gcc_assert (TREE_CODE (t) == FUNCTION_DECL
206 || TREE_CODE (t) == VAR_DECL);
208 if (DECL_FRIEND_CONTEXT (t))
209 push_nested_class (DECL_FRIEND_CONTEXT (t));
210 else if (DECL_CLASS_SCOPE_P (t))
211 push_nested_class (DECL_CONTEXT (t));
213 push_to_top_level ();
215 if (TREE_CODE (t) == FUNCTION_DECL)
217 saved_access_scope = tree_cons
218 (NULL_TREE, current_function_decl, saved_access_scope);
219 current_function_decl = t;
223 /* Restore the scope set up by push_access_scope. T is the node we
227 pop_access_scope (tree t)
229 if (TREE_CODE (t) == FUNCTION_DECL)
231 current_function_decl = TREE_VALUE (saved_access_scope);
232 saved_access_scope = TREE_CHAIN (saved_access_scope);
235 if (DECL_FRIEND_CONTEXT (t) || DECL_CLASS_SCOPE_P (t))
238 pop_from_top_level ();
241 /* Do any processing required when DECL (a member template
242 declaration) is finished. Returns the TEMPLATE_DECL corresponding
243 to DECL, unless it is a specialization, in which case the DECL
244 itself is returned. */
247 finish_member_template_decl (tree decl)
249 if (decl == error_mark_node)
250 return error_mark_node;
252 gcc_assert (DECL_P (decl));
254 if (TREE_CODE (decl) == TYPE_DECL)
258 type = TREE_TYPE (decl);
259 if (type == error_mark_node)
260 return error_mark_node;
261 if (MAYBE_CLASS_TYPE_P (type)
262 && CLASSTYPE_TEMPLATE_INFO (type)
263 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
265 tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
266 check_member_template (tmpl);
271 else if (TREE_CODE (decl) == FIELD_DECL)
272 error ("data member %qD cannot be a member template", decl);
273 else if (DECL_TEMPLATE_INFO (decl))
275 if (!DECL_TEMPLATE_SPECIALIZATION (decl))
277 check_member_template (DECL_TI_TEMPLATE (decl));
278 return DECL_TI_TEMPLATE (decl);
284 error ("invalid member template declaration %qD", decl);
286 return error_mark_node;
289 /* Create a template info node. */
292 build_template_info (tree template_decl, tree template_args)
294 tree result = make_node (TEMPLATE_INFO);
295 TI_TEMPLATE (result) = template_decl;
296 TI_ARGS (result) = template_args;
300 /* Return the template info node corresponding to T, whatever T is. */
303 get_template_info (const_tree t)
305 tree tinfo = NULL_TREE;
307 if (!t || t == error_mark_node)
310 if (DECL_P (t) && DECL_LANG_SPECIFIC (t))
311 tinfo = DECL_TEMPLATE_INFO (t);
313 if (!tinfo && DECL_IMPLICIT_TYPEDEF_P (t))
316 if (TAGGED_TYPE_P (t))
317 tinfo = TYPE_TEMPLATE_INFO (t);
318 else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
319 tinfo = TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t);
324 /* Returns the template nesting level of the indicated class TYPE.
334 A<T>::B<U> has depth two, while A<T> has depth one.
335 Both A<T>::B<int> and A<int>::B<U> have depth one, if
336 they are instantiations, not specializations.
338 This function is guaranteed to return 0 if passed NULL_TREE so
339 that, for example, `template_class_depth (current_class_type)' is
343 template_class_depth (tree type)
348 type && TREE_CODE (type) != NAMESPACE_DECL;
349 type = (TREE_CODE (type) == FUNCTION_DECL)
350 ? CP_DECL_CONTEXT (type) : TYPE_CONTEXT (type))
352 tree tinfo = get_template_info (type);
354 if (tinfo && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo))
355 && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo))))
362 /* Subroutine of maybe_begin_member_template_processing.
363 Returns true if processing DECL needs us to push template parms. */
366 inline_needs_template_parms (tree decl)
368 if (! DECL_TEMPLATE_INFO (decl))
371 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl)))
372 > (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl)));
375 /* Subroutine of maybe_begin_member_template_processing.
376 Push the template parms in PARMS, starting from LEVELS steps into the
377 chain, and ending at the beginning, since template parms are listed
381 push_inline_template_parms_recursive (tree parmlist, int levels)
383 tree parms = TREE_VALUE (parmlist);
387 push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1);
389 ++processing_template_decl;
390 current_template_parms
391 = tree_cons (size_int (processing_template_decl),
392 parms, current_template_parms);
393 TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1;
395 begin_scope (TREE_VEC_LENGTH (parms) ? sk_template_parms : sk_template_spec,
397 for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
399 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
401 if (parm == error_mark_node)
404 gcc_assert (DECL_P (parm));
406 switch (TREE_CODE (parm))
415 /* Make a CONST_DECL as is done in process_template_parm.
416 It is ugly that we recreate this here; the original
417 version built in process_template_parm is no longer
419 tree decl = build_decl (DECL_SOURCE_LOCATION (parm),
420 CONST_DECL, DECL_NAME (parm),
422 DECL_ARTIFICIAL (decl) = 1;
423 TREE_CONSTANT (decl) = 1;
424 TREE_READONLY (decl) = 1;
425 DECL_INITIAL (decl) = DECL_INITIAL (parm);
426 SET_DECL_TEMPLATE_PARM_P (decl);
437 /* Restore the template parameter context for a member template or
438 a friend template defined in a class definition. */
441 maybe_begin_member_template_processing (tree decl)
446 if (inline_needs_template_parms (decl))
448 parms = DECL_TEMPLATE_PARMS (most_general_template (decl));
449 levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl;
451 if (DECL_TEMPLATE_SPECIALIZATION (decl))
454 parms = TREE_CHAIN (parms);
457 push_inline_template_parms_recursive (parms, levels);
460 /* Remember how many levels of template parameters we pushed so that
461 we can pop them later. */
462 VEC_safe_push (int, heap, inline_parm_levels, levels);
465 /* Undo the effects of maybe_begin_member_template_processing. */
468 maybe_end_member_template_processing (void)
473 if (VEC_length (int, inline_parm_levels) == 0)
476 last = VEC_pop (int, inline_parm_levels);
477 for (i = 0; i < last; ++i)
479 --processing_template_decl;
480 current_template_parms = TREE_CHAIN (current_template_parms);
485 /* Return a new template argument vector which contains all of ARGS,
486 but has as its innermost set of arguments the EXTRA_ARGS. */
489 add_to_template_args (tree args, tree extra_args)
496 if (args == NULL_TREE)
499 extra_depth = TMPL_ARGS_DEPTH (extra_args);
500 new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth);
502 for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i)
503 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));
505 for (j = 1; j <= extra_depth; ++j, ++i)
506 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));
511 /* Like add_to_template_args, but only the outermost ARGS are added to
512 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
513 (EXTRA_ARGS) levels are added. This function is used to combine
514 the template arguments from a partial instantiation with the
515 template arguments used to attain the full instantiation from the
516 partial instantiation. */
519 add_outermost_template_args (tree args, tree extra_args)
523 /* If there are more levels of EXTRA_ARGS than there are ARGS,
524 something very fishy is going on. */
525 gcc_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args));
527 /* If *all* the new arguments will be the EXTRA_ARGS, just return
529 if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
532 /* For the moment, we make ARGS look like it contains fewer levels. */
533 TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);
535 new_args = add_to_template_args (args, extra_args);
537 /* Now, we restore ARGS to its full dimensions. */
538 TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);
543 /* Return the N levels of innermost template arguments from the ARGS. */
546 get_innermost_template_args (tree args, int n)
554 /* If N is 1, just return the innermost set of template arguments. */
556 return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args));
558 /* If we're not removing anything, just return the arguments we were
560 extra_levels = TMPL_ARGS_DEPTH (args) - n;
561 gcc_assert (extra_levels >= 0);
562 if (extra_levels == 0)
565 /* Make a new set of arguments, not containing the outer arguments. */
566 new_args = make_tree_vec (n);
567 for (i = 1; i <= n; ++i)
568 SET_TMPL_ARGS_LEVEL (new_args, i,
569 TMPL_ARGS_LEVEL (args, i + extra_levels));
574 /* The inverse of get_innermost_template_args: Return all but the innermost
575 EXTRA_LEVELS levels of template arguments from the ARGS. */
578 strip_innermost_template_args (tree args, int extra_levels)
581 int n = TMPL_ARGS_DEPTH (args) - extra_levels;
586 /* If N is 1, just return the outermost set of template arguments. */
588 return TMPL_ARGS_LEVEL (args, 1);
590 /* If we're not removing anything, just return the arguments we were
592 gcc_assert (extra_levels >= 0);
593 if (extra_levels == 0)
596 /* Make a new set of arguments, not containing the inner arguments. */
597 new_args = make_tree_vec (n);
598 for (i = 1; i <= n; ++i)
599 SET_TMPL_ARGS_LEVEL (new_args, i,
600 TMPL_ARGS_LEVEL (args, i));
605 /* We've got a template header coming up; push to a new level for storing
609 begin_template_parm_list (void)
611 /* We use a non-tag-transparent scope here, which causes pushtag to
612 put tags in this scope, rather than in the enclosing class or
613 namespace scope. This is the right thing, since we want
614 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
615 global template class, push_template_decl handles putting the
616 TEMPLATE_DECL into top-level scope. For a nested template class,
619 template <class T> struct S1 {
620 template <class T> struct S2 {};
623 pushtag contains special code to call pushdecl_with_scope on the
624 TEMPLATE_DECL for S2. */
625 begin_scope (sk_template_parms, NULL);
626 ++processing_template_decl;
627 ++processing_template_parmlist;
628 note_template_header (0);
631 /* This routine is called when a specialization is declared. If it is
632 invalid to declare a specialization here, an error is reported and
633 false is returned, otherwise this routine will return true. */
636 check_specialization_scope (void)
638 tree scope = current_scope ();
642 An explicit specialization shall be declared in the namespace of
643 which the template is a member, or, for member templates, in the
644 namespace of which the enclosing class or enclosing class
645 template is a member. An explicit specialization of a member
646 function, member class or static data member of a class template
647 shall be declared in the namespace of which the class template
649 if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
651 error ("explicit specialization in non-namespace scope %qD", scope);
657 In an explicit specialization declaration for a member of a class
658 template or a member template that appears in namespace scope,
659 the member template and some of its enclosing class templates may
660 remain unspecialized, except that the declaration shall not
661 explicitly specialize a class member template if its enclosing
662 class templates are not explicitly specialized as well. */
663 if (current_template_parms)
665 error ("enclosing class templates are not explicitly specialized");
672 /* We've just seen template <>. */
675 begin_specialization (void)
677 begin_scope (sk_template_spec, NULL);
678 note_template_header (1);
679 return check_specialization_scope ();
682 /* Called at then end of processing a declaration preceded by
686 end_specialization (void)
689 reset_specialization ();
692 /* Any template <>'s that we have seen thus far are not referring to a
693 function specialization. */
696 reset_specialization (void)
698 processing_specialization = 0;
699 template_header_count = 0;
702 /* We've just seen a template header. If SPECIALIZATION is nonzero,
703 it was of the form template <>. */
706 note_template_header (int specialization)
708 processing_specialization = specialization;
709 template_header_count++;
712 /* We're beginning an explicit instantiation. */
715 begin_explicit_instantiation (void)
717 gcc_assert (!processing_explicit_instantiation);
718 processing_explicit_instantiation = true;
723 end_explicit_instantiation (void)
725 gcc_assert (processing_explicit_instantiation);
726 processing_explicit_instantiation = false;
729 /* An explicit specialization or partial specialization TMPL is being
730 declared. Check that the namespace in which the specialization is
731 occurring is permissible. Returns false iff it is invalid to
732 specialize TMPL in the current namespace. */
735 check_specialization_namespace (tree tmpl)
737 tree tpl_ns = decl_namespace_context (tmpl);
741 An explicit specialization shall be declared in the namespace of
742 which the template is a member, or, for member templates, in the
743 namespace of which the enclosing class or enclosing class
744 template is a member. An explicit specialization of a member
745 function, member class or static data member of a class template
746 shall be declared in the namespace of which the class template is
748 if (current_scope() != DECL_CONTEXT (tmpl)
749 && !at_namespace_scope_p ())
751 error ("specialization of %qD must appear at namespace scope", tmpl);
754 if (is_associated_namespace (current_namespace, tpl_ns))
755 /* Same or super-using namespace. */
759 permerror (input_location, "specialization of %qD in different namespace", tmpl);
760 permerror (input_location, " from definition of %q+#D", tmpl);
765 /* SPEC is an explicit instantiation. Check that it is valid to
766 perform this explicit instantiation in the current namespace. */
769 check_explicit_instantiation_namespace (tree spec)
773 /* DR 275: An explicit instantiation shall appear in an enclosing
774 namespace of its template. */
775 ns = decl_namespace_context (spec);
776 if (!is_ancestor (current_namespace, ns))
777 permerror (input_location, "explicit instantiation of %qD in namespace %qD "
778 "(which does not enclose namespace %qD)",
779 spec, current_namespace, ns);
782 /* The TYPE is being declared. If it is a template type, that means it
783 is a partial specialization. Do appropriate error-checking. */
786 maybe_process_partial_specialization (tree type)
790 if (type == error_mark_node)
791 return error_mark_node;
793 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
795 error ("name of class shadows template template parameter %qD",
797 return error_mark_node;
800 context = TYPE_CONTEXT (type);
802 if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type))
804 /* This is for ordinary explicit specialization and partial
805 specialization of a template class such as:
807 template <> class C<int>;
811 template <class T> class C<T*>;
813 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
815 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
816 && !COMPLETE_TYPE_P (type))
818 check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type));
819 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
820 if (processing_template_decl)
822 if (push_template_decl (TYPE_MAIN_DECL (type))
824 return error_mark_node;
827 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
828 error ("specialization of %qT after instantiation", type);
830 else if (CLASS_TYPE_P (type)
831 && !CLASSTYPE_USE_TEMPLATE (type)
832 && CLASSTYPE_TEMPLATE_INFO (type)
833 && context && CLASS_TYPE_P (context)
834 && CLASSTYPE_TEMPLATE_INFO (context))
836 /* This is for an explicit specialization of member class
837 template according to [temp.expl.spec/18]:
839 template <> template <class U> class C<int>::D;
841 The context `C<int>' must be an implicit instantiation.
842 Otherwise this is just a member class template declared
845 template <> class C<int> { template <class U> class D; };
846 template <> template <class U> class C<int>::D;
848 In the first case, `C<int>::D' is a specialization of `C<T>::D'
849 while in the second case, `C<int>::D' is a primary template
850 and `C<T>::D' may not exist. */
852 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context)
853 && !COMPLETE_TYPE_P (type))
856 tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
858 if (current_namespace
859 != decl_namespace_context (tmpl))
861 permerror (input_location, "specializing %q#T in different namespace", type);
862 permerror (input_location, " from definition of %q+#D", tmpl);
865 /* Check for invalid specialization after instantiation:
867 template <> template <> class C<int>::D<int>;
868 template <> template <class U> class C<int>::D; */
870 for (t = DECL_TEMPLATE_INSTANTIATIONS (tmpl);
871 t; t = TREE_CHAIN (t))
873 tree inst = TREE_VALUE (t);
874 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst))
876 /* We already have a full specialization of this partial
877 instantiation. Reassign it to the new member
878 specialization template. */
882 elt.tmpl = most_general_template (tmpl);
883 elt.args = CLASSTYPE_TI_ARGS (inst);
886 htab_remove_elt (type_specializations, &elt);
889 elt.args = INNERMOST_TEMPLATE_ARGS (elt.args);
891 slot = (spec_entry **)
892 htab_find_slot (type_specializations, &elt, INSERT);
893 *slot = GGC_NEW (spec_entry);
896 else if (COMPLETE_TYPE_P (inst) || TYPE_BEING_DEFINED (inst))
897 /* But if we've had an implicit instantiation, that's a
898 problem ([temp.expl.spec]/6). */
899 error ("specialization %qT after instantiation %qT",
903 /* Mark TYPE as a specialization. And as a result, we only
904 have one level of template argument for the innermost
906 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
907 CLASSTYPE_TI_ARGS (type)
908 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
911 else if (processing_specialization)
913 error ("explicit specialization of non-template %qT", type);
914 return error_mark_node;
920 /* Returns nonzero if we can optimize the retrieval of specializations
921 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
922 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
925 optimize_specialization_lookup_p (tree tmpl)
927 return (DECL_FUNCTION_TEMPLATE_P (tmpl)
928 && DECL_CLASS_SCOPE_P (tmpl)
929 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
931 && CLASS_TYPE_P (DECL_CONTEXT (tmpl))
932 /* The optimized lookup depends on the fact that the
933 template arguments for the member function template apply
934 purely to the containing class, which is not true if the
935 containing class is an explicit or partial
937 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl))
938 && !DECL_MEMBER_TEMPLATE_P (tmpl)
939 && !DECL_CONV_FN_P (tmpl)
940 /* It is possible to have a template that is not a member
941 template and is not a member of a template class:
943 template <typename T>
944 struct S { friend A::f(); };
946 Here, the friend function is a template, but the context does
947 not have template information. The optimized lookup relies
948 on having ARGS be the template arguments for both the class
949 and the function template. */
950 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl)));
953 /* Retrieve the specialization (in the sense of [temp.spec] - a
954 specialization is either an instantiation or an explicit
955 specialization) of TMPL for the given template ARGS. If there is
956 no such specialization, return NULL_TREE. The ARGS are a vector of
957 arguments, or a vector of vectors of arguments, in the case of
958 templates with more than one level of parameters.
960 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
961 then we search for a partial specialization matching ARGS. This
962 parameter is ignored if TMPL is not a class template. */
965 retrieve_specialization (tree tmpl, tree args, hashval_t hash)
967 if (args == error_mark_node)
970 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
972 /* There should be as many levels of arguments as there are
973 levels of parameters. */
974 gcc_assert (TMPL_ARGS_DEPTH (args)
975 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)));
977 if (optimize_specialization_lookup_p (tmpl))
980 tree class_specialization;
981 VEC(tree,gc) *methods;
985 /* The template arguments actually apply to the containing
986 class. Find the class specialization with those
988 class_template = CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl));
990 = retrieve_specialization (class_template, args, 0);
991 if (!class_specialization)
993 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
994 for the specialization. */
995 idx = class_method_index_for_fn (class_specialization, tmpl);
998 /* Iterate through the methods with the indicated name, looking
999 for the one that has an instance of TMPL. */
1000 methods = CLASSTYPE_METHOD_VEC (class_specialization);
1001 for (fns = VEC_index (tree, methods, idx); fns; fns = OVL_NEXT (fns))
1003 tree fn = OVL_CURRENT (fns);
1004 if (DECL_TEMPLATE_INFO (fn) && DECL_TI_TEMPLATE (fn) == tmpl
1005 /* using-declarations can add base methods to the method vec,
1006 and we don't want those here. */
1007 && DECL_CONTEXT (fn) == class_specialization)
1016 htab_t specializations;
1020 elt.spec = NULL_TREE;
1022 if (DECL_CLASS_TEMPLATE_P (tmpl))
1023 specializations = type_specializations;
1025 specializations = decl_specializations;
1028 hash = hash_specialization (&elt);
1029 found = (spec_entry *) htab_find_with_hash (specializations, &elt, hash);
1037 /* Like retrieve_specialization, but for local declarations. */
1040 retrieve_local_specialization (tree tmpl)
1044 if (local_specializations == NULL)
1047 spec = (tree) htab_find_with_hash (local_specializations, tmpl,
1048 htab_hash_pointer (tmpl));
1049 return spec ? TREE_PURPOSE (spec) : NULL_TREE;
1052 /* Returns nonzero iff DECL is a specialization of TMPL. */
1055 is_specialization_of (tree decl, tree tmpl)
1059 if (TREE_CODE (decl) == FUNCTION_DECL)
1063 t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
1069 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
1071 for (t = TREE_TYPE (decl);
1073 t = CLASSTYPE_USE_TEMPLATE (t)
1074 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
1075 if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl)))
1082 /* Returns nonzero iff DECL is a specialization of friend declaration
1083 FRIEND_DECL according to [temp.friend]. */
1086 is_specialization_of_friend (tree decl, tree friend_decl)
1088 bool need_template = true;
1091 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
1092 || TREE_CODE (decl) == TYPE_DECL);
1094 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1095 of a template class, we want to check if DECL is a specialization
1097 if (TREE_CODE (friend_decl) == FUNCTION_DECL
1098 && DECL_TEMPLATE_INFO (friend_decl)
1099 && !DECL_USE_TEMPLATE (friend_decl))
1101 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1102 friend_decl = DECL_TI_TEMPLATE (friend_decl);
1103 need_template = false;
1105 else if (TREE_CODE (friend_decl) == TEMPLATE_DECL
1106 && !PRIMARY_TEMPLATE_P (friend_decl))
1107 need_template = false;
1109 /* There is nothing to do if this is not a template friend. */
1110 if (TREE_CODE (friend_decl) != TEMPLATE_DECL)
1113 if (is_specialization_of (decl, friend_decl))
1117 A member of a class template may be declared to be a friend of a
1118 non-template class. In this case, the corresponding member of
1119 every specialization of the class template is a friend of the
1120 class granting friendship.
1122 For example, given a template friend declaration
1124 template <class T> friend void A<T>::f();
1126 the member function below is considered a friend
1128 template <> struct A<int> {
1132 For this type of template friend, TEMPLATE_DEPTH below will be
1133 nonzero. To determine if DECL is a friend of FRIEND, we first
1134 check if the enclosing class is a specialization of another. */
1136 template_depth = template_class_depth (DECL_CONTEXT (friend_decl));
1138 && DECL_CLASS_SCOPE_P (decl)
1139 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)),
1140 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl))))
1142 /* Next, we check the members themselves. In order to handle
1143 a few tricky cases, such as when FRIEND_DECL's are
1145 template <class T> friend void A<T>::g(T t);
1146 template <class T> template <T t> friend void A<T>::h();
1150 void A<int>::g(int);
1151 template <int> void A<int>::h();
1153 we need to figure out ARGS, the template arguments from
1154 the context of DECL. This is required for template substitution
1155 of `T' in the function parameter of `g' and template parameter
1156 of `h' in the above examples. Here ARGS corresponds to `int'. */
1158 tree context = DECL_CONTEXT (decl);
1159 tree args = NULL_TREE;
1160 int current_depth = 0;
1162 while (current_depth < template_depth)
1164 if (CLASSTYPE_TEMPLATE_INFO (context))
1166 if (current_depth == 0)
1167 args = TYPE_TI_ARGS (context);
1169 args = add_to_template_args (TYPE_TI_ARGS (context), args);
1172 context = TYPE_CONTEXT (context);
1175 if (TREE_CODE (decl) == FUNCTION_DECL)
1180 tree friend_args_type;
1181 tree decl_args_type;
1183 /* Make sure that both DECL and FRIEND_DECL are templates or
1185 is_template = DECL_TEMPLATE_INFO (decl)
1186 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl));
1187 if (need_template ^ is_template)
1189 else if (is_template)
1191 /* If both are templates, check template parameter list. */
1193 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl),
1195 if (!comp_template_parms
1196 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)),
1200 decl_type = TREE_TYPE (DECL_TI_TEMPLATE (decl));
1203 decl_type = TREE_TYPE (decl);
1205 friend_type = tsubst_function_type (TREE_TYPE (friend_decl), args,
1206 tf_none, NULL_TREE);
1207 if (friend_type == error_mark_node)
1210 /* Check if return types match. */
1211 if (!same_type_p (TREE_TYPE (decl_type), TREE_TYPE (friend_type)))
1214 /* Check if function parameter types match, ignoring the
1215 `this' parameter. */
1216 friend_args_type = TYPE_ARG_TYPES (friend_type);
1217 decl_args_type = TYPE_ARG_TYPES (decl_type);
1218 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl))
1219 friend_args_type = TREE_CHAIN (friend_args_type);
1220 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1221 decl_args_type = TREE_CHAIN (decl_args_type);
1223 return compparms (decl_args_type, friend_args_type);
1227 /* DECL is a TYPE_DECL */
1229 tree decl_type = TREE_TYPE (decl);
1231 /* Make sure that both DECL and FRIEND_DECL are templates or
1234 = CLASSTYPE_TEMPLATE_INFO (decl_type)
1235 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type));
1237 if (need_template ^ is_template)
1239 else if (is_template)
1242 /* If both are templates, check the name of the two
1243 TEMPLATE_DECL's first because is_friend didn't. */
1244 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type))
1245 != DECL_NAME (friend_decl))
1248 /* Now check template parameter list. */
1250 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl),
1252 return comp_template_parms
1253 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type)),
1257 return (DECL_NAME (decl)
1258 == DECL_NAME (friend_decl));
1264 /* Register the specialization SPEC as a specialization of TMPL with
1265 the indicated ARGS. IS_FRIEND indicates whether the specialization
1266 is actually just a friend declaration. Returns SPEC, or an
1267 equivalent prior declaration, if available. */
1270 register_specialization (tree spec, tree tmpl, tree args, bool is_friend,
1274 spec_entry **slot = NULL;
1277 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL && DECL_P (spec));
1279 if (TREE_CODE (spec) == FUNCTION_DECL
1280 && uses_template_parms (DECL_TI_ARGS (spec)))
1281 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1282 register it; we want the corresponding TEMPLATE_DECL instead.
1283 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1284 the more obvious `uses_template_parms (spec)' to avoid problems
1285 with default function arguments. In particular, given
1286 something like this:
1288 template <class T> void f(T t1, T t = T())
1290 the default argument expression is not substituted for in an
1291 instantiation unless and until it is actually needed. */
1294 if (optimize_specialization_lookup_p (tmpl))
1295 /* We don't put these specializations in the hash table, but we might
1296 want to give an error about a mismatch. */
1297 fn = retrieve_specialization (tmpl, args, 0);
1305 hash = hash_specialization (&elt);
1307 slot = (spec_entry **)
1308 htab_find_slot_with_hash (decl_specializations, &elt, hash, INSERT);
1315 /* We can sometimes try to re-register a specialization that we've
1316 already got. In particular, regenerate_decl_from_template calls
1317 duplicate_decls which will update the specialization list. But,
1318 we'll still get called again here anyhow. It's more convenient
1319 to simply allow this than to try to prevent it. */
1322 else if (fn && DECL_TEMPLATE_SPECIALIZATION (spec))
1324 if (DECL_TEMPLATE_INSTANTIATION (fn))
1326 if (DECL_ODR_USED (fn)
1327 || DECL_EXPLICIT_INSTANTIATION (fn))
1329 error ("specialization of %qD after instantiation",
1331 return error_mark_node;
1336 /* This situation should occur only if the first
1337 specialization is an implicit instantiation, the
1338 second is an explicit specialization, and the
1339 implicit instantiation has not yet been used. That
1340 situation can occur if we have implicitly
1341 instantiated a member function and then specialized
1344 We can also wind up here if a friend declaration that
1345 looked like an instantiation turns out to be a
1348 template <class T> void foo(T);
1349 class S { friend void foo<>(int) };
1350 template <> void foo(int);
1352 We transform the existing DECL in place so that any
1353 pointers to it become pointers to the updated
1356 If there was a definition for the template, but not
1357 for the specialization, we want this to look as if
1358 there were no definition, and vice versa. */
1359 DECL_INITIAL (fn) = NULL_TREE;
1360 duplicate_decls (spec, fn, is_friend);
1361 /* The call to duplicate_decls will have applied
1364 An explicit specialization of a function template
1365 is inline only if it is explicitly declared to be,
1366 and independently of whether its function template
1369 to the primary function; now copy the inline bits to
1370 the various clones. */
1371 FOR_EACH_CLONE (clone, fn)
1373 DECL_DECLARED_INLINE_P (clone)
1374 = DECL_DECLARED_INLINE_P (fn);
1375 DECL_SOURCE_LOCATION (clone)
1376 = DECL_SOURCE_LOCATION (fn);
1378 check_specialization_namespace (fn);
1383 else if (DECL_TEMPLATE_SPECIALIZATION (fn))
1385 if (!duplicate_decls (spec, fn, is_friend) && DECL_INITIAL (spec))
1386 /* Dup decl failed, but this is a new definition. Set the
1387 line number so any errors match this new
1389 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec);
1395 return duplicate_decls (spec, fn, is_friend);
1397 /* A specialization must be declared in the same namespace as the
1398 template it is specializing. */
1399 if (DECL_TEMPLATE_SPECIALIZATION (spec)
1400 && !check_specialization_namespace (tmpl))
1401 DECL_CONTEXT (spec) = DECL_CONTEXT (tmpl);
1403 if (!optimize_specialization_lookup_p (tmpl))
1405 gcc_assert (tmpl && args && spec);
1406 *slot = GGC_NEW (spec_entry);
1408 if (TREE_CODE (spec) == FUNCTION_DECL && DECL_NAMESPACE_SCOPE_P (spec)
1409 && PRIMARY_TEMPLATE_P (tmpl)
1410 && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl)) == NULL_TREE)
1411 /* TMPL is a forward declaration of a template function; keep a list
1412 of all specializations in case we need to reassign them to a friend
1413 template later in tsubst_friend_function. */
1414 DECL_TEMPLATE_INSTANTIATIONS (tmpl)
1415 = tree_cons (args, spec, DECL_TEMPLATE_INSTANTIATIONS (tmpl));
1421 /* Returns true iff two spec_entry nodes are equivalent. Only compares the
1422 TMPL and ARGS members, ignores SPEC. */
1425 eq_specializations (const void *p1, const void *p2)
1427 const spec_entry *e1 = (const spec_entry *)p1;
1428 const spec_entry *e2 = (const spec_entry *)p2;
1430 return (e1->tmpl == e2->tmpl
1431 && comp_template_args (e1->args, e2->args));
1434 /* Returns a hash for a template TMPL and template arguments ARGS. */
1437 hash_tmpl_and_args (tree tmpl, tree args)
1439 hashval_t val = DECL_UID (tmpl);
1440 return iterative_hash_template_arg (args, val);
1443 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1447 hash_specialization (const void *p)
1449 const spec_entry *e = (const spec_entry *)p;
1450 return hash_tmpl_and_args (e->tmpl, e->args);
1453 /* Recursively calculate a hash value for a template argument ARG, for use
1454 in the hash tables of template specializations. */
1457 iterative_hash_template_arg (tree arg, hashval_t val)
1459 unsigned HOST_WIDE_INT i;
1460 enum tree_code code;
1463 if (arg == NULL_TREE)
1464 return iterative_hash_object (arg, val);
1469 if (TREE_CODE (arg) == ARGUMENT_PACK_SELECT)
1470 /* We can get one of these when re-hashing a previous entry in the middle
1471 of substituting into a pack expansion. Just look through it. */
1472 arg = ARGUMENT_PACK_SELECT_FROM_PACK (arg);
1474 code = TREE_CODE (arg);
1475 tclass = TREE_CODE_CLASS (code);
1477 val = iterative_hash_object (code, val);
1484 case IDENTIFIER_NODE:
1485 return iterative_hash_object (IDENTIFIER_HASH_VALUE (arg), val);
1489 int i, len = TREE_VEC_LENGTH (arg);
1490 for (i = 0; i < len; ++i)
1491 val = iterative_hash_template_arg (TREE_VEC_ELT (arg, i), val);
1495 case TYPE_PACK_EXPANSION:
1496 case EXPR_PACK_EXPANSION:
1497 return iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg), val);
1499 case TYPE_ARGUMENT_PACK:
1500 case NONTYPE_ARGUMENT_PACK:
1501 return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg), val);
1504 for (; arg; arg = TREE_CHAIN (arg))
1505 val = iterative_hash_template_arg (TREE_VALUE (arg), val);
1509 for (; arg; arg = OVL_CHAIN (arg))
1510 val = iterative_hash_template_arg (OVL_FUNCTION (arg), val);
1516 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg), i, field, value)
1518 val = iterative_hash_template_arg (field, val);
1519 val = iterative_hash_template_arg (value, val);
1525 if (!DECL_ARTIFICIAL (arg))
1526 val = iterative_hash_object (DECL_PARM_INDEX (arg), val);
1527 return iterative_hash_template_arg (TREE_TYPE (arg), val);
1530 return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg), val);
1533 val = iterative_hash_template_arg (PTRMEM_CST_CLASS (arg), val);
1534 return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg), val);
1536 case TEMPLATE_PARM_INDEX:
1537 val = iterative_hash_template_arg
1538 (TREE_TYPE (TEMPLATE_PARM_DECL (arg)), val);
1539 val = iterative_hash_object (TEMPLATE_PARM_LEVEL (arg), val);
1540 return iterative_hash_object (TEMPLATE_PARM_IDX (arg), val);
1543 val = iterative_hash_object (TRAIT_EXPR_KIND (arg), val);
1544 val = iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg), val);
1545 return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg), val);
1548 val = iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg)),
1550 return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg)),
1554 val = iterative_hash_template_arg (TREE_OPERAND (arg, 0), val);
1555 code = TREE_CODE (TREE_OPERAND (arg, 1));
1556 val = iterative_hash_object (code, val);
1557 return iterative_hash_template_arg (TREE_OPERAND (arg, 2), val);
1560 /* layout_type sets structural equality for arrays of
1561 incomplete type, so we can't rely on the canonical type
1563 val = iterative_hash_template_arg (TREE_TYPE (arg), val);
1564 return iterative_hash_template_arg (TYPE_DOMAIN (arg), val);
1570 if (TYPE_CANONICAL (arg))
1571 return iterative_hash_object (TYPE_HASH (TYPE_CANONICAL (arg)),
1573 else if (TREE_CODE (arg) == DECLTYPE_TYPE)
1574 return iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg), val);
1575 /* Otherwise just compare the types during lookup. */
1578 case tcc_declaration:
1580 return iterative_hash_expr (arg, val);
1583 gcc_assert (IS_EXPR_CODE_CLASS (tclass));
1585 unsigned n = TREE_OPERAND_LENGTH (arg);
1586 for (i = 0; i < n; ++i)
1587 val = iterative_hash_template_arg (TREE_OPERAND (arg, i), val);
1596 /* Unregister the specialization SPEC as a specialization of TMPL.
1597 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1598 if the SPEC was listed as a specialization of TMPL.
1600 Note that SPEC has been ggc_freed, so we can't look inside it. */
1603 reregister_specialization (tree spec, tree tinfo, tree new_spec)
1608 elt.tmpl = most_general_template (TI_TEMPLATE (tinfo));
1609 elt.args = TI_ARGS (tinfo);
1610 elt.spec = NULL_TREE;
1612 slot = (spec_entry **) htab_find_slot (decl_specializations, &elt, INSERT);
1615 gcc_assert ((*slot)->spec == spec || (*slot)->spec == new_spec);
1616 gcc_assert (new_spec != NULL_TREE);
1617 (*slot)->spec = new_spec;
1624 /* Compare an entry in the local specializations hash table P1 (which
1625 is really a pointer to a TREE_LIST) with P2 (which is really a
1629 eq_local_specializations (const void *p1, const void *p2)
1631 return TREE_VALUE ((const_tree) p1) == (const_tree) p2;
1634 /* Hash P1, an entry in the local specializations table. */
1637 hash_local_specialization (const void* p1)
1639 return htab_hash_pointer (TREE_VALUE ((const_tree) p1));
1642 /* Like register_specialization, but for local declarations. We are
1643 registering SPEC, an instantiation of TMPL. */
1646 register_local_specialization (tree spec, tree tmpl)
1650 slot = htab_find_slot_with_hash (local_specializations, tmpl,
1651 htab_hash_pointer (tmpl), INSERT);
1652 *slot = build_tree_list (spec, tmpl);
1655 /* TYPE is a class type. Returns true if TYPE is an explicitly
1656 specialized class. */
1659 explicit_class_specialization_p (tree type)
1661 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
1663 return !uses_template_parms (CLASSTYPE_TI_ARGS (type));
1666 /* Print the list of functions at FNS, going through all the overloads
1667 for each element of the list. Alternatively, FNS can not be a
1668 TREE_LIST, in which case it will be printed together with all the
1671 MORE and *STR should respectively be FALSE and NULL when the function
1672 is called from the outside. They are used internally on recursive
1673 calls. print_candidates manages the two parameters and leaves NULL
1674 in *STR when it ends. */
1677 print_candidates_1 (tree fns, bool more, const char **str)
1680 char *spaces = NULL;
1682 for (fn = fns; fn; fn = OVL_NEXT (fn))
1683 if (TREE_CODE (fn) == TREE_LIST)
1685 gcc_assert (!OVL_NEXT (fn) && !is_overloaded_fn (fn));
1686 for (fn2 = fn; fn2 != NULL_TREE; fn2 = TREE_CHAIN (fn2))
1687 print_candidates_1 (TREE_VALUE (fn2),
1688 TREE_CHAIN (fn2) || more, str);
1694 /* Pick the prefix string. */
1695 if (!more && !OVL_NEXT (fns))
1697 error ("candidate is: %+#D", OVL_CURRENT (fn));
1701 *str = _("candidates are:");
1702 spaces = get_spaces (*str);
1704 error ("%s %+#D", *str, OVL_CURRENT (fn));
1705 *str = spaces ? spaces : *str;
1715 /* Print the list of candidate FNS in an error message. */
1718 print_candidates (tree fns)
1720 const char *str = NULL;
1721 print_candidates_1 (fns, false, &str);
1722 gcc_assert (str == NULL);
1725 /* Returns the template (one of the functions given by TEMPLATE_ID)
1726 which can be specialized to match the indicated DECL with the
1727 explicit template args given in TEMPLATE_ID. The DECL may be
1728 NULL_TREE if none is available. In that case, the functions in
1729 TEMPLATE_ID are non-members.
1731 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1732 specialization of a member template.
1734 The TEMPLATE_COUNT is the number of references to qualifying
1735 template classes that appeared in the name of the function. See
1736 check_explicit_specialization for a more accurate description.
1738 TSK indicates what kind of template declaration (if any) is being
1739 declared. TSK_TEMPLATE indicates that the declaration given by
1740 DECL, though a FUNCTION_DECL, has template parameters, and is
1741 therefore a template function.
1743 The template args (those explicitly specified and those deduced)
1744 are output in a newly created vector *TARGS_OUT.
1746 If it is impossible to determine the result, an error message is
1747 issued. The error_mark_node is returned to indicate failure. */
1750 determine_specialization (tree template_id,
1753 int need_member_template,
1759 tree explicit_targs;
1760 tree candidates = NULL_TREE;
1761 /* A TREE_LIST of templates of which DECL may be a specialization.
1762 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1763 corresponding TREE_PURPOSE is the set of template arguments that,
1764 when used to instantiate the template, would produce a function
1765 with the signature of DECL. */
1766 tree templates = NULL_TREE;
1768 struct cp_binding_level *b;
1770 *targs_out = NULL_TREE;
1772 if (template_id == error_mark_node || decl == error_mark_node)
1773 return error_mark_node;
1775 fns = TREE_OPERAND (template_id, 0);
1776 explicit_targs = TREE_OPERAND (template_id, 1);
1778 if (fns == error_mark_node)
1779 return error_mark_node;
1781 /* Check for baselinks. */
1782 if (BASELINK_P (fns))
1783 fns = BASELINK_FUNCTIONS (fns);
1785 if (!is_overloaded_fn (fns))
1787 error ("%qD is not a function template", fns);
1788 return error_mark_node;
1791 /* Count the number of template headers specified for this
1794 for (b = current_binding_level;
1795 b->kind == sk_template_parms;
1799 for (; fns; fns = OVL_NEXT (fns))
1801 tree fn = OVL_CURRENT (fns);
1803 if (TREE_CODE (fn) == TEMPLATE_DECL)
1805 tree decl_arg_types;
1808 /* In case of explicit specialization, we need to check if
1809 the number of template headers appearing in the specialization
1810 is correct. This is usually done in check_explicit_specialization,
1811 but the check done there cannot be exhaustive when specializing
1812 member functions. Consider the following code:
1814 template <> void A<int>::f(int);
1815 template <> template <> void A<int>::f(int);
1817 Assuming that A<int> is not itself an explicit specialization
1818 already, the first line specializes "f" which is a non-template
1819 member function, whilst the second line specializes "f" which
1820 is a template member function. So both lines are syntactically
1821 correct, and check_explicit_specialization does not reject
1824 Here, we can do better, as we are matching the specialization
1825 against the declarations. We count the number of template
1826 headers, and we check if they match TEMPLATE_COUNT + 1
1827 (TEMPLATE_COUNT is the number of qualifying template classes,
1828 plus there must be another header for the member template
1831 Notice that if header_count is zero, this is not a
1832 specialization but rather a template instantiation, so there
1833 is no check we can perform here. */
1834 if (header_count && header_count != template_count + 1)
1837 /* Check that the number of template arguments at the
1838 innermost level for DECL is the same as for FN. */
1839 if (current_binding_level->kind == sk_template_parms
1840 && !current_binding_level->explicit_spec_p
1841 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn))
1842 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
1843 (current_template_parms))))
1846 /* DECL might be a specialization of FN. */
1847 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1848 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
1850 /* For a non-static member function, we need to make sure
1851 that the const qualification is the same. Since
1852 get_bindings does not try to merge the "this" parameter,
1853 we must do the comparison explicitly. */
1854 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1855 && !same_type_p (TREE_VALUE (fn_arg_types),
1856 TREE_VALUE (decl_arg_types)))
1859 /* Skip the "this" parameter and, for constructors of
1860 classes with virtual bases, the VTT parameter. A
1861 full specialization of a constructor will have a VTT
1862 parameter, but a template never will. */
1864 = skip_artificial_parms_for (decl, decl_arg_types);
1866 = skip_artificial_parms_for (fn, fn_arg_types);
1868 /* Check that the number of function parameters matches.
1870 template <class T> void f(int i = 0);
1871 template <> void f<int>();
1872 The specialization f<int> is invalid but is not caught
1873 by get_bindings below. */
1874 if (list_length (fn_arg_types) != list_length (decl_arg_types))
1877 /* Function templates cannot be specializations; there are
1878 no partial specializations of functions. Therefore, if
1879 the type of DECL does not match FN, there is no
1881 if (tsk == tsk_template)
1883 if (compparms (fn_arg_types, decl_arg_types))
1884 candidates = tree_cons (NULL_TREE, fn, candidates);
1888 /* See whether this function might be a specialization of this
1890 targs = get_bindings (fn, decl, explicit_targs, /*check_ret=*/true);
1893 /* We cannot deduce template arguments that when used to
1894 specialize TMPL will produce DECL. */
1897 /* Save this template, and the arguments deduced. */
1898 templates = tree_cons (targs, fn, templates);
1900 else if (need_member_template)
1901 /* FN is an ordinary member function, and we need a
1902 specialization of a member template. */
1904 else if (TREE_CODE (fn) != FUNCTION_DECL)
1905 /* We can get IDENTIFIER_NODEs here in certain erroneous
1908 else if (!DECL_FUNCTION_MEMBER_P (fn))
1909 /* This is just an ordinary non-member function. Nothing can
1910 be a specialization of that. */
1912 else if (DECL_ARTIFICIAL (fn))
1913 /* Cannot specialize functions that are created implicitly. */
1917 tree decl_arg_types;
1919 /* This is an ordinary member function. However, since
1920 we're here, we can assume it's enclosing class is a
1921 template class. For example,
1923 template <typename T> struct S { void f(); };
1924 template <> void S<int>::f() {}
1926 Here, S<int>::f is a non-template, but S<int> is a
1927 template class. If FN has the same type as DECL, we
1928 might be in business. */
1930 if (!DECL_TEMPLATE_INFO (fn))
1931 /* Its enclosing class is an explicit specialization
1932 of a template class. This is not a candidate. */
1935 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
1936 TREE_TYPE (TREE_TYPE (fn))))
1937 /* The return types differ. */
1940 /* Adjust the type of DECL in case FN is a static member. */
1941 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1942 if (DECL_STATIC_FUNCTION_P (fn)
1943 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1944 decl_arg_types = TREE_CHAIN (decl_arg_types);
1946 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1949 candidates = tree_cons (NULL_TREE, fn, candidates);
1953 if (templates && TREE_CHAIN (templates))
1959 It is possible for a specialization with a given function
1960 signature to be instantiated from more than one function
1961 template. In such cases, explicit specification of the
1962 template arguments must be used to uniquely identify the
1963 function template specialization being specialized.
1965 Note that here, there's no suggestion that we're supposed to
1966 determine which of the candidate templates is most
1967 specialized. However, we, also have:
1971 Partial ordering of overloaded function template
1972 declarations is used in the following contexts to select
1973 the function template to which a function template
1974 specialization refers:
1976 -- when an explicit specialization refers to a function
1979 So, we do use the partial ordering rules, at least for now.
1980 This extension can only serve to make invalid programs valid,
1981 so it's safe. And, there is strong anecdotal evidence that
1982 the committee intended the partial ordering rules to apply;
1983 the EDG front end has that behavior, and John Spicer claims
1984 that the committee simply forgot to delete the wording in
1985 [temp.expl.spec]. */
1986 tree tmpl = most_specialized_instantiation (templates);
1987 if (tmpl != error_mark_node)
1990 TREE_CHAIN (templates) = NULL_TREE;
1994 if (templates == NULL_TREE && candidates == NULL_TREE)
1996 error ("template-id %qD for %q+D does not match any template "
1997 "declaration", template_id, decl);
1998 if (header_count && header_count != template_count + 1)
1999 inform (input_location, "saw %d %<template<>%>, need %d for "
2000 "specializing a member function template",
2001 header_count, template_count + 1);
2002 return error_mark_node;
2004 else if ((templates && TREE_CHAIN (templates))
2005 || (candidates && TREE_CHAIN (candidates))
2006 || (templates && candidates))
2008 error ("ambiguous template specialization %qD for %q+D",
2010 candidates = chainon (candidates, templates);
2011 print_candidates (candidates);
2012 return error_mark_node;
2015 /* We have one, and exactly one, match. */
2018 tree fn = TREE_VALUE (candidates);
2019 *targs_out = copy_node (DECL_TI_ARGS (fn));
2020 /* DECL is a re-declaration or partial instantiation of a template
2022 if (TREE_CODE (fn) == TEMPLATE_DECL)
2024 /* It was a specialization of an ordinary member function in a
2026 return DECL_TI_TEMPLATE (fn);
2029 /* It was a specialization of a template. */
2030 targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates)));
2031 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs))
2033 *targs_out = copy_node (targs);
2034 SET_TMPL_ARGS_LEVEL (*targs_out,
2035 TMPL_ARGS_DEPTH (*targs_out),
2036 TREE_PURPOSE (templates));
2039 *targs_out = TREE_PURPOSE (templates);
2040 return TREE_VALUE (templates);
2043 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2044 but with the default argument values filled in from those in the
2048 copy_default_args_to_explicit_spec_1 (tree spec_types,
2051 tree new_spec_types;
2056 if (spec_types == void_list_node)
2057 return void_list_node;
2059 /* Substitute into the rest of the list. */
2061 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
2062 TREE_CHAIN (tmpl_types));
2064 /* Add the default argument for this parameter. */
2065 return hash_tree_cons (TREE_PURPOSE (tmpl_types),
2066 TREE_VALUE (spec_types),
2070 /* DECL is an explicit specialization. Replicate default arguments
2071 from the template it specializes. (That way, code like:
2073 template <class T> void f(T = 3);
2074 template <> void f(double);
2077 works, as required.) An alternative approach would be to look up
2078 the correct default arguments at the call-site, but this approach
2079 is consistent with how implicit instantiations are handled. */
2082 copy_default_args_to_explicit_spec (tree decl)
2087 tree new_spec_types;
2091 tree object_type = NULL_TREE;
2092 tree in_charge = NULL_TREE;
2093 tree vtt = NULL_TREE;
2095 /* See if there's anything we need to do. */
2096 tmpl = DECL_TI_TEMPLATE (decl);
2097 tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
2098 for (t = tmpl_types; t; t = TREE_CHAIN (t))
2099 if (TREE_PURPOSE (t))
2104 old_type = TREE_TYPE (decl);
2105 spec_types = TYPE_ARG_TYPES (old_type);
2107 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2109 /* Remove the this pointer, but remember the object's type for
2111 object_type = TREE_TYPE (TREE_VALUE (spec_types));
2112 spec_types = TREE_CHAIN (spec_types);
2113 tmpl_types = TREE_CHAIN (tmpl_types);
2115 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
2117 /* DECL may contain more parameters than TMPL due to the extra
2118 in-charge parameter in constructors and destructors. */
2119 in_charge = spec_types;
2120 spec_types = TREE_CHAIN (spec_types);
2122 if (DECL_HAS_VTT_PARM_P (decl))
2125 spec_types = TREE_CHAIN (spec_types);
2129 /* Compute the merged default arguments. */
2131 copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);
2133 /* Compute the new FUNCTION_TYPE. */
2137 new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt),
2142 /* Put the in-charge parameter back. */
2143 new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
2144 TREE_VALUE (in_charge),
2147 new_type = build_method_type_directly (object_type,
2148 TREE_TYPE (old_type),
2152 new_type = build_function_type (TREE_TYPE (old_type),
2154 new_type = cp_build_type_attribute_variant (new_type,
2155 TYPE_ATTRIBUTES (old_type));
2156 new_type = build_exception_variant (new_type,
2157 TYPE_RAISES_EXCEPTIONS (old_type));
2158 TREE_TYPE (decl) = new_type;
2161 /* Check to see if the function just declared, as indicated in
2162 DECLARATOR, and in DECL, is a specialization of a function
2163 template. We may also discover that the declaration is an explicit
2164 instantiation at this point.
2166 Returns DECL, or an equivalent declaration that should be used
2167 instead if all goes well. Issues an error message if something is
2168 amiss. Returns error_mark_node if the error is not easily
2171 FLAGS is a bitmask consisting of the following flags:
2173 2: The function has a definition.
2174 4: The function is a friend.
2176 The TEMPLATE_COUNT is the number of references to qualifying
2177 template classes that appeared in the name of the function. For
2180 template <class T> struct S { void f(); };
2183 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2184 classes are not counted in the TEMPLATE_COUNT, so that in
2186 template <class T> struct S {};
2187 template <> struct S<int> { void f(); }
2188 template <> void S<int>::f();
2190 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2191 invalid; there should be no template <>.)
2193 If the function is a specialization, it is marked as such via
2194 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2195 is set up correctly, and it is added to the list of specializations
2196 for that template. */
2199 check_explicit_specialization (tree declarator,
2204 int have_def = flags & 2;
2205 int is_friend = flags & 4;
2206 int specialization = 0;
2207 int explicit_instantiation = 0;
2208 int member_specialization = 0;
2209 tree ctype = DECL_CLASS_CONTEXT (decl);
2210 tree dname = DECL_NAME (decl);
2215 if (!processing_specialization)
2218 tsk = tsk_excessive_parms;
2221 tsk = current_tmpl_spec_kind (template_count);
2226 if (processing_specialization)
2229 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
2231 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
2234 /* This could be something like:
2236 template <class T> void f(T);
2237 class S { friend void f<>(int); } */
2241 /* This case handles bogus declarations like template <>
2242 template <class T> void f<int>(); */
2244 error ("template-id %qD in declaration of primary template",
2251 case tsk_invalid_member_spec:
2252 /* The error has already been reported in
2253 check_specialization_scope. */
2254 return error_mark_node;
2256 case tsk_invalid_expl_inst:
2257 error ("template parameter list used in explicit instantiation");
2263 error ("definition provided for explicit instantiation");
2265 explicit_instantiation = 1;
2268 case tsk_excessive_parms:
2269 case tsk_insufficient_parms:
2270 if (tsk == tsk_excessive_parms)
2271 error ("too many template parameter lists in declaration of %qD",
2273 else if (template_header_count)
2274 error("too few template parameter lists in declaration of %qD", decl);
2276 error("explicit specialization of %qD must be introduced by "
2277 "%<template <>%>", decl);
2281 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
2283 member_specialization = 1;
2289 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
2291 /* This case handles bogus declarations like template <>
2292 template <class T> void f<int>(); */
2294 if (uses_template_parms (declarator))
2295 error ("function template partial specialization %qD "
2296 "is not allowed", declarator);
2298 error ("template-id %qD in declaration of primary template",
2303 if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
2304 /* This is a specialization of a member template, without
2305 specialization the containing class. Something like:
2307 template <class T> struct S {
2308 template <class U> void f (U);
2310 template <> template <class U> void S<int>::f(U) {}
2312 That's a specialization -- but of the entire template. */
2320 if (specialization || member_specialization)
2322 tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
2323 for (; t; t = TREE_CHAIN (t))
2324 if (TREE_PURPOSE (t))
2326 permerror (input_location,
2327 "default argument specified in explicit specialization");
2332 if (specialization || member_specialization || explicit_instantiation)
2334 tree tmpl = NULL_TREE;
2335 tree targs = NULL_TREE;
2337 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2338 if (TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
2342 gcc_assert (TREE_CODE (declarator) == IDENTIFIER_NODE);
2347 /* If there is no class context, the explicit instantiation
2348 must be at namespace scope. */
2349 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl));
2351 /* Find the namespace binding, using the declaration
2353 fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
2355 if (fns == error_mark_node || !is_overloaded_fn (fns))
2357 error ("%qD is not a template function", dname);
2358 fns = error_mark_node;
2362 tree fn = OVL_CURRENT (fns);
2363 if (!is_associated_namespace (CP_DECL_CONTEXT (decl),
2364 CP_DECL_CONTEXT (fn)))
2365 error ("%qD is not declared in %qD",
2366 decl, current_namespace);
2370 declarator = lookup_template_function (fns, NULL_TREE);
2373 if (declarator == error_mark_node)
2374 return error_mark_node;
2376 if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
2378 if (!explicit_instantiation)
2379 /* A specialization in class scope. This is invalid,
2380 but the error will already have been flagged by
2381 check_specialization_scope. */
2382 return error_mark_node;
2385 /* It's not valid to write an explicit instantiation in
2388 class C { template void f(); }
2390 This case is caught by the parser. However, on
2393 template class C { void f(); };
2395 (which is invalid) we can get here. The error will be
2402 else if (ctype != NULL_TREE
2403 && (TREE_CODE (TREE_OPERAND (declarator, 0)) ==
2406 /* Find the list of functions in ctype that have the same
2407 name as the declared function. */
2408 tree name = TREE_OPERAND (declarator, 0);
2409 tree fns = NULL_TREE;
2412 if (constructor_name_p (name, ctype))
2414 int is_constructor = DECL_CONSTRUCTOR_P (decl);
2416 if (is_constructor ? !TYPE_HAS_USER_CONSTRUCTOR (ctype)
2417 : !CLASSTYPE_DESTRUCTORS (ctype))
2419 /* From [temp.expl.spec]:
2421 If such an explicit specialization for the member
2422 of a class template names an implicitly-declared
2423 special member function (clause _special_), the
2424 program is ill-formed.
2426 Similar language is found in [temp.explicit]. */
2427 error ("specialization of implicitly-declared special member function");
2428 return error_mark_node;
2431 name = is_constructor ? ctor_identifier : dtor_identifier;
2434 if (!DECL_CONV_FN_P (decl))
2436 idx = lookup_fnfields_1 (ctype, name);
2438 fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (ctype), idx);
2442 VEC(tree,gc) *methods;
2445 /* For a type-conversion operator, we cannot do a
2446 name-based lookup. We might be looking for `operator
2447 int' which will be a specialization of `operator T'.
2448 So, we find *all* the conversion operators, and then
2449 select from them. */
2452 methods = CLASSTYPE_METHOD_VEC (ctype);
2454 for (idx = CLASSTYPE_FIRST_CONVERSION_SLOT;
2455 VEC_iterate (tree, methods, idx, ovl);
2458 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl)))
2459 /* There are no more conversion functions. */
2462 /* Glue all these conversion functions together
2463 with those we already have. */
2464 for (; ovl; ovl = OVL_NEXT (ovl))
2465 fns = ovl_cons (OVL_CURRENT (ovl), fns);
2469 if (fns == NULL_TREE)
2471 error ("no member function %qD declared in %qT", name, ctype);
2472 return error_mark_node;
2475 TREE_OPERAND (declarator, 0) = fns;
2478 /* Figure out what exactly is being specialized at this point.
2479 Note that for an explicit instantiation, even one for a
2480 member function, we cannot tell apriori whether the
2481 instantiation is for a member template, or just a member
2482 function of a template class. Even if a member template is
2483 being instantiated, the member template arguments may be
2484 elided if they can be deduced from the rest of the
2486 tmpl = determine_specialization (declarator, decl,
2488 member_specialization,
2492 if (!tmpl || tmpl == error_mark_node)
2493 /* We couldn't figure out what this declaration was
2495 return error_mark_node;
2498 tree gen_tmpl = most_general_template (tmpl);
2500 if (explicit_instantiation)
2502 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2503 is done by do_decl_instantiation later. */
2505 int arg_depth = TMPL_ARGS_DEPTH (targs);
2506 int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
2508 if (arg_depth > parm_depth)
2510 /* If TMPL is not the most general template (for
2511 example, if TMPL is a friend template that is
2512 injected into namespace scope), then there will
2513 be too many levels of TARGS. Remove some of them
2518 new_targs = make_tree_vec (parm_depth);
2519 for (i = arg_depth - parm_depth; i < arg_depth; ++i)
2520 TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
2521 = TREE_VEC_ELT (targs, i);
2525 return instantiate_template (tmpl, targs, tf_error);
2528 /* If we thought that the DECL was a member function, but it
2529 turns out to be specializing a static member function,
2530 make DECL a static member function as well. */
2531 if (DECL_STATIC_FUNCTION_P (tmpl)
2532 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2533 revert_static_member_fn (decl);
2535 /* If this is a specialization of a member template of a
2536 template class, we want to return the TEMPLATE_DECL, not
2537 the specialization of it. */
2538 if (tsk == tsk_template)
2540 tree result = DECL_TEMPLATE_RESULT (tmpl);
2541 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
2542 DECL_INITIAL (result) = NULL_TREE;
2546 DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
2547 DECL_SOURCE_LOCATION (result)
2548 = DECL_SOURCE_LOCATION (decl);
2549 /* We want to use the argument list specified in the
2550 definition, not in the original declaration. */
2551 DECL_ARGUMENTS (result) = DECL_ARGUMENTS (decl);
2552 for (parm = DECL_ARGUMENTS (result); parm;
2553 parm = TREE_CHAIN (parm))
2554 DECL_CONTEXT (parm) = result;
2556 return register_specialization (tmpl, gen_tmpl, targs,
2560 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2561 DECL_TEMPLATE_INFO (decl) = build_template_info (tmpl, targs);
2563 /* Inherit default function arguments from the template
2564 DECL is specializing. */
2565 copy_default_args_to_explicit_spec (decl);
2567 /* This specialization has the same protection as the
2568 template it specializes. */
2569 TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
2570 TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
2572 /* 7.1.1-1 [dcl.stc]
2574 A storage-class-specifier shall not be specified in an
2575 explicit specialization...
2577 The parser rejects these, so unless action is taken here,
2578 explicit function specializations will always appear with
2581 The action recommended by the C++ CWG in response to C++
2582 defect report 605 is to make the storage class and linkage
2583 of the explicit specialization match the templated function:
2585 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2587 if (tsk == tsk_expl_spec && DECL_FUNCTION_TEMPLATE_P (gen_tmpl))
2589 tree tmpl_func = DECL_TEMPLATE_RESULT (gen_tmpl);
2590 gcc_assert (TREE_CODE (tmpl_func) == FUNCTION_DECL);
2592 /* This specialization has the same linkage and visibility as
2593 the function template it specializes. */
2594 TREE_PUBLIC (decl) = TREE_PUBLIC (tmpl_func);
2595 if (! TREE_PUBLIC (decl))
2597 DECL_INTERFACE_KNOWN (decl) = 1;
2598 DECL_NOT_REALLY_EXTERN (decl) = 1;
2600 DECL_THIS_STATIC (decl) = DECL_THIS_STATIC (tmpl_func);
2601 if (DECL_VISIBILITY_SPECIFIED (tmpl_func))
2603 DECL_VISIBILITY_SPECIFIED (decl) = 1;
2604 DECL_VISIBILITY (decl) = DECL_VISIBILITY (tmpl_func);
2608 /* If DECL is a friend declaration, declared using an
2609 unqualified name, the namespace associated with DECL may
2610 have been set incorrectly. For example, in:
2612 template <typename T> void f(T);
2614 struct S { friend void f<int>(int); }
2617 we will have set the DECL_CONTEXT for the friend
2618 declaration to N, rather than to the global namespace. */
2619 if (DECL_NAMESPACE_SCOPE_P (decl))
2620 DECL_CONTEXT (decl) = DECL_CONTEXT (tmpl);
2622 if (is_friend && !have_def)
2623 /* This is not really a declaration of a specialization.
2624 It's just the name of an instantiation. But, it's not
2625 a request for an instantiation, either. */
2626 SET_DECL_IMPLICIT_INSTANTIATION (decl);
2627 else if (DECL_CONSTRUCTOR_P (decl) || DECL_DESTRUCTOR_P (decl))
2628 /* This is indeed a specialization. In case of constructors
2629 and destructors, we need in-charge and not-in-charge
2630 versions in V3 ABI. */
2631 clone_function_decl (decl, /*update_method_vec_p=*/0);
2633 /* Register this specialization so that we can find it
2635 decl = register_specialization (decl, gen_tmpl, targs, is_friend, 0);
2642 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2643 parameters. These are represented in the same format used for
2644 DECL_TEMPLATE_PARMS. */
2647 comp_template_parms (const_tree parms1, const_tree parms2)
2652 if (parms1 == parms2)
2655 for (p1 = parms1, p2 = parms2;
2656 p1 != NULL_TREE && p2 != NULL_TREE;
2657 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2))
2659 tree t1 = TREE_VALUE (p1);
2660 tree t2 = TREE_VALUE (p2);
2663 gcc_assert (TREE_CODE (t1) == TREE_VEC);
2664 gcc_assert (TREE_CODE (t2) == TREE_VEC);
2666 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
2669 for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
2671 tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
2672 tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
2674 /* If either of the template parameters are invalid, assume
2675 they match for the sake of error recovery. */
2676 if (parm1 == error_mark_node || parm2 == error_mark_node)
2679 if (TREE_CODE (parm1) != TREE_CODE (parm2))
2682 if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM
2683 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1)
2684 == TEMPLATE_TYPE_PARAMETER_PACK (parm2)))
2686 else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
2691 if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
2692 /* One set of parameters has more parameters lists than the
2699 /* Determine whether PARM is a parameter pack. */
2702 template_parameter_pack_p (const_tree parm)
2704 /* Determine if we have a non-type template parameter pack. */
2705 if (TREE_CODE (parm) == PARM_DECL)
2706 return (DECL_TEMPLATE_PARM_P (parm)
2707 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)));
2709 /* If this is a list of template parameters, we could get a
2710 TYPE_DECL or a TEMPLATE_DECL. */
2711 if (TREE_CODE (parm) == TYPE_DECL || TREE_CODE (parm) == TEMPLATE_DECL)
2712 parm = TREE_TYPE (parm);
2714 return ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
2715 || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM)
2716 && TEMPLATE_TYPE_PARAMETER_PACK (parm));
2719 /* Determine if T is a function parameter pack. */
2722 function_parameter_pack_p (const_tree t)
2724 if (t && TREE_CODE (t) == PARM_DECL)
2725 return FUNCTION_PARAMETER_PACK_P (t);
2729 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
2730 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
2733 get_function_template_decl (const_tree primary_func_tmpl_inst)
2735 if (! primary_func_tmpl_inst
2736 || TREE_CODE (primary_func_tmpl_inst) != FUNCTION_DECL
2737 || ! primary_template_instantiation_p (primary_func_tmpl_inst))
2740 return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst));
2743 /* Return true iff the function parameter PARAM_DECL was expanded
2744 from the function parameter pack PACK. */
2747 function_parameter_expanded_from_pack_p (tree param_decl, tree pack)
2749 if (DECL_ARTIFICIAL (param_decl)
2750 || !function_parameter_pack_p (pack))
2753 /* The parameter pack and its pack arguments have the same
2755 return DECL_PARM_INDEX (pack) == DECL_PARM_INDEX (param_decl);
2758 /* Determine whether ARGS describes a variadic template args list,
2759 i.e., one that is terminated by a template argument pack. */
2762 template_args_variadic_p (tree args)
2767 if (args == NULL_TREE)
2770 args = INNERMOST_TEMPLATE_ARGS (args);
2771 nargs = TREE_VEC_LENGTH (args);
2776 last_parm = TREE_VEC_ELT (args, nargs - 1);
2778 return ARGUMENT_PACK_P (last_parm);
2781 /* Generate a new name for the parameter pack name NAME (an
2782 IDENTIFIER_NODE) that incorporates its */
2785 make_ith_pack_parameter_name (tree name, int i)
2787 /* Munge the name to include the parameter index. */
2788 #define NUMBUF_LEN 128
2789 char numbuf[NUMBUF_LEN];
2793 snprintf (numbuf, NUMBUF_LEN, "%i", i);
2794 newname_len = IDENTIFIER_LENGTH (name)
2795 + strlen (numbuf) + 2;
2796 newname = (char*)alloca (newname_len);
2797 snprintf (newname, newname_len,
2798 "%s#%i", IDENTIFIER_POINTER (name), i);
2799 return get_identifier (newname);
2802 /* Return true if T is a primary function
2803 or class template instantiation. */
2806 primary_template_instantiation_p (const_tree t)
2811 if (TREE_CODE (t) == FUNCTION_DECL)
2812 return DECL_LANG_SPECIFIC (t)
2813 && DECL_TEMPLATE_INSTANTIATION (t)
2814 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t));
2815 else if (CLASS_TYPE_P (t))
2816 return CLASSTYPE_TEMPLATE_INSTANTIATION (t)
2817 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t));
2821 /* Return true if PARM is a template template parameter. */
2824 template_template_parameter_p (const_tree parm)
2826 return DECL_TEMPLATE_TEMPLATE_PARM_P (parm);
2829 /* Return the template parameters of T if T is a
2830 primary template instantiation, NULL otherwise. */
2833 get_primary_template_innermost_parameters (const_tree t)
2835 tree parms = NULL, template_info = NULL;
2837 if ((template_info = get_template_info (t))
2838 && primary_template_instantiation_p (t))
2839 parms = INNERMOST_TEMPLATE_PARMS
2840 (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info)));
2845 /* Return the template parameters of the LEVELth level from the full list
2846 of template parameters PARMS. */
2849 get_template_parms_at_level (tree parms, int level)
2853 || TREE_CODE (parms) != TREE_LIST
2854 || level > TMPL_PARMS_DEPTH (parms))
2857 for (p = parms; p; p = TREE_CHAIN (p))
2858 if (TMPL_PARMS_DEPTH (p) == level)
2864 /* Returns the template arguments of T if T is a template instantiation,
2868 get_template_innermost_arguments (const_tree t)
2870 tree args = NULL, template_info = NULL;
2872 if ((template_info = get_template_info (t))
2873 && TI_ARGS (template_info))
2874 args = INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info));
2879 /* Return the argument pack elements of T if T is a template argument pack,
2883 get_template_argument_pack_elems (const_tree t)
2885 if (TREE_CODE (t) != TYPE_ARGUMENT_PACK
2886 && TREE_CODE (t) != NONTYPE_ARGUMENT_PACK)
2889 return ARGUMENT_PACK_ARGS (t);
2892 /* Structure used to track the progress of find_parameter_packs_r. */
2893 struct find_parameter_pack_data
2895 /* TREE_LIST that will contain all of the parameter packs found by
2897 tree* parameter_packs;
2899 /* Set of AST nodes that have been visited by the traversal. */
2900 struct pointer_set_t *visited;
2903 /* Identifies all of the argument packs that occur in a template
2904 argument and appends them to the TREE_LIST inside DATA, which is a
2905 find_parameter_pack_data structure. This is a subroutine of
2906 make_pack_expansion and uses_parameter_packs. */
2908 find_parameter_packs_r (tree *tp, int *walk_subtrees, void* data)
2911 struct find_parameter_pack_data* ppd =
2912 (struct find_parameter_pack_data*)data;
2913 bool parameter_pack_p = false;
2915 /* Identify whether this is a parameter pack or not. */
2916 switch (TREE_CODE (t))
2918 case TEMPLATE_PARM_INDEX:
2919 if (TEMPLATE_PARM_PARAMETER_PACK (t))
2920 parameter_pack_p = true;
2923 case TEMPLATE_TYPE_PARM:
2924 case TEMPLATE_TEMPLATE_PARM:
2925 if (TEMPLATE_TYPE_PARAMETER_PACK (t))
2926 parameter_pack_p = true;
2930 if (FUNCTION_PARAMETER_PACK_P (t))
2932 /* We don't want to walk into the type of a PARM_DECL,
2933 because we don't want to see the type parameter pack. */
2935 parameter_pack_p = true;
2940 /* Not a parameter pack. */
2944 if (parameter_pack_p)
2946 /* Add this parameter pack to the list. */
2947 *ppd->parameter_packs = tree_cons (NULL_TREE, t, *ppd->parameter_packs);
2951 cp_walk_tree (&TYPE_CONTEXT (t),
2952 &find_parameter_packs_r, ppd, ppd->visited);
2954 /* This switch statement will return immediately if we don't find a
2956 switch (TREE_CODE (t))
2958 case TEMPLATE_PARM_INDEX:
2961 case BOUND_TEMPLATE_TEMPLATE_PARM:
2962 /* Check the template itself. */
2963 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t)),
2964 &find_parameter_packs_r, ppd, ppd->visited);
2965 /* Check the template arguments. */
2966 cp_walk_tree (&TYPE_TI_ARGS (t), &find_parameter_packs_r, ppd,
2971 case TEMPLATE_TYPE_PARM:
2972 case TEMPLATE_TEMPLATE_PARM:
2979 if (TYPE_PTRMEMFUNC_P (t))
2985 if (TYPE_TEMPLATE_INFO (t))
2986 cp_walk_tree (&TI_ARGS (TYPE_TEMPLATE_INFO (t)),
2987 &find_parameter_packs_r, ppd, ppd->visited);
2993 cp_walk_tree (&TREE_TYPE (t),
2994 &find_parameter_packs_r, ppd, ppd->visited);
2998 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t), &find_parameter_packs_r,
3003 case TYPE_PACK_EXPANSION:
3004 case EXPR_PACK_EXPANSION:
3009 cp_walk_tree (&TYPE_MAX_VALUE (t), &find_parameter_packs_r,
3014 case IDENTIFIER_NODE:
3015 cp_walk_tree (&TREE_TYPE (t), &find_parameter_packs_r, ppd,
3027 /* Determines if the expression or type T uses any parameter packs. */
3029 uses_parameter_packs (tree t)
3031 tree parameter_packs = NULL_TREE;
3032 struct find_parameter_pack_data ppd;
3033 ppd.parameter_packs = ¶meter_packs;
3034 ppd.visited = pointer_set_create ();
3035 cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
3036 pointer_set_destroy (ppd.visited);
3037 return parameter_packs != NULL_TREE;
3040 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3041 representation a base-class initializer into a parameter pack
3042 expansion. If all goes well, the resulting node will be an
3043 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3046 make_pack_expansion (tree arg)
3049 tree parameter_packs = NULL_TREE;
3050 bool for_types = false;
3051 struct find_parameter_pack_data ppd;
3053 if (!arg || arg == error_mark_node)
3056 if (TREE_CODE (arg) == TREE_LIST)
3058 /* The only time we will see a TREE_LIST here is for a base
3059 class initializer. In this case, the TREE_PURPOSE will be a
3060 _TYPE node (representing the base class expansion we're
3061 initializing) and the TREE_VALUE will be a TREE_LIST
3062 containing the initialization arguments.
3064 The resulting expansion looks somewhat different from most
3065 expansions. Rather than returning just one _EXPANSION, we
3066 return a TREE_LIST whose TREE_PURPOSE is a
3067 TYPE_PACK_EXPANSION containing the bases that will be
3068 initialized. The TREE_VALUE will be identical to the
3069 original TREE_VALUE, which is a list of arguments that will
3070 be passed to each base. We do not introduce any new pack
3071 expansion nodes into the TREE_VALUE (although it is possible
3072 that some already exist), because the TREE_PURPOSE and
3073 TREE_VALUE all need to be expanded together with the same
3074 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3075 resulting TREE_PURPOSE will mention the parameter packs in
3076 both the bases and the arguments to the bases. */
3079 tree parameter_packs = NULL_TREE;
3081 /* Determine which parameter packs will be used by the base
3083 ppd.visited = pointer_set_create ();
3084 ppd.parameter_packs = ¶meter_packs;
3085 cp_walk_tree (&TREE_PURPOSE (arg), &find_parameter_packs_r,
3088 if (parameter_packs == NULL_TREE)
3090 error ("base initializer expansion %<%T%> contains no parameter packs", arg);
3091 pointer_set_destroy (ppd.visited);
3092 return error_mark_node;
3095 if (TREE_VALUE (arg) != void_type_node)
3097 /* Collect the sets of parameter packs used in each of the
3098 initialization arguments. */
3099 for (value = TREE_VALUE (arg); value; value = TREE_CHAIN (value))
3101 /* Determine which parameter packs will be expanded in this
3103 cp_walk_tree (&TREE_VALUE (value), &find_parameter_packs_r,
3108 pointer_set_destroy (ppd.visited);
3110 /* Create the pack expansion type for the base type. */
3111 purpose = cxx_make_type (TYPE_PACK_EXPANSION);
3112 SET_PACK_EXPANSION_PATTERN (purpose, TREE_PURPOSE (arg));
3113 PACK_EXPANSION_PARAMETER_PACKS (purpose) = parameter_packs;
3115 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3116 they will rarely be compared to anything. */
3117 SET_TYPE_STRUCTURAL_EQUALITY (purpose);
3119 return tree_cons (purpose, TREE_VALUE (arg), NULL_TREE);
3122 if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
3125 /* Build the PACK_EXPANSION_* node. */
3127 ? cxx_make_type (TYPE_PACK_EXPANSION)
3128 : make_node (EXPR_PACK_EXPANSION);
3129 SET_PACK_EXPANSION_PATTERN (result, arg);
3130 if (TREE_CODE (result) == EXPR_PACK_EXPANSION)
3132 /* Propagate type and const-expression information. */
3133 TREE_TYPE (result) = TREE_TYPE (arg);
3134 TREE_CONSTANT (result) = TREE_CONSTANT (arg);
3137 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3138 they will rarely be compared to anything. */
3139 SET_TYPE_STRUCTURAL_EQUALITY (result);
3141 /* Determine which parameter packs will be expanded. */
3142 ppd.parameter_packs = ¶meter_packs;
3143 ppd.visited = pointer_set_create ();
3144 cp_walk_tree (&arg, &find_parameter_packs_r, &ppd, ppd.visited);
3145 pointer_set_destroy (ppd.visited);
3147 /* Make sure we found some parameter packs. */
3148 if (parameter_packs == NULL_TREE)
3151 error ("expansion pattern %<%T%> contains no argument packs", arg);
3153 error ("expansion pattern %<%E%> contains no argument packs", arg);
3154 return error_mark_node;
3156 PACK_EXPANSION_PARAMETER_PACKS (result) = parameter_packs;
3161 /* Checks T for any "bare" parameter packs, which have not yet been
3162 expanded, and issues an error if any are found. This operation can
3163 only be done on full expressions or types (e.g., an expression
3164 statement, "if" condition, etc.), because we could have expressions like:
3166 foo(f(g(h(args)))...)
3168 where "args" is a parameter pack. check_for_bare_parameter_packs
3169 should not be called for the subexpressions args, h(args),
3170 g(h(args)), or f(g(h(args))), because we would produce erroneous
3173 Returns TRUE and emits an error if there were bare parameter packs,
3174 returns FALSE otherwise. */
3176 check_for_bare_parameter_packs (tree t)
3178 tree parameter_packs = NULL_TREE;
3179 struct find_parameter_pack_data ppd;
3181 if (!processing_template_decl || !t || t == error_mark_node)
3184 if (TREE_CODE (t) == TYPE_DECL)
3187 ppd.parameter_packs = ¶meter_packs;
3188 ppd.visited = pointer_set_create ();
3189 cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
3190 pointer_set_destroy (ppd.visited);
3192 if (parameter_packs)
3194 error ("parameter packs not expanded with %<...%>:");
3195 while (parameter_packs)
3197 tree pack = TREE_VALUE (parameter_packs);
3198 tree name = NULL_TREE;
3200 if (TREE_CODE (pack) == TEMPLATE_TYPE_PARM
3201 || TREE_CODE (pack) == TEMPLATE_TEMPLATE_PARM)
3202 name = TYPE_NAME (pack);
3203 else if (TREE_CODE (pack) == TEMPLATE_PARM_INDEX)
3204 name = DECL_NAME (TEMPLATE_PARM_DECL (pack));
3206 name = DECL_NAME (pack);
3209 inform (input_location, " %qD", name);
3211 inform (input_location, " <anonymous>");
3213 parameter_packs = TREE_CHAIN (parameter_packs);
3222 /* Expand any parameter packs that occur in the template arguments in
3225 expand_template_argument_pack (tree args)
3227 tree result_args = NULL_TREE;
3228 int in_arg, out_arg = 0, nargs = args ? TREE_VEC_LENGTH (args) : 0;
3229 int num_result_args = -1;
3230 int non_default_args_count = -1;
3232 /* First, determine if we need to expand anything, and the number of
3233 slots we'll need. */
3234 for (in_arg = 0; in_arg < nargs; ++in_arg)
3236 tree arg = TREE_VEC_ELT (args, in_arg);
3237 if (arg == NULL_TREE)
3239 if (ARGUMENT_PACK_P (arg))
3241 int num_packed = TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg));
3242 if (num_result_args < 0)
3243 num_result_args = in_arg + num_packed;
3245 num_result_args += num_packed;
3249 if (num_result_args >= 0)
3254 /* If no expansion is necessary, we're done. */
3255 if (num_result_args < 0)
3258 /* Expand arguments. */
3259 result_args = make_tree_vec (num_result_args);
3260 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args))
3261 non_default_args_count =
3262 GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args);
3263 for (in_arg = 0; in_arg < nargs; ++in_arg)
3265 tree arg = TREE_VEC_ELT (args, in_arg);
3266 if (ARGUMENT_PACK_P (arg))
3268 tree packed = ARGUMENT_PACK_ARGS (arg);
3269 int i, num_packed = TREE_VEC_LENGTH (packed);
3270 for (i = 0; i < num_packed; ++i, ++out_arg)
3271 TREE_VEC_ELT (result_args, out_arg) = TREE_VEC_ELT(packed, i);
3272 if (non_default_args_count > 0)
3273 non_default_args_count += num_packed;
3277 TREE_VEC_ELT (result_args, out_arg) = arg;
3281 if (non_default_args_count >= 0)
3282 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args, non_default_args_count);
3286 /* Checks if DECL shadows a template parameter.
3288 [temp.local]: A template-parameter shall not be redeclared within its
3289 scope (including nested scopes).
3291 Emits an error and returns TRUE if the DECL shadows a parameter,
3292 returns FALSE otherwise. */
3295 check_template_shadow (tree decl)
3299 /* If we're not in a template, we can't possibly shadow a template
3301 if (!current_template_parms)
3304 /* Figure out what we're shadowing. */
3305 if (TREE_CODE (decl) == OVERLOAD)
3306 decl = OVL_CURRENT (decl);
3307 olddecl = innermost_non_namespace_value (DECL_NAME (decl));
3309 /* If there's no previous binding for this name, we're not shadowing
3310 anything, let alone a template parameter. */
3314 /* If we're not shadowing a template parameter, we're done. Note
3315 that OLDDECL might be an OVERLOAD (or perhaps even an
3316 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3318 if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
3321 /* We check for decl != olddecl to avoid bogus errors for using a
3322 name inside a class. We check TPFI to avoid duplicate errors for
3323 inline member templates. */
3325 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms))
3328 error ("declaration of %q+#D", decl);
3329 error (" shadows template parm %q+#D", olddecl);
3333 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3334 ORIG_LEVEL, DECL, and TYPE. */
3337 build_template_parm_index (int index,
3343 tree t = make_node (TEMPLATE_PARM_INDEX);
3344 TEMPLATE_PARM_IDX (t) = index;
3345 TEMPLATE_PARM_LEVEL (t) = level;
3346 TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
3347 TEMPLATE_PARM_DECL (t) = decl;
3348 TREE_TYPE (t) = type;
3349 TREE_CONSTANT (t) = TREE_CONSTANT (decl);
3350 TREE_READONLY (t) = TREE_READONLY (decl);
3355 /* Find the canonical type parameter for the given template type
3356 parameter. Returns the canonical type parameter, which may be TYPE
3357 if no such parameter existed. */
3359 canonical_type_parameter (tree type)
3362 int idx = TEMPLATE_TYPE_IDX (type);
3363 if (!canonical_template_parms)
3364 canonical_template_parms = VEC_alloc (tree, gc, idx+1);
3366 while (VEC_length (tree, canonical_template_parms) <= (unsigned)idx)
3367 VEC_safe_push (tree, gc, canonical_template_parms, NULL_TREE);
3369 list = VEC_index (tree, canonical_template_parms, idx);
3370 while (list && !comptypes (type, TREE_VALUE (list), COMPARE_STRUCTURAL))
3371 list = TREE_CHAIN (list);
3374 return TREE_VALUE (list);
3377 VEC_replace(tree, canonical_template_parms, idx,
3378 tree_cons (NULL_TREE, type,
3379 VEC_index (tree, canonical_template_parms, idx)));
3384 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3385 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3386 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3387 new one is created. */
3390 reduce_template_parm_level (tree index, tree type, int levels, tree args,
3391 tsubst_flags_t complain)
3393 if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
3394 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
3395 != TEMPLATE_PARM_LEVEL (index) - levels)
3396 || !same_type_p (type, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index))))
3398 tree orig_decl = TEMPLATE_PARM_DECL (index);
3401 decl = build_decl (DECL_SOURCE_LOCATION (orig_decl),
3402 TREE_CODE (orig_decl), DECL_NAME (orig_decl), type);
3403 TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl);
3404 TREE_READONLY (decl) = TREE_READONLY (orig_decl);
3405 DECL_ARTIFICIAL (decl) = 1;
3406 SET_DECL_TEMPLATE_PARM_P (decl);
3408 t = build_template_parm_index (TEMPLATE_PARM_IDX (index),
3409 TEMPLATE_PARM_LEVEL (index) - levels,
3410 TEMPLATE_PARM_ORIG_LEVEL (index),
3412 TEMPLATE_PARM_DESCENDANTS (index) = t;
3413 TEMPLATE_PARM_PARAMETER_PACK (t)
3414 = TEMPLATE_PARM_PARAMETER_PACK (index);
3416 /* Template template parameters need this. */
3417 if (TREE_CODE (decl) == TEMPLATE_DECL)
3418 DECL_TEMPLATE_PARMS (decl) = tsubst_template_parms
3419 (DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index)),
3423 return TEMPLATE_PARM_DESCENDANTS (index);
3426 /* Process information from new template parameter PARM and append it to the
3427 LIST being built. This new parameter is a non-type parameter iff
3428 IS_NON_TYPE is true. This new parameter is a parameter
3429 pack iff IS_PARAMETER_PACK is true. The location of PARM is in
3433 process_template_parm (tree list, location_t parm_loc, tree parm, bool is_non_type,
3434 bool is_parameter_pack)
3441 gcc_assert (TREE_CODE (parm) == TREE_LIST);
3442 defval = TREE_PURPOSE (parm);
3446 tree p = tree_last (list);
3448 if (p && TREE_VALUE (p) != error_mark_node)
3451 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
3452 idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
3454 idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
3464 parm = TREE_VALUE (parm);
3466 SET_DECL_TEMPLATE_PARM_P (parm);
3468 if (TREE_TYPE (parm) == error_mark_node)
3470 err_parm_list = build_tree_list (defval, parm);
3471 TREE_VALUE (err_parm_list) = error_mark_node;
3472 return chainon (list, err_parm_list);
3478 The top-level cv-qualifiers on the template-parameter are
3479 ignored when determining its type. */
3480 TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
3481 if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
3483 err_parm_list = build_tree_list (defval, parm);
3484 TREE_VALUE (err_parm_list) = error_mark_node;
3485 return chainon (list, err_parm_list);
3488 if (uses_parameter_packs (TREE_TYPE (parm)) && !is_parameter_pack)
3490 /* This template parameter is not a parameter pack, but it
3491 should be. Complain about "bare" parameter packs. */
3492 check_for_bare_parameter_packs (TREE_TYPE (parm));
3494 /* Recover by calling this a parameter pack. */
3495 is_parameter_pack = true;
3499 /* A template parameter is not modifiable. */
3500 TREE_CONSTANT (parm) = 1;
3501 TREE_READONLY (parm) = 1;
3502 decl = build_decl (parm_loc,
3503 CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
3504 TREE_CONSTANT (decl) = 1;
3505 TREE_READONLY (decl) = 1;
3506 DECL_INITIAL (parm) = DECL_INITIAL (decl)
3507 = build_template_parm_index (idx, processing_template_decl,
3508 processing_template_decl,
3509 decl, TREE_TYPE (parm));
3511 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm))
3512 = is_parameter_pack;
3517 parm = TREE_VALUE (TREE_VALUE (parm));
3519 if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
3521 t = cxx_make_type (TEMPLATE_TEMPLATE_PARM);
3522 /* This is for distinguishing between real templates and template
3523 template parameters */
3524 TREE_TYPE (parm) = t;
3525 TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t;
3530 t = cxx_make_type (TEMPLATE_TYPE_PARM);
3531 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3532 decl = build_decl (parm_loc,
3533 TYPE_DECL, parm, t);
3536 TYPE_NAME (t) = decl;
3537 TYPE_STUB_DECL (t) = decl;
3539 TEMPLATE_TYPE_PARM_INDEX (t)
3540 = build_template_parm_index (idx, processing_template_decl,
3541 processing_template_decl,
3542 decl, TREE_TYPE (parm));
3543 TEMPLATE_TYPE_PARAMETER_PACK (t) = is_parameter_pack;
3544 TYPE_CANONICAL (t) = canonical_type_parameter (t);
3546 DECL_ARTIFICIAL (decl) = 1;
3547 SET_DECL_TEMPLATE_PARM_P (decl);
3549 parm = build_tree_list (defval, parm);
3550 return chainon (list, parm);
3553 /* The end of a template parameter list has been reached. Process the
3554 tree list into a parameter vector, converting each parameter into a more
3555 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3559 end_template_parm_list (tree parms)
3563 tree saved_parmlist = make_tree_vec (list_length (parms));
3565 current_template_parms
3566 = tree_cons (size_int (processing_template_decl),
3567 saved_parmlist, current_template_parms);
3569 for (parm = parms, nparms = 0; parm; parm = next, nparms++)
3571 next = TREE_CHAIN (parm);
3572 TREE_VEC_ELT (saved_parmlist, nparms) = parm;
3573 TREE_CHAIN (parm) = NULL_TREE;
3576 --processing_template_parmlist;
3578 return saved_parmlist;
3581 /* end_template_decl is called after a template declaration is seen. */
3584 end_template_decl (void)
3586 reset_specialization ();
3588 if (! processing_template_decl)
3591 /* This matches the pushlevel in begin_template_parm_list. */
3594 --processing_template_decl;
3595 current_template_parms = TREE_CHAIN (current_template_parms);
3598 /* Within the declaration of a template, return all levels of template
3599 parameters that apply. The template parameters are represented as
3600 a TREE_VEC, in the form documented in cp-tree.h for template
3604 current_template_args (void)
3607 tree args = NULL_TREE;
3608 int length = TMPL_PARMS_DEPTH (current_template_parms);
3611 /* If there is only one level of template parameters, we do not
3612 create a TREE_VEC of TREE_VECs. Instead, we return a single
3613 TREE_VEC containing the arguments. */
3615 args = make_tree_vec (length);
3617 for (header = current_template_parms; header; header = TREE_CHAIN (header))
3619 tree a = copy_node (TREE_VALUE (header));
3622 TREE_TYPE (a) = NULL_TREE;
3623 for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
3625 tree t = TREE_VEC_ELT (a, i);
3627 /* T will be a list if we are called from within a
3628 begin/end_template_parm_list pair, but a vector directly
3629 if within a begin/end_member_template_processing pair. */
3630 if (TREE_CODE (t) == TREE_LIST)
3634 if (!error_operand_p (t))
3636 if (TREE_CODE (t) == TYPE_DECL
3637 || TREE_CODE (t) == TEMPLATE_DECL)
3641 if (TEMPLATE_TYPE_PARAMETER_PACK (t))
3643 /* Turn this argument into a TYPE_ARGUMENT_PACK
3644 with a single element, which expands T. */
3645 tree vec = make_tree_vec (1);
3646 #ifdef ENABLE_CHECKING
3647 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3648 (vec, TREE_VEC_LENGTH (vec));
3650 TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
3652 t = cxx_make_type (TYPE_ARGUMENT_PACK);
3653 SET_ARGUMENT_PACK_ARGS (t, vec);
3658 t = DECL_INITIAL (t);
3660 if (TEMPLATE_PARM_PARAMETER_PACK (t))
3662 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3663 with a single element, which expands T. */
3664 tree vec = make_tree_vec (1);
3665 tree type = TREE_TYPE (TEMPLATE_PARM_DECL (t));
3666 #ifdef ENABLE_CHECKING
3667 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3668 (vec, TREE_VEC_LENGTH (vec));
3670 TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
3672 t = make_node (NONTYPE_ARGUMENT_PACK);
3673 SET_ARGUMENT_PACK_ARGS (t, vec);
3674 TREE_TYPE (t) = type;
3677 TREE_VEC_ELT (a, i) = t;
3682 #ifdef ENABLE_CHECKING
3683 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a, TREE_VEC_LENGTH (a));
3687 TREE_VEC_ELT (args, --l) = a;
3695 /* Update the declared TYPE by doing any lookups which were thought to be
3696 dependent, but are not now that we know the SCOPE of the declarator. */
3699 maybe_update_decl_type (tree orig_type, tree scope)
3701 tree type = orig_type;
3703 if (type == NULL_TREE)
3706 if (TREE_CODE (orig_type) == TYPE_DECL)
3707 type = TREE_TYPE (type);
3709 if (scope && TYPE_P (scope) && dependent_type_p (scope)
3710 && dependent_type_p (type)
3711 /* Don't bother building up the args in this case. */
3712 && TREE_CODE (type) != TEMPLATE_TYPE_PARM)
3714 /* tsubst in the args corresponding to the template parameters,
3715 including auto if present. Most things will be unchanged, but
3716 make_typename_type and tsubst_qualified_id will resolve
3717 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
3718 tree args = current_template_args ();
3719 tree auto_node = type_uses_auto (type);
3722 tree auto_vec = make_tree_vec (1);
3723 TREE_VEC_ELT (auto_vec, 0) = auto_node;
3724 args = add_to_template_args (args, auto_vec);
3727 type = tsubst (type, args, tf_warning_or_error, NULL_TREE);
3731 if (type == error_mark_node)
3734 if (TREE_CODE (orig_type) == TYPE_DECL)
3736 if (same_type_p (type, TREE_TYPE (orig_type)))
3739 type = TYPE_NAME (type);
3744 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
3745 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
3746 a member template. Used by push_template_decl below. */
3749 build_template_decl (tree decl, tree parms, bool member_template_p)
3751 tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
3752 DECL_TEMPLATE_PARMS (tmpl) = parms;
3753 DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
3754 DECL_MEMBER_TEMPLATE_P (tmpl) = member_template_p;
3759 struct template_parm_data
3761 /* The level of the template parameters we are currently
3765 /* The index of the specialization argument we are currently
3769 /* An array whose size is the number of template parameters. The
3770 elements are nonzero if the parameter has been used in any one
3771 of the arguments processed so far. */
3774 /* An array whose size is the number of template arguments. The
3775 elements are nonzero if the argument makes use of template
3776 parameters of this level. */
3777 int* arg_uses_template_parms;
3780 /* Subroutine of push_template_decl used to see if each template
3781 parameter in a partial specialization is used in the explicit
3782 argument list. If T is of the LEVEL given in DATA (which is
3783 treated as a template_parm_data*), then DATA->PARMS is marked
3787 mark_template_parm (tree t, void* data)
3791 struct template_parm_data* tpd = (struct template_parm_data*) data;
3793 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
3795 level = TEMPLATE_PARM_LEVEL (t);
3796 idx = TEMPLATE_PARM_IDX (t);
3800 level = TEMPLATE_TYPE_LEVEL (t);
3801 idx = TEMPLATE_TYPE_IDX (t);
3804 if (level == tpd->level)
3806 tpd->parms[idx] = 1;
3807 tpd->arg_uses_template_parms[tpd->current_arg] = 1;
3810 /* Return zero so that for_each_template_parm will continue the
3811 traversal of the tree; we want to mark *every* template parm. */
3815 /* Process the partial specialization DECL. */
3818 process_partial_specialization (tree decl)
3820 tree type = TREE_TYPE (decl);
3821 tree maintmpl = CLASSTYPE_TI_TEMPLATE (type);
3822 tree specargs = CLASSTYPE_TI_ARGS (type);
3823 tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
3824 tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
3826 int nargs = TREE_VEC_LENGTH (inner_args);
3829 int did_error_intro = 0;
3830 struct template_parm_data tpd;
3831 struct template_parm_data tpd2;
3833 gcc_assert (current_template_parms);
3835 inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
3836 ntparms = TREE_VEC_LENGTH (inner_parms);
3838 /* We check that each of the template parameters given in the
3839 partial specialization is used in the argument list to the
3840 specialization. For example:
3842 template <class T> struct S;
3843 template <class T> struct S<T*>;
3845 The second declaration is OK because `T*' uses the template
3846 parameter T, whereas
3848 template <class T> struct S<int>;
3850 is no good. Even trickier is:
3861 The S2<T> declaration is actually invalid; it is a
3862 full-specialization. Of course,
3865 struct S2<T (*)(U)>;
3867 or some such would have been OK. */
3868 tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
3869 tpd.parms = (int *) alloca (sizeof (int) * ntparms);
3870 memset (tpd.parms, 0, sizeof (int) * ntparms);
3872 tpd.arg_uses_template_parms = (int *) alloca (sizeof (int) * nargs);
3873 memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
3874 for (i = 0; i < nargs; ++i)
3876 tpd.current_arg = i;
3877 for_each_template_parm (TREE_VEC_ELT (inner_args, i),
3878 &mark_template_parm,
3881 /*include_nondeduced_p=*/false);
3883 for (i = 0; i < ntparms; ++i)
3884 if (tpd.parms[i] == 0)
3886 /* One of the template parms was not used in the
3888 if (!did_error_intro)
3890 error ("template parameters not used in partial specialization:");
3891 did_error_intro = 1;
3894 error (" %qD", TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
3897 /* [temp.class.spec]
3899 The argument list of the specialization shall not be identical to
3900 the implicit argument list of the primary template. */
3901 if (comp_template_args
3903 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
3905 error ("partial specialization %qT does not specialize any template arguments", type);
3907 /* [temp.class.spec]
3909 A partially specialized non-type argument expression shall not
3910 involve template parameters of the partial specialization except
3911 when the argument expression is a simple identifier.
3913 The type of a template parameter corresponding to a specialized
3914 non-type argument shall not be dependent on a parameter of the
3917 Also, we verify that pack expansions only occur at the
3918 end of the argument list. */
3919 gcc_assert (nargs == DECL_NTPARMS (maintmpl));
3921 for (i = 0; i < nargs; ++i)
3923 tree parm = TREE_VALUE (TREE_VEC_ELT (main_inner_parms, i));
3924 tree arg = TREE_VEC_ELT (inner_args, i);
3925 tree packed_args = NULL_TREE;
3928 if (ARGUMENT_PACK_P (arg))
3930 /* Extract the arguments from the argument pack. We'll be
3931 iterating over these in the following loop. */
3932 packed_args = ARGUMENT_PACK_ARGS (arg);
3933 len = TREE_VEC_LENGTH (packed_args);
3936 for (j = 0; j < len; j++)
3939 /* Get the Jth argument in the parameter pack. */
3940 arg = TREE_VEC_ELT (packed_args, j);
3942 if (PACK_EXPANSION_P (arg))
3944 /* Pack expansions must come at the end of the
3946 if ((packed_args && j < len - 1)
3947 || (!packed_args && i < nargs - 1))
3949 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
3950 error ("parameter pack argument %qE must be at the "
3951 "end of the template argument list", arg);
3953 error ("parameter pack argument %qT must be at the "
3954 "end of the template argument list", arg);
3958 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
3959 /* We only care about the pattern. */
3960 arg = PACK_EXPANSION_PATTERN (arg);
3962 if (/* These first two lines are the `non-type' bit. */
3964 && TREE_CODE (arg) != TEMPLATE_DECL
3965 /* This next line is the `argument expression is not just a
3966 simple identifier' condition and also the `specialized
3967 non-type argument' bit. */
3968 && TREE_CODE (arg) != TEMPLATE_PARM_INDEX)
3970 if ((!packed_args && tpd.arg_uses_template_parms[i])
3971 || (packed_args && uses_template_parms (arg)))
3972 error ("template argument %qE involves template parameter(s)",
3976 /* Look at the corresponding template parameter,
3977 marking which template parameters its type depends
3979 tree type = TREE_TYPE (parm);
3983 /* We haven't yet initialized TPD2. Do so now. */
3984 tpd2.arg_uses_template_parms
3985 = (int *) alloca (sizeof (int) * nargs);
3986 /* The number of parameters here is the number in the
3987 main template, which, as checked in the assertion
3989 tpd2.parms = (int *) alloca (sizeof (int) * nargs);
3991 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
3994 /* Mark the template parameters. But this time, we're
3995 looking for the template parameters of the main
3996 template, not in the specialization. */
3997 tpd2.current_arg = i;
3998 tpd2.arg_uses_template_parms[i] = 0;
3999 memset (tpd2.parms, 0, sizeof (int) * nargs);
4000 for_each_template_parm (type,
4001 &mark_template_parm,
4004 /*include_nondeduced_p=*/false);
4006 if (tpd2.arg_uses_template_parms [i])
4008 /* The type depended on some template parameters.
4009 If they are fully specialized in the
4010 specialization, that's OK. */
4013 for (j = 0; j < nargs; ++j)
4014 if (tpd2.parms[j] != 0
4015 && tpd.arg_uses_template_parms [j])
4018 error_n (input_location, count,
4019 "type %qT of template argument %qE depends "
4020 "on a template parameter",
4021 "type %qT of template argument %qE depends "
4022 "on template parameters",
4031 /* We should only get here once. */
4032 gcc_assert (!COMPLETE_TYPE_P (type));
4034 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
4035 = tree_cons (specargs, inner_parms,
4036 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
4037 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
4041 /* Check that a template declaration's use of default arguments and
4042 parameter packs is not invalid. Here, PARMS are the template
4043 parameters. IS_PRIMARY is nonzero if DECL is the thing declared by
4044 a primary template. IS_PARTIAL is nonzero if DECL is a partial
4048 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4049 declaration (but not a definition); 1 indicates a declaration, 2
4050 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4051 emitted for extraneous default arguments.
4053 Returns TRUE if there were no errors found, FALSE otherwise. */
4056 check_default_tmpl_args (tree decl, tree parms, int is_primary,
4057 int is_partial, int is_friend_decl)
4060 int last_level_to_check;
4062 bool no_errors = true;
4066 A default template-argument shall not be specified in a
4067 function template declaration or a function template definition, nor
4068 in the template-parameter-list of the definition of a member of a
4071 if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
4072 /* You can't have a function template declaration in a local
4073 scope, nor you can you define a member of a class template in a
4077 if (current_class_type
4078 && !TYPE_BEING_DEFINED (current_class_type)
4079 && DECL_LANG_SPECIFIC (decl)
4080 && DECL_DECLARES_FUNCTION_P (decl)
4081 /* If this is either a friend defined in the scope of the class
4082 or a member function. */
4083 && (DECL_FUNCTION_MEMBER_P (decl)
4084 ? same_type_p (DECL_CONTEXT (decl), current_class_type)
4085 : DECL_FRIEND_CONTEXT (decl)
4086 ? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type)
4088 /* And, if it was a member function, it really was defined in
4089 the scope of the class. */
4090 && (!DECL_FUNCTION_MEMBER_P (decl)
4091 || DECL_INITIALIZED_IN_CLASS_P (decl)))
4092 /* We already checked these parameters when the template was
4093 declared, so there's no need to do it again now. This function
4094 was defined in class scope, but we're processing it's body now
4095 that the class is complete. */
4098 /* Core issue 226 (C++0x only): the following only applies to class
4100 if ((cxx_dialect == cxx98) || TREE_CODE (decl) != FUNCTION_DECL)
4104 If a template-parameter has a default template-argument, all
4105 subsequent template-parameters shall have a default
4106 template-argument supplied. */
4107 for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
4109 tree inner_parms = TREE_VALUE (parm_level);
4110 int ntparms = TREE_VEC_LENGTH (inner_parms);
4111 int seen_def_arg_p = 0;
4114 for (i = 0; i < ntparms; ++i)
4116 tree parm = TREE_VEC_ELT (inner_parms, i);
4118 if (parm == error_mark_node)
4121 if (TREE_PURPOSE (parm))
4123 else if (seen_def_arg_p
4124 && !template_parameter_pack_p (TREE_VALUE (parm)))
4126 error ("no default argument for %qD", TREE_VALUE (parm));
4127 /* For better subsequent error-recovery, we indicate that
4128 there should have been a default argument. */
4129 TREE_PURPOSE (parm) = error_mark_node;
4135 /* Don't complain about an enclosing partial
4137 && parm_level == parms
4138 && TREE_CODE (decl) == TYPE_DECL
4140 && template_parameter_pack_p (TREE_VALUE (parm)))
4142 /* A primary class template can only have one
4143 parameter pack, at the end of the template
4146 if (TREE_CODE (TREE_VALUE (parm)) == PARM_DECL)
4147 error ("parameter pack %qE must be at the end of the"
4148 " template parameter list", TREE_VALUE (parm));
4150 error ("parameter pack %qT must be at the end of the"
4151 " template parameter list",
4152 TREE_TYPE (TREE_VALUE (parm)));
4154 TREE_VALUE (TREE_VEC_ELT (inner_parms, i))
4162 if (((cxx_dialect == cxx98) && TREE_CODE (decl) != TYPE_DECL)
4166 /* For an ordinary class template, default template arguments are
4167 allowed at the innermost level, e.g.:
4168 template <class T = int>
4170 but, in a partial specialization, they're not allowed even
4171 there, as we have in [temp.class.spec]:
4173 The template parameter list of a specialization shall not
4174 contain default template argument values.
4176 So, for a partial specialization, or for a function template
4177 (in C++98/C++03), we look at all of them. */
4180 /* But, for a primary class template that is not a partial
4181 specialization we look at all template parameters except the
4183 parms = TREE_CHAIN (parms);
4185 /* Figure out what error message to issue. */
4186 if (is_friend_decl == 2)
4187 msg = G_("default template arguments may not be used in function template "
4188 "friend re-declaration");
4189 else if (is_friend_decl)
4190 msg = G_("default template arguments may not be used in function template "
4191 "friend declarations");
4192 else if (TREE_CODE (decl) == FUNCTION_DECL && (cxx_dialect == cxx98))
4193 msg = G_("default template arguments may not be used in function templates "
4194 "without -std=c++0x or -std=gnu++0x");
4195 else if (is_partial)
4196 msg = G_("default template arguments may not be used in "
4197 "partial specializations");
4199 msg = G_("default argument for template parameter for class enclosing %qD");
4201 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
4202 /* If we're inside a class definition, there's no need to
4203 examine the parameters to the class itself. On the one
4204 hand, they will be checked when the class is defined, and,
4205 on the other, default arguments are valid in things like:
4206 template <class T = double>
4207 struct S { template <class U> void f(U); };
4208 Here the default argument for `S' has no bearing on the
4209 declaration of `f'. */
4210 last_level_to_check = template_class_depth (current_class_type) + 1;
4212 /* Check everything. */
4213 last_level_to_check = 0;
4215 for (parm_level = parms;
4216 parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
4217 parm_level = TREE_CHAIN (parm_level))
4219 tree inner_parms = TREE_VALUE (parm_level);
4223 ntparms = TREE_VEC_LENGTH (inner_parms);
4224 for (i = 0; i < ntparms; ++i)
4226 if (TREE_VEC_ELT (inner_parms, i) == error_mark_node)
4229 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
4234 if (is_friend_decl == 2)
4241 /* Clear out the default argument so that we are not
4243 TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
4247 /* At this point, if we're still interested in issuing messages,
4248 they must apply to classes surrounding the object declared. */
4250 msg = G_("default argument for template parameter for class "
4257 /* Worker for push_template_decl_real, called via
4258 for_each_template_parm. DATA is really an int, indicating the
4259 level of the parameters we are interested in. If T is a template
4260 parameter of that level, return nonzero. */
4263 template_parm_this_level_p (tree t, void* data)
4265 int this_level = *(int *)data;
4268 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
4269 level = TEMPLATE_PARM_LEVEL (t);
4271 level = TEMPLATE_TYPE_LEVEL (t);
4272 return level == this_level;
4275 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
4276 parameters given by current_template_args, or reuses a
4277 previously existing one, if appropriate. Returns the DECL, or an
4278 equivalent one, if it is replaced via a call to duplicate_decls.
4280 If IS_FRIEND is true, DECL is a friend declaration. */
4283 push_template_decl_real (tree decl, bool is_friend)
4291 int new_template_p = 0;
4292 /* True if the template is a member template, in the sense of
4294 bool member_template_p = false;
4296 if (decl == error_mark_node || !current_template_parms)
4297 return error_mark_node;
4299 /* See if this is a partial specialization. */
4300 is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl)
4301 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
4302 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)));
4304 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl))
4308 /* For a friend, we want the context of the friend function, not
4309 the type of which it is a friend. */
4310 ctx = DECL_CONTEXT (decl);
4311 else if (CP_DECL_CONTEXT (decl)
4312 && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4313 /* In the case of a virtual function, we want the class in which
4315 ctx = CP_DECL_CONTEXT (decl);
4317 /* Otherwise, if we're currently defining some class, the DECL
4318 is assumed to be a member of the class. */
4319 ctx = current_scope ();
4321 if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
4324 if (!DECL_CONTEXT (decl))
4325 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
4327 /* See if this is a primary template. */
4328 if (is_friend && ctx)
4329 /* A friend template that specifies a class context, i.e.
4330 template <typename T> friend void A<T>::f();
4334 primary = template_parm_scope_p ();
4338 if (DECL_CLASS_SCOPE_P (decl))
4339 member_template_p = true;
4340 if (TREE_CODE (decl) == TYPE_DECL
4341 && ANON_AGGRNAME_P (DECL_NAME (decl)))
4343 error ("template class without a name");
4344 return error_mark_node;
4346 else if (TREE_CODE (decl) == FUNCTION_DECL)
4348 if (DECL_DESTRUCTOR_P (decl))
4352 A destructor shall not be a member template. */
4353 error ("destructor %qD declared as member template", decl);
4354 return error_mark_node;
4356 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl))
4357 && (!TYPE_ARG_TYPES (TREE_TYPE (decl))
4358 || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
4359 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
4360 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl))))
4361 == void_list_node)))
4363 /* [basic.stc.dynamic.allocation]
4365 An allocation function can be a function
4366 template. ... Template allocation functions shall
4367 have two or more parameters. */
4368 error ("invalid template declaration of %qD", decl);
4369 return error_mark_node;
4372 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
4373 && CLASS_TYPE_P (TREE_TYPE (decl)))
4377 error ("template declaration of %q#D", decl);
4378 return error_mark_node;
4382 /* Check to see that the rules regarding the use of default
4383 arguments are not being violated. */
4384 check_default_tmpl_args (decl, current_template_parms,
4385 primary, is_partial, /*is_friend_decl=*/0);
4387 /* Ensure that there are no parameter packs in the type of this
4388 declaration that have not been expanded. */
4389 if (TREE_CODE (decl) == FUNCTION_DECL)
4391 /* Check each of the arguments individually to see if there are
4392 any bare parameter packs. */
4393 tree type = TREE_TYPE (decl);
4394 tree arg = DECL_ARGUMENTS (decl);
4395 tree argtype = TYPE_ARG_TYPES (type);
4397 while (arg && argtype)
4399 if (!FUNCTION_PARAMETER_PACK_P (arg)
4400 && check_for_bare_parameter_packs (TREE_TYPE (arg)))
4402 /* This is a PARM_DECL that contains unexpanded parameter
4403 packs. We have already complained about this in the
4404 check_for_bare_parameter_packs call, so just replace
4405 these types with ERROR_MARK_NODE. */
4406 TREE_TYPE (arg) = error_mark_node;
4407 TREE_VALUE (argtype) = error_mark_node;
4410 arg = TREE_CHAIN (arg);
4411 argtype = TREE_CHAIN (argtype);
4414 /* Check for bare parameter packs in the return type and the
4415 exception specifiers. */
4416 if (check_for_bare_parameter_packs (TREE_TYPE (type)))
4417 /* Errors were already issued, set return type to int
4418 as the frontend doesn't expect error_mark_node as
4420 TREE_TYPE (type) = integer_type_node;
4421 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type)))
4422 TYPE_RAISES_EXCEPTIONS (type) = NULL_TREE;
4424 else if (check_for_bare_parameter_packs (TREE_TYPE (decl)))
4426 TREE_TYPE (decl) = error_mark_node;
4427 return error_mark_node;
4431 return process_partial_specialization (decl);
4433 args = current_template_args ();
4436 || TREE_CODE (ctx) == FUNCTION_DECL
4437 || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
4438 || (is_friend && !DECL_TEMPLATE_INFO (decl)))
4440 if (DECL_LANG_SPECIFIC (decl)
4441 && DECL_TEMPLATE_INFO (decl)
4442 && DECL_TI_TEMPLATE (decl))
4443 tmpl = DECL_TI_TEMPLATE (decl);
4444 /* If DECL is a TYPE_DECL for a class-template, then there won't
4445 be DECL_LANG_SPECIFIC. The information equivalent to
4446 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
4447 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
4448 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
4449 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
4451 /* Since a template declaration already existed for this
4452 class-type, we must be redeclaring it here. Make sure
4453 that the redeclaration is valid. */
4454 redeclare_class_template (TREE_TYPE (decl),
4455 current_template_parms);
4456 /* We don't need to create a new TEMPLATE_DECL; just use the
4457 one we already had. */
4458 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
4462 tmpl = build_template_decl (decl, current_template_parms,
4466 if (DECL_LANG_SPECIFIC (decl)
4467 && DECL_TEMPLATE_SPECIALIZATION (decl))
4469 /* A specialization of a member template of a template
4471 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
4472 DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
4473 DECL_TEMPLATE_INFO (decl) = NULL_TREE;
4479 tree a, t, current, parms;
4481 tree tinfo = get_template_info (decl);
4485 error ("template definition of non-template %q#D", decl);
4486 return error_mark_node;
4489 tmpl = TI_TEMPLATE (tinfo);
4491 if (DECL_FUNCTION_TEMPLATE_P (tmpl)
4492 && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
4493 && DECL_TEMPLATE_SPECIALIZATION (decl)
4494 && DECL_MEMBER_TEMPLATE_P (tmpl))
4498 /* The declaration is a specialization of a member
4499 template, declared outside the class. Therefore, the
4500 innermost template arguments will be NULL, so we
4501 replace them with the arguments determined by the
4502 earlier call to check_explicit_specialization. */
4503 args = DECL_TI_ARGS (decl);
4506 = build_template_decl (decl, current_template_parms,
4508 DECL_TEMPLATE_RESULT (new_tmpl) = decl;
4509 TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
4510 DECL_TI_TEMPLATE (decl) = new_tmpl;
4511 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
4512 DECL_TEMPLATE_INFO (new_tmpl)
4513 = build_template_info (tmpl, args);
4515 register_specialization (new_tmpl,
4516 most_general_template (tmpl),
4522 /* Make sure the template headers we got make sense. */
4524 parms = DECL_TEMPLATE_PARMS (tmpl);
4525 i = TMPL_PARMS_DEPTH (parms);
4526 if (TMPL_ARGS_DEPTH (args) != i)
4528 error ("expected %d levels of template parms for %q#D, got %d",
4529 i, decl, TMPL_ARGS_DEPTH (args));
4532 for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
4534 a = TMPL_ARGS_LEVEL (args, i);
4535 t = INNERMOST_TEMPLATE_PARMS (parms);
4537 if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
4539 if (current == decl)
4540 error ("got %d template parameters for %q#D",
4541 TREE_VEC_LENGTH (a), decl);
4543 error ("got %d template parameters for %q#T",
4544 TREE_VEC_LENGTH (a), current);
4545 error (" but %d required", TREE_VEC_LENGTH (t));
4546 return error_mark_node;
4549 if (current == decl)
4552 current = (TYPE_P (current)
4553 ? TYPE_CONTEXT (current)
4554 : DECL_CONTEXT (current));
4557 /* Check that the parms are used in the appropriate qualifying scopes
4558 in the declarator. */
4559 if (!comp_template_args
4561 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl)))))
4564 template arguments to %qD do not match original template %qD",
4565 decl, DECL_TEMPLATE_RESULT (tmpl));
4566 if (!uses_template_parms (TI_ARGS (tinfo)))
4567 inform (input_location, "use template<> for an explicit specialization");
4568 /* Avoid crash in import_export_decl. */
4569 DECL_INTERFACE_KNOWN (decl) = 1;
4570 return error_mark_node;
4574 DECL_TEMPLATE_RESULT (tmpl) = decl;
4575 TREE_TYPE (tmpl) = TREE_TYPE (decl);
4577 /* Push template declarations for global functions and types. Note
4578 that we do not try to push a global template friend declared in a
4579 template class; such a thing may well depend on the template
4580 parameters of the class. */
4581 if (new_template_p && !ctx
4582 && !(is_friend && template_class_depth (current_class_type) > 0))
4584 tmpl = pushdecl_namespace_level (tmpl, is_friend);
4585 if (tmpl == error_mark_node)
4586 return error_mark_node;
4588 /* Hide template friend classes that haven't been declared yet. */
4589 if (is_friend && TREE_CODE (decl) == TYPE_DECL)
4591 DECL_ANTICIPATED (tmpl) = 1;
4592 DECL_FRIEND_P (tmpl) = 1;
4598 tree parms = DECL_TEMPLATE_PARMS (tmpl);
4601 DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
4602 if (DECL_CONV_FN_P (tmpl))
4604 int depth = TMPL_PARMS_DEPTH (parms);
4606 /* It is a conversion operator. See if the type converted to
4607 depends on innermost template operands. */
4609 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl)),
4611 DECL_TEMPLATE_CONV_FN_P (tmpl) = 1;
4614 /* Give template template parms a DECL_CONTEXT of the template
4615 for which they are a parameter. */
4616 parms = INNERMOST_TEMPLATE_PARMS (parms);
4617 for (i = TREE_VEC_LENGTH (parms) - 1; i >= 0; --i)
4619 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
4620 if (TREE_CODE (parm) == TEMPLATE_DECL)
4621 DECL_CONTEXT (parm) = tmpl;
4623 if (TREE_CODE (TREE_TYPE (parm)) == TEMPLATE_TYPE_PARM)
4624 DECL_CONTEXT (TYPE_NAME (TREE_TYPE (parm))) = tmpl;
4628 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
4629 back to its most general template. If TMPL is a specialization,
4630 ARGS may only have the innermost set of arguments. Add the missing
4631 argument levels if necessary. */
4632 if (DECL_TEMPLATE_INFO (tmpl))
4633 args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);
4635 info = build_template_info (tmpl, args);
4637 if (DECL_IMPLICIT_TYPEDEF_P (decl))
4638 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
4639 else if (DECL_LANG_SPECIFIC (decl))
4640 DECL_TEMPLATE_INFO (decl) = info;
4642 return DECL_TEMPLATE_RESULT (tmpl);
4646 push_template_decl (tree decl)
4648 return push_template_decl_real (decl, false);
4651 /* Called when a class template TYPE is redeclared with the indicated
4652 template PARMS, e.g.:
4654 template <class T> struct S;
4655 template <class T> struct S {}; */
4658 redeclare_class_template (tree type, tree parms)
4664 if (!TYPE_TEMPLATE_INFO (type))
4666 error ("%qT is not a template type", type);
4670 tmpl = TYPE_TI_TEMPLATE (type);
4671 if (!PRIMARY_TEMPLATE_P (tmpl))
4672 /* The type is nested in some template class. Nothing to worry
4673 about here; there are no new template parameters for the nested
4679 error ("template specifiers not specified in declaration of %qD",
4684 parms = INNERMOST_TEMPLATE_PARMS (parms);
4685 tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
4687 if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
4689 error_n (input_location, TREE_VEC_LENGTH (parms),
4690 "redeclared with %d template parameter",
4691 "redeclared with %d template parameters",
4692 TREE_VEC_LENGTH (parms));
4693 inform_n (input_location, TREE_VEC_LENGTH (tmpl_parms),
4694 "previous declaration %q+D used %d template parameter",
4695 "previous declaration %q+D used %d template parameters",
4696 tmpl, TREE_VEC_LENGTH (tmpl_parms));
4700 for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
4707 if (TREE_VEC_ELT (tmpl_parms, i) == error_mark_node
4708 || TREE_VEC_ELT (parms, i) == error_mark_node)
4711 tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
4712 if (tmpl_parm == error_mark_node)
4715 parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
4716 tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i));
4717 parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
4719 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
4721 if (TREE_CODE (tmpl_parm) != TREE_CODE (parm)
4722 || (TREE_CODE (tmpl_parm) != TYPE_DECL
4723 && !same_type_p (TREE_TYPE (tmpl_parm), TREE_TYPE (parm)))
4724 || (TREE_CODE (tmpl_parm) != PARM_DECL
4725 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm))
4726 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm))))
4727 || (TREE_CODE (tmpl_parm) == PARM_DECL
4728 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm))
4729 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))))
4731 error ("template parameter %q+#D", tmpl_parm);
4732 error ("redeclared here as %q#D", parm);
4736 if (tmpl_default != NULL_TREE && parm_default != NULL_TREE)
4738 /* We have in [temp.param]:
4740 A template-parameter may not be given default arguments
4741 by two different declarations in the same scope. */
4742 error_at (input_location, "redefinition of default argument for %q#D", parm);
4743 inform (DECL_SOURCE_LOCATION (tmpl_parm),
4744 "original definition appeared here");
4748 if (parm_default != NULL_TREE)
4749 /* Update the previous template parameters (which are the ones
4750 that will really count) with the new default value. */
4751 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default;
4752 else if (tmpl_default != NULL_TREE)
4753 /* Update the new parameters, too; they'll be used as the
4754 parameters for any members. */
4755 TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default;
4761 /* Simplify EXPR if it is a non-dependent expression. Returns the
4762 (possibly simplified) expression. */
4765 fold_non_dependent_expr (tree expr)
4767 if (expr == NULL_TREE)
4770 /* If we're in a template, but EXPR isn't value dependent, simplify
4771 it. We're supposed to treat:
4773 template <typename T> void f(T[1 + 1]);
4774 template <typename T> void f(T[2]);
4776 as two declarations of the same function, for example. */
4777 if (processing_template_decl
4778 && !type_dependent_expression_p (expr)
4779 && !value_dependent_expression_p (expr))
4781 HOST_WIDE_INT saved_processing_template_decl;
4783 saved_processing_template_decl = processing_template_decl;
4784 processing_template_decl = 0;
4785 expr = tsubst_copy_and_build (expr,
4788 /*in_decl=*/NULL_TREE,
4789 /*function_p=*/false,
4790 /*integral_constant_expression_p=*/true);
4791 processing_template_decl = saved_processing_template_decl;
4796 /* EXPR is an expression which is used in a constant-expression context.
4797 For instance, it could be a VAR_DECL with a constant initializer.
4798 Extract the innermost constant expression.
4800 This is basically a more powerful version of
4801 integral_constant_value, which can be used also in templates where
4802 initializers can maintain a syntactic rather than semantic form
4803 (even if they are non-dependent, for access-checking purposes). */
4806 fold_decl_constant_value (tree expr)
4808 tree const_expr = expr;
4811 expr = fold_non_dependent_expr (const_expr);
4812 const_expr = integral_constant_value (expr);
4814 while (expr != const_expr);
4819 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
4820 must be a function or a pointer-to-function type, as specified
4821 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
4822 and check that the resulting function has external linkage. */
4825 convert_nontype_argument_function (tree type, tree expr)
4830 fn = instantiate_type (type, fns, tf_none);
4831 if (fn == error_mark_node)
4832 return error_mark_node;
4835 if (TREE_CODE (fn_no_ptr) == ADDR_EXPR)
4836 fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0);
4837 if (TREE_CODE (fn_no_ptr) == BASELINK)
4838 fn_no_ptr = BASELINK_FUNCTIONS (fn_no_ptr);
4840 /* [temp.arg.nontype]/1
4842 A template-argument for a non-type, non-template template-parameter
4845 -- the address of an object or function with external linkage. */
4846 if (!DECL_EXTERNAL_LINKAGE_P (fn_no_ptr))
4848 error ("%qE is not a valid template argument for type %qT "
4849 "because function %qD has not external linkage",
4850 expr, type, fn_no_ptr);
4857 /* Subroutine of convert_nontype_argument.
4858 Check if EXPR of type TYPE is a valid pointer-to-member constant.
4859 Emit an error otherwise. */
4862 check_valid_ptrmem_cst_expr (tree type, tree expr)
4865 if (expr && (null_ptr_cst_p (expr) || TREE_CODE (expr) == PTRMEM_CST))
4867 error ("%qE is not a valid template argument for type %qT",
4869 error ("it must be a pointer-to-member of the form `&X::Y'");
4873 /* Attempt to convert the non-type template parameter EXPR to the
4874 indicated TYPE. If the conversion is successful, return the
4875 converted value. If the conversion is unsuccessful, return
4876 NULL_TREE if we issued an error message, or error_mark_node if we
4877 did not. We issue error messages for out-and-out bad template
4878 parameters, but not simply because the conversion failed, since we
4879 might be just trying to do argument deduction. Both TYPE and EXPR
4880 must be non-dependent.
4882 The conversion follows the special rules described in
4883 [temp.arg.nontype], and it is much more strict than an implicit
4886 This function is called twice for each template argument (see
4887 lookup_template_class for a more accurate description of this
4888 problem). This means that we need to handle expressions which
4889 are not valid in a C++ source, but can be created from the
4890 first call (for instance, casts to perform conversions). These
4891 hacks can go away after we fix the double coercion problem. */
4894 convert_nontype_argument (tree type, tree expr)
4898 /* Detect immediately string literals as invalid non-type argument.
4899 This special-case is not needed for correctness (we would easily
4900 catch this later), but only to provide better diagnostic for this
4901 common user mistake. As suggested by DR 100, we do not mention
4902 linkage issues in the diagnostic as this is not the point. */
4903 if (TREE_CODE (expr) == STRING_CST)
4905 error ("%qE is not a valid template argument for type %qT "
4906 "because string literals can never be used in this context",
4911 /* If we are in a template, EXPR may be non-dependent, but still
4912 have a syntactic, rather than semantic, form. For example, EXPR
4913 might be a SCOPE_REF, rather than the VAR_DECL to which the
4914 SCOPE_REF refers. Preserving the qualifying scope is necessary
4915 so that access checking can be performed when the template is
4916 instantiated -- but here we need the resolved form so that we can
4917 convert the argument. */
4918 expr = fold_non_dependent_expr (expr);
4919 if (error_operand_p (expr))
4920 return error_mark_node;
4921 expr_type = TREE_TYPE (expr);
4923 /* HACK: Due to double coercion, we can get a
4924 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
4925 which is the tree that we built on the first call (see
4926 below when coercing to reference to object or to reference to
4927 function). We just strip everything and get to the arg.
4928 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
4930 if (TREE_CODE (expr) == NOP_EXPR)
4932 if (TYPE_REF_OBJ_P (type) || TYPE_REFFN_P (type))
4934 /* ??? Maybe we could use convert_from_reference here, but we
4935 would need to relax its constraints because the NOP_EXPR
4936 could actually change the type to something more cv-qualified,
4937 and this is not folded by convert_from_reference. */
4938 tree addr = TREE_OPERAND (expr, 0);
4939 gcc_assert (TREE_CODE (expr_type) == REFERENCE_TYPE);
4940 gcc_assert (TREE_CODE (addr) == ADDR_EXPR);
4941 gcc_assert (TREE_CODE (TREE_TYPE (addr)) == POINTER_TYPE);
4942 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4943 (TREE_TYPE (expr_type),
4944 TREE_TYPE (TREE_TYPE (addr))));
4946 expr = TREE_OPERAND (addr, 0);
4947 expr_type = TREE_TYPE (expr);
4950 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
4951 parameter is a pointer to object, through decay and
4952 qualification conversion. Let's strip everything. */
4953 else if (TYPE_PTROBV_P (type))
4956 gcc_assert (TREE_CODE (expr) == ADDR_EXPR);
4957 gcc_assert (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE);
4958 /* Skip the ADDR_EXPR only if it is part of the decay for
4959 an array. Otherwise, it is part of the original argument
4960 in the source code. */
4961 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == ARRAY_TYPE)
4962 expr = TREE_OPERAND (expr, 0);
4963 expr_type = TREE_TYPE (expr);
4967 /* [temp.arg.nontype]/5, bullet 1
4969 For a non-type template-parameter of integral or enumeration type,
4970 integral promotions (_conv.prom_) and integral conversions
4971 (_conv.integral_) are applied. */
4972 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type))
4974 if (!INTEGRAL_OR_ENUMERATION_TYPE_P (expr_type))
4975 return error_mark_node;
4977 expr = fold_decl_constant_value (expr);
4978 /* Notice that there are constant expressions like '4 % 0' which
4979 do not fold into integer constants. */
4980 if (TREE_CODE (expr) != INTEGER_CST)
4982 error ("%qE is not a valid template argument for type %qT "
4983 "because it is a non-constant expression", expr, type);
4987 /* At this point, an implicit conversion does what we want,
4988 because we already know that the expression is of integral
4990 expr = ocp_convert (type, expr, CONV_IMPLICIT, LOOKUP_PROTECT);
4991 if (expr == error_mark_node)
4992 return error_mark_node;
4994 /* Conversion was allowed: fold it to a bare integer constant. */
4997 /* [temp.arg.nontype]/5, bullet 2
4999 For a non-type template-parameter of type pointer to object,
5000 qualification conversions (_conv.qual_) and the array-to-pointer
5001 conversion (_conv.array_) are applied. */
5002 else if (TYPE_PTROBV_P (type))
5004 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
5006 A template-argument for a non-type, non-template template-parameter
5007 shall be one of: [...]
5009 -- the name of a non-type template-parameter;
5010 -- the address of an object or function with external linkage, [...]
5011 expressed as "& id-expression" where the & is optional if the name
5012 refers to a function or array, or if the corresponding
5013 template-parameter is a reference.
5015 Here, we do not care about functions, as they are invalid anyway
5016 for a parameter of type pointer-to-object. */
5018 if (DECL_P (expr) && DECL_TEMPLATE_PARM_P (expr))
5019 /* Non-type template parameters are OK. */
5021 else if (TREE_CODE (expr) != ADDR_EXPR
5022 && TREE_CODE (expr_type) != ARRAY_TYPE)
5024 if (TREE_CODE (expr) == VAR_DECL)
5026 error ("%qD is not a valid template argument "
5027 "because %qD is a variable, not the address of "
5032 /* Other values, like integer constants, might be valid
5033 non-type arguments of some other type. */
5034 return error_mark_node;
5040 decl = ((TREE_CODE (expr) == ADDR_EXPR)
5041 ? TREE_OPERAND (expr, 0) : expr);
5042 if (TREE_CODE (decl) != VAR_DECL)
5044 error ("%qE is not a valid template argument of type %qT "
5045 "because %qE is not a variable",
5049 else if (!DECL_EXTERNAL_LINKAGE_P (decl))
5051 error ("%qE is not a valid template argument of type %qT "
5052 "because %qD does not have external linkage",
5058 expr = decay_conversion (expr);
5059 if (expr == error_mark_node)
5060 return error_mark_node;
5062 expr = perform_qualification_conversions (type, expr);
5063 if (expr == error_mark_node)
5064 return error_mark_node;
5066 /* [temp.arg.nontype]/5, bullet 3
5068 For a non-type template-parameter of type reference to object, no
5069 conversions apply. The type referred to by the reference may be more
5070 cv-qualified than the (otherwise identical) type of the
5071 template-argument. The template-parameter is bound directly to the
5072 template-argument, which must be an lvalue. */
5073 else if (TYPE_REF_OBJ_P (type))
5075 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type),
5077 return error_mark_node;
5079 if (!at_least_as_qualified_p (TREE_TYPE (type), expr_type))
5081 error ("%qE is not a valid template argument for type %qT "
5082 "because of conflicts in cv-qualification", expr, type);
5086 if (!real_lvalue_p (expr))
5088 error ("%qE is not a valid template argument for type %qT "
5089 "because it is not an lvalue", expr, type);
5093 /* [temp.arg.nontype]/1
5095 A template-argument for a non-type, non-template template-parameter
5096 shall be one of: [...]
5098 -- the address of an object or function with external linkage. */
5099 if (TREE_CODE (expr) == INDIRECT_REF
5100 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr, 0))))
5102 expr = TREE_OPERAND (expr, 0);
5105 error ("%q#D is not a valid template argument for type %qT "
5106 "because a reference variable does not have a constant "
5107 "address", expr, type);
5114 error ("%qE is not a valid template argument for type %qT "
5115 "because it is not an object with external linkage",
5120 if (!DECL_EXTERNAL_LINKAGE_P (expr))
5122 error ("%qE is not a valid template argument for type %qT "
5123 "because object %qD has not external linkage",
5128 expr = build_nop (type, build_address (expr));
5130 /* [temp.arg.nontype]/5, bullet 4
5132 For a non-type template-parameter of type pointer to function, only
5133 the function-to-pointer conversion (_conv.func_) is applied. If the
5134 template-argument represents a set of overloaded functions (or a
5135 pointer to such), the matching function is selected from the set
5137 else if (TYPE_PTRFN_P (type))
5139 /* If the argument is a template-id, we might not have enough
5140 context information to decay the pointer. */
5141 if (!type_unknown_p (expr_type))
5143 expr = decay_conversion (expr);
5144 if (expr == error_mark_node)
5145 return error_mark_node;
5148 expr = convert_nontype_argument_function (type, expr);
5149 if (!expr || expr == error_mark_node)
5152 if (TREE_CODE (expr) != ADDR_EXPR)
5154 error ("%qE is not a valid template argument for type %qT", expr, type);
5155 error ("it must be the address of a function with external linkage");
5159 /* [temp.arg.nontype]/5, bullet 5
5161 For a non-type template-parameter of type reference to function, no
5162 conversions apply. If the template-argument represents a set of
5163 overloaded functions, the matching function is selected from the set
5165 else if (TYPE_REFFN_P (type))
5167 if (TREE_CODE (expr) == ADDR_EXPR)
5169 error ("%qE is not a valid template argument for type %qT "
5170 "because it is a pointer", expr, type);
5171 inform (input_location, "try using %qE instead", TREE_OPERAND (expr, 0));
5175 expr = convert_nontype_argument_function (TREE_TYPE (type), expr);
5176 if (!expr || expr == error_mark_node)
5179 expr = build_nop (type, build_address (expr));
5181 /* [temp.arg.nontype]/5, bullet 6
5183 For a non-type template-parameter of type pointer to member function,
5184 no conversions apply. If the template-argument represents a set of
5185 overloaded member functions, the matching member function is selected
5186 from the set (_over.over_). */
5187 else if (TYPE_PTRMEMFUNC_P (type))
5189 expr = instantiate_type (type, expr, tf_none);
5190 if (expr == error_mark_node)
5191 return error_mark_node;
5193 /* [temp.arg.nontype] bullet 1 says the pointer to member
5194 expression must be a pointer-to-member constant. */
5195 if (!check_valid_ptrmem_cst_expr (type, expr))
5196 return error_mark_node;
5198 /* There is no way to disable standard conversions in
5199 resolve_address_of_overloaded_function (called by
5200 instantiate_type). It is possible that the call succeeded by
5201 converting &B::I to &D::I (where B is a base of D), so we need
5202 to reject this conversion here.
5204 Actually, even if there was a way to disable standard conversions,
5205 it would still be better to reject them here so that we can
5206 provide a superior diagnostic. */
5207 if (!same_type_p (TREE_TYPE (expr), type))
5209 error ("%qE is not a valid template argument for type %qT "
5210 "because it is of type %qT", expr, type,
5212 /* If we are just one standard conversion off, explain. */
5213 if (can_convert (type, TREE_TYPE (expr)))
5214 inform (input_location,
5215 "standard conversions are not allowed in this context");
5219 /* [temp.arg.nontype]/5, bullet 7
5221 For a non-type template-parameter of type pointer to data member,
5222 qualification conversions (_conv.qual_) are applied. */
5223 else if (TYPE_PTRMEM_P (type))
5225 /* [temp.arg.nontype] bullet 1 says the pointer to member
5226 expression must be a pointer-to-member constant. */
5227 if (!check_valid_ptrmem_cst_expr (type, expr))
5228 return error_mark_node;
5230 expr = perform_qualification_conversions (type, expr);
5231 if (expr == error_mark_node)
5234 /* A template non-type parameter must be one of the above. */
5238 /* Sanity check: did we actually convert the argument to the
5240 gcc_assert (same_type_p (type, TREE_TYPE (expr)));
5244 /* Subroutine of coerce_template_template_parms, which returns 1 if
5245 PARM_PARM and ARG_PARM match using the rule for the template
5246 parameters of template template parameters. Both PARM and ARG are
5247 template parameters; the rest of the arguments are the same as for
5248 coerce_template_template_parms.
5251 coerce_template_template_parm (tree parm,
5253 tsubst_flags_t complain,
5257 if (arg == NULL_TREE || arg == error_mark_node
5258 || parm == NULL_TREE || parm == error_mark_node)
5261 if (TREE_CODE (arg) != TREE_CODE (parm))
5264 switch (TREE_CODE (parm))
5267 /* We encounter instantiations of templates like
5268 template <template <template <class> class> class TT>
5271 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
5272 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
5274 if (!coerce_template_template_parms
5275 (parmparm, argparm, complain, in_decl, outer_args))
5281 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg))
5282 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm)))
5283 /* Argument is a parameter pack but parameter is not. */
5288 /* The tsubst call is used to handle cases such as
5290 template <int> class C {};
5291 template <class T, template <T> class TT> class D {};
5294 i.e. the parameter list of TT depends on earlier parameters. */
5295 if (!uses_template_parms (TREE_TYPE (arg))
5297 (tsubst (TREE_TYPE (parm), outer_args, complain, in_decl),
5301 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg))
5302 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))
5303 /* Argument is a parameter pack but parameter is not. */
5316 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
5317 template template parameters. Both PARM_PARMS and ARG_PARMS are
5318 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
5321 Consider the example:
5322 template <class T> class A;
5323 template<template <class U> class TT> class B;
5325 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
5326 the parameters to A, and OUTER_ARGS contains A. */
5329 coerce_template_template_parms (tree parm_parms,
5331 tsubst_flags_t complain,
5335 int nparms, nargs, i;
5339 gcc_assert (TREE_CODE (parm_parms) == TREE_VEC);
5340 gcc_assert (TREE_CODE (arg_parms) == TREE_VEC);
5342 nparms = TREE_VEC_LENGTH (parm_parms);
5343 nargs = TREE_VEC_LENGTH (arg_parms);
5345 /* Determine whether we have a parameter pack at the end of the
5346 template template parameter's template parameter list. */
5347 if (TREE_VEC_ELT (parm_parms, nparms - 1) != error_mark_node)
5349 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, nparms - 1));
5351 if (parm == error_mark_node)
5354 switch (TREE_CODE (parm))
5358 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm)))
5363 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))
5373 && !(variadic_p && nargs >= nparms - 1))
5376 /* Check all of the template parameters except the parameter pack at
5377 the end (if any). */
5378 for (i = 0; i < nparms - variadic_p; ++i)
5380 if (TREE_VEC_ELT (parm_parms, i) == error_mark_node
5381 || TREE_VEC_ELT (arg_parms, i) == error_mark_node)
5384 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
5385 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
5387 if (!coerce_template_template_parm (parm, arg, complain, in_decl,
5395 /* Check each of the template parameters in the template
5396 argument against the template parameter pack at the end of
5397 the template template parameter. */
5398 if (TREE_VEC_ELT (parm_parms, i) == error_mark_node)
5401 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
5403 for (; i < nargs; ++i)
5405 if (TREE_VEC_ELT (arg_parms, i) == error_mark_node)
5408 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
5410 if (!coerce_template_template_parm (parm, arg, complain, in_decl,
5419 /* Verifies that the deduced template arguments (in TARGS) for the
5420 template template parameters (in TPARMS) represent valid bindings,
5421 by comparing the template parameter list of each template argument
5422 to the template parameter list of its corresponding template
5423 template parameter, in accordance with DR150. This
5424 routine can only be called after all template arguments have been
5425 deduced. It will return TRUE if all of the template template
5426 parameter bindings are okay, FALSE otherwise. */
5428 template_template_parm_bindings_ok_p (tree tparms, tree targs)
5430 int i, ntparms = TREE_VEC_LENGTH (tparms);
5433 /* We're dealing with template parms in this process. */
5434 ++processing_template_decl;
5436 targs = INNERMOST_TEMPLATE_ARGS (targs);
5438 for (i = 0; i < ntparms; ++i)
5440 tree tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
5441 tree targ = TREE_VEC_ELT (targs, i);
5443 if (TREE_CODE (tparm) == TEMPLATE_DECL && targ)
5445 tree packed_args = NULL_TREE;
5448 if (ARGUMENT_PACK_P (targ))
5450 /* Look inside the argument pack. */
5451 packed_args = ARGUMENT_PACK_ARGS (targ);
5452 len = TREE_VEC_LENGTH (packed_args);
5455 for (idx = 0; idx < len; ++idx)
5457 tree targ_parms = NULL_TREE;
5460 /* Extract the next argument from the argument
5462 targ = TREE_VEC_ELT (packed_args, idx);
5464 if (PACK_EXPANSION_P (targ))
5465 /* Look at the pattern of the pack expansion. */
5466 targ = PACK_EXPANSION_PATTERN (targ);
5468 /* Extract the template parameters from the template
5470 if (TREE_CODE (targ) == TEMPLATE_DECL)
5471 targ_parms = DECL_INNERMOST_TEMPLATE_PARMS (targ);
5472 else if (TREE_CODE (targ) == TEMPLATE_TEMPLATE_PARM)
5473 targ_parms = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ));
5475 /* Verify that we can coerce the template template
5476 parameters from the template argument to the template
5477 parameter. This requires an exact match. */
5479 && !coerce_template_template_parms
5480 (DECL_INNERMOST_TEMPLATE_PARMS (tparm),
5495 --processing_template_decl;
5499 /* Convert the indicated template ARG as necessary to match the
5500 indicated template PARM. Returns the converted ARG, or
5501 error_mark_node if the conversion was unsuccessful. Error and
5502 warning messages are issued under control of COMPLAIN. This
5503 conversion is for the Ith parameter in the parameter list. ARGS is
5504 the full set of template arguments deduced so far. */
5507 convert_template_argument (tree parm,
5510 tsubst_flags_t complain,
5516 int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
5518 if (TREE_CODE (arg) == TREE_LIST
5519 && TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF)
5521 /* The template argument was the name of some
5522 member function. That's usually
5523 invalid, but static members are OK. In any
5524 case, grab the underlying fields/functions
5525 and issue an error later if required. */
5526 orig_arg = TREE_VALUE (arg);
5527 TREE_TYPE (arg) = unknown_type_node;
5532 requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
5533 requires_type = (TREE_CODE (parm) == TYPE_DECL
5534 || requires_tmpl_type);
5536 /* When determining whether an argument pack expansion is a template,
5537 look at the pattern. */
5538 if (TREE_CODE (arg) == TYPE_PACK_EXPANSION)
5539 arg = PACK_EXPANSION_PATTERN (arg);
5541 /* Deal with an injected-class-name used as a template template arg. */
5542 if (requires_tmpl_type && CLASS_TYPE_P (arg))
5544 tree t = maybe_get_template_decl_from_type_decl (TYPE_NAME (arg));
5545 if (TREE_CODE (t) == TEMPLATE_DECL)
5547 if (complain & tf_warning_or_error)
5548 pedwarn (input_location, OPT_pedantic, "injected-class-name %qD"
5549 " used as template template argument", TYPE_NAME (arg));
5550 else if (flag_pedantic_errors)
5558 ((TREE_CODE (arg) == TEMPLATE_DECL
5559 && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
5560 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
5561 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
5564 && (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
5565 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE))
5566 arg = TYPE_STUB_DECL (arg);
5568 is_type = TYPE_P (arg) || is_tmpl_type;
5570 if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
5571 && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
5573 permerror (input_location, "to refer to a type member of a template parameter, "
5574 "use %<typename %E%>", orig_arg);
5576 orig_arg = make_typename_type (TREE_OPERAND (arg, 0),
5577 TREE_OPERAND (arg, 1),
5579 complain & tf_error);
5583 if (is_type != requires_type)
5587 if (complain & tf_error)
5589 error ("type/value mismatch at argument %d in template "
5590 "parameter list for %qD",
5593 error (" expected a constant of type %qT, got %qT",
5595 (DECL_P (arg) ? DECL_NAME (arg) : orig_arg));
5596 else if (requires_tmpl_type)
5597 error (" expected a class template, got %qE", orig_arg);
5599 error (" expected a type, got %qE", orig_arg);
5602 return error_mark_node;
5604 if (is_tmpl_type ^ requires_tmpl_type)
5606 if (in_decl && (complain & tf_error))
5608 error ("type/value mismatch at argument %d in template "
5609 "parameter list for %qD",
5612 error (" expected a type, got %qT", DECL_NAME (arg));
5614 error (" expected a class template, got %qT", orig_arg);
5616 return error_mark_node;
5621 if (requires_tmpl_type)
5623 if (TREE_CODE (TREE_TYPE (arg)) == UNBOUND_CLASS_TEMPLATE)
5624 /* The number of argument required is not known yet.
5625 Just accept it for now. */
5626 val = TREE_TYPE (arg);
5629 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
5632 argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
5634 if (coerce_template_template_parms (parmparm, argparm,
5640 /* TEMPLATE_TEMPLATE_PARM node is preferred over
5642 if (val != error_mark_node)
5644 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val))
5645 val = TREE_TYPE (val);
5646 if (TREE_CODE (orig_arg) == TYPE_PACK_EXPANSION)
5647 val = make_pack_expansion (val);
5652 if (in_decl && (complain & tf_error))
5654 error ("type/value mismatch at argument %d in "
5655 "template parameter list for %qD",
5657 error (" expected a template of type %qD, got %qT",
5661 val = error_mark_node;
5667 /* We only form one instance of each template specialization.
5668 Therefore, if we use a non-canonical variant (i.e., a
5669 typedef), any future messages referring to the type will use
5670 the typedef, which is confusing if those future uses do not
5671 themselves also use the typedef. */
5673 val = strip_typedefs (val);
5677 tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl);
5679 if (invalid_nontype_parm_type_p (t, complain))
5680 return error_mark_node;
5682 if (template_parameter_pack_p (parm) && ARGUMENT_PACK_P (orig_arg))
5684 if (same_type_p (t, TREE_TYPE (orig_arg)))
5688 /* Not sure if this is reachable, but it doesn't hurt
5690 error ("type mismatch in nontype parameter pack");
5691 val = error_mark_node;
5694 else if (!uses_template_parms (orig_arg) && !uses_template_parms (t))
5695 /* We used to call digest_init here. However, digest_init
5696 will report errors, which we don't want when complain
5697 is zero. More importantly, digest_init will try too
5698 hard to convert things: for example, `0' should not be
5699 converted to pointer type at this point according to
5700 the standard. Accepting this is not merely an
5701 extension, since deciding whether or not these
5702 conversions can occur is part of determining which
5703 function template to call, or whether a given explicit
5704 argument specification is valid. */
5705 val = convert_nontype_argument (t, orig_arg);
5709 if (val == NULL_TREE)
5710 val = error_mark_node;
5711 else if (val == error_mark_node && (complain & tf_error))
5712 error ("could not convert template argument %qE to %qT", orig_arg, t);
5714 if (TREE_CODE (val) == SCOPE_REF)
5716 /* Strip typedefs from the SCOPE_REF. */
5717 tree type = strip_typedefs (TREE_TYPE (val));
5718 tree scope = strip_typedefs (TREE_OPERAND (val, 0));
5719 val = build_qualified_name (type, scope, TREE_OPERAND (val, 1),
5720 QUALIFIED_NAME_IS_TEMPLATE (val));
5727 /* Coerces the remaining template arguments in INNER_ARGS (from
5728 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
5729 Returns the coerced argument pack. PARM_IDX is the position of this
5730 parameter in the template parameter list. ARGS is the original
5731 template argument list. */
5733 coerce_template_parameter_pack (tree parms,
5741 tsubst_flags_t complain)
5743 tree parm = TREE_VEC_ELT (parms, parm_idx);
5744 int nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
5747 tree packed_types = NULL_TREE;
5749 if (arg_idx > nargs)
5752 packed_args = make_tree_vec (nargs - arg_idx);
5754 if (TREE_CODE (TREE_VALUE (parm)) == PARM_DECL
5755 && uses_parameter_packs (TREE_TYPE (TREE_VALUE (parm))))
5757 /* When the template parameter is a non-type template
5758 parameter pack whose type uses parameter packs, we need
5759 to look at each of the template arguments
5760 separately. Build a vector of the types for these
5761 non-type template parameters in PACKED_TYPES. */
5763 = make_pack_expansion (TREE_TYPE (TREE_VALUE (parm)));
5764 packed_types = tsubst_pack_expansion (expansion, args,
5767 if (packed_types == error_mark_node)
5768 return error_mark_node;
5770 /* Check that we have the right number of arguments. */
5772 && !PACK_EXPANSION_P (TREE_VEC_ELT (inner_args, arg_idx))
5773 && nargs - arg_idx != TREE_VEC_LENGTH (packed_types))
5776 = TREE_VEC_LENGTH (parms) - 1 + TREE_VEC_LENGTH (packed_types);
5777 error ("wrong number of template arguments (%d, should be %d)",
5778 nargs, needed_parms);
5779 return error_mark_node;
5782 /* If we aren't able to check the actual arguments now
5783 (because they haven't been expanded yet), we can at least
5784 verify that all of the types used for the non-type
5785 template parameter pack are, in fact, valid for non-type
5786 template parameters. */
5788 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args, arg_idx)))
5790 int j, len = TREE_VEC_LENGTH (packed_types);
5791 for (j = 0; j < len; ++j)
5793 tree t = TREE_VEC_ELT (packed_types, j);
5794 if (invalid_nontype_parm_type_p (t, complain))
5795 return error_mark_node;
5800 /* Convert the remaining arguments, which will be a part of the
5801 parameter pack "parm". */
5802 for (; arg_idx < nargs; ++arg_idx)
5804 tree arg = TREE_VEC_ELT (inner_args, arg_idx);
5805 tree actual_parm = TREE_VALUE (parm);
5807 if (packed_types && !PACK_EXPANSION_P (arg))
5809 /* When we have a vector of types (corresponding to the
5810 non-type template parameter pack that uses parameter
5811 packs in its type, as mention above), and the
5812 argument is not an expansion (which expands to a
5813 currently unknown number of arguments), clone the
5814 parm and give it the next type in PACKED_TYPES. */
5815 actual_parm = copy_node (actual_parm);
5816 TREE_TYPE (actual_parm) =
5817 TREE_VEC_ELT (packed_types, arg_idx - parm_idx);
5820 if (arg != error_mark_node)
5821 arg = convert_template_argument (actual_parm,
5822 arg, new_args, complain, parm_idx,
5824 if (arg == error_mark_node)
5826 TREE_VEC_ELT (packed_args, arg_idx - parm_idx) = arg;
5829 if (TREE_CODE (TREE_VALUE (parm)) == TYPE_DECL
5830 || TREE_CODE (TREE_VALUE (parm)) == TEMPLATE_DECL)
5831 argument_pack = cxx_make_type (TYPE_ARGUMENT_PACK);
5834 argument_pack = make_node (NONTYPE_ARGUMENT_PACK);
5835 TREE_TYPE (argument_pack)
5836 = tsubst (TREE_TYPE (TREE_VALUE (parm)), new_args, complain, in_decl);
5837 TREE_CONSTANT (argument_pack) = 1;
5840 SET_ARGUMENT_PACK_ARGS (argument_pack, packed_args);
5841 #ifdef ENABLE_CHECKING
5842 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args,
5843 TREE_VEC_LENGTH (packed_args));
5845 return argument_pack;
5848 /* Convert all template arguments to their appropriate types, and
5849 return a vector containing the innermost resulting template
5850 arguments. If any error occurs, return error_mark_node. Error and
5851 warning messages are issued under control of COMPLAIN.
5853 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
5854 for arguments not specified in ARGS. Otherwise, if
5855 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
5856 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
5857 USE_DEFAULT_ARGS is false, then all arguments must be specified in
5861 coerce_template_parms (tree parms,
5864 tsubst_flags_t complain,
5865 bool require_all_args,
5866 bool use_default_args)
5868 int nparms, nargs, parm_idx, arg_idx, lost = 0;
5871 tree new_inner_args;
5872 int saved_unevaluated_operand;
5873 int saved_inhibit_evaluation_warnings;
5875 /* When used as a boolean value, indicates whether this is a
5876 variadic template parameter list. Since it's an int, we can also
5877 subtract it from nparms to get the number of non-variadic
5881 nparms = TREE_VEC_LENGTH (parms);
5883 /* Determine if there are any parameter packs. */
5884 for (parm_idx = 0; parm_idx < nparms; ++parm_idx)
5886 tree tparm = TREE_VALUE (TREE_VEC_ELT (parms, parm_idx));
5887 if (template_parameter_pack_p (tparm))
5891 inner_args = INNERMOST_TEMPLATE_ARGS (args);
5892 /* If there are 0 or 1 parameter packs, we need to expand any argument
5893 packs so that we can deduce a parameter pack from some non-packed args
5894 followed by an argument pack, as in variadic85.C. If there are more
5895 than that, we need to leave argument packs intact so the arguments are
5896 assigned to the right parameter packs. This should only happen when
5897 dealing with a nested class inside a partial specialization of a class
5898 template, as in variadic92.C. */
5899 if (variadic_p <= 1)
5900 inner_args = expand_template_argument_pack (inner_args);
5902 nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
5903 if ((nargs > nparms && !variadic_p)
5904 || (nargs < nparms - variadic_p
5906 && (!use_default_args
5907 || (TREE_VEC_ELT (parms, nargs) != error_mark_node
5908 && !TREE_PURPOSE (TREE_VEC_ELT (parms, nargs))))))
5910 if (complain & tf_error)
5912 const char *or_more = "";
5915 or_more = " or more";
5919 error ("wrong number of template arguments (%d, should be %d%s)",
5920 nargs, nparms, or_more);
5923 error ("provided for %q+D", in_decl);
5926 return error_mark_node;
5929 /* We need to evaluate the template arguments, even though this
5930 template-id may be nested within a "sizeof". */
5931 saved_unevaluated_operand = cp_unevaluated_operand;
5932 cp_unevaluated_operand = 0;
5933 saved_inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
5934 c_inhibit_evaluation_warnings = 0;
5935 new_inner_args = make_tree_vec (nparms);
5936 new_args = add_outermost_template_args (args, new_inner_args);
5937 for (parm_idx = 0, arg_idx = 0; parm_idx < nparms; parm_idx++, arg_idx++)
5942 /* Get the Ith template parameter. */
5943 parm = TREE_VEC_ELT (parms, parm_idx);
5945 if (parm == error_mark_node)
5947 TREE_VEC_ELT (new_inner_args, arg_idx) = error_mark_node;
5951 /* Calculate the next argument. */
5952 if (arg_idx < nargs)
5953 arg = TREE_VEC_ELT (inner_args, arg_idx);
5957 if (template_parameter_pack_p (TREE_VALUE (parm))
5958 && !(arg && ARGUMENT_PACK_P (arg)))
5960 /* All remaining arguments will be placed in the
5961 template parameter pack PARM. */
5962 arg = coerce_template_parameter_pack (parms, parm_idx, args,
5963 inner_args, arg_idx,
5967 /* Store this argument. */
5968 if (arg == error_mark_node)
5970 TREE_VEC_ELT (new_inner_args, parm_idx) = arg;
5972 /* We are done with all of the arguments. */
5979 if (PACK_EXPANSION_P (arg))
5981 if (complain & tf_error)
5983 /* FIXME this restriction was removed by N2555; see
5985 /* If ARG is a pack expansion, but PARM is not a
5986 template parameter pack (if it were, we would have
5987 handled it above), we're trying to expand into a
5988 fixed-length argument list. */
5989 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
5990 sorry ("cannot expand %<%E%> into a fixed-length "
5991 "argument list", arg);
5993 sorry ("cannot expand %<%T%> into a fixed-length "
5994 "argument list", arg);
5996 return error_mark_node;
5999 else if (require_all_args)
6001 /* There must be a default arg in this case. */
6002 arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
6004 /* The position of the first default template argument,
6005 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
6007 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args))
6008 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args, arg_idx);
6013 if (arg == error_mark_node)
6015 if (complain & tf_error)
6016 error ("template argument %d is invalid", arg_idx + 1);
6019 /* This only occurs if there was an error in the template
6020 parameter list itself (which we would already have
6021 reported) that we are trying to recover from, e.g., a class
6022 template with a parameter list such as
6023 template<typename..., typename>. */
6024 return error_mark_node;
6026 arg = convert_template_argument (TREE_VALUE (parm),
6027 arg, new_args, complain,
6030 if (arg == error_mark_node)
6032 TREE_VEC_ELT (new_inner_args, arg_idx) = arg;
6034 cp_unevaluated_operand = saved_unevaluated_operand;
6035 c_inhibit_evaluation_warnings = saved_inhibit_evaluation_warnings;
6038 return error_mark_node;
6040 #ifdef ENABLE_CHECKING
6041 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args))
6042 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args,
6043 TREE_VEC_LENGTH (new_inner_args));
6046 return new_inner_args;
6049 /* Returns 1 if template args OT and NT are equivalent. */
6052 template_args_equal (tree ot, tree nt)
6057 if (TREE_CODE (nt) == TREE_VEC)
6058 /* For member templates */
6059 return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt);
6060 else if (PACK_EXPANSION_P (ot))
6061 return PACK_EXPANSION_P (nt)
6062 && template_args_equal (PACK_EXPANSION_PATTERN (ot),
6063 PACK_EXPANSION_PATTERN (nt));
6064 else if (ARGUMENT_PACK_P (ot))
6069 if (!ARGUMENT_PACK_P (nt))
6072 opack = ARGUMENT_PACK_ARGS (ot);
6073 npack = ARGUMENT_PACK_ARGS (nt);
6074 len = TREE_VEC_LENGTH (opack);
6075 if (TREE_VEC_LENGTH (npack) != len)
6077 for (i = 0; i < len; ++i)
6078 if (!template_args_equal (TREE_VEC_ELT (opack, i),
6079 TREE_VEC_ELT (npack, i)))
6083 else if (ot && TREE_CODE (ot) == ARGUMENT_PACK_SELECT)
6085 /* We get here probably because we are in the middle of substituting
6086 into the pattern of a pack expansion. In that case the
6087 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
6088 interested in. So we want to use the initial pack argument for
6090 ot = ARGUMENT_PACK_SELECT_FROM_PACK (ot);
6091 if (nt && TREE_CODE (nt) == ARGUMENT_PACK_SELECT)
6092 nt = ARGUMENT_PACK_SELECT_FROM_PACK (nt);
6093 return template_args_equal (ot, nt);
6095 else if (TYPE_P (nt))
6096 return TYPE_P (ot) && same_type_p (ot, nt);
6097 else if (TREE_CODE (ot) == TREE_VEC || TYPE_P (ot))
6100 return cp_tree_equal (ot, nt);
6103 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
6104 of template arguments. Returns 0 otherwise. */
6107 comp_template_args (tree oldargs, tree newargs)
6111 if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
6114 for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
6116 tree nt = TREE_VEC_ELT (newargs, i);
6117 tree ot = TREE_VEC_ELT (oldargs, i);
6119 if (! template_args_equal (ot, nt))
6126 add_pending_template (tree d)
6128 tree ti = (TYPE_P (d)
6129 ? CLASSTYPE_TEMPLATE_INFO (d)
6130 : DECL_TEMPLATE_INFO (d));
6131 struct pending_template *pt;
6134 if (TI_PENDING_TEMPLATE_FLAG (ti))
6137 /* We are called both from instantiate_decl, where we've already had a
6138 tinst_level pushed, and instantiate_template, where we haven't.
6140 level = !current_tinst_level || current_tinst_level->decl != d;
6143 push_tinst_level (d);
6145 pt = GGC_NEW (struct pending_template);
6147 pt->tinst = current_tinst_level;
6148 if (last_pending_template)
6149 last_pending_template->next = pt;
6151 pending_templates = pt;
6153 last_pending_template = pt;
6155 TI_PENDING_TEMPLATE_FLAG (ti) = 1;
6162 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
6163 ARGLIST. Valid choices for FNS are given in the cp-tree.def
6164 documentation for TEMPLATE_ID_EXPR. */
6167 lookup_template_function (tree fns, tree arglist)
6171 if (fns == error_mark_node || arglist == error_mark_node)
6172 return error_mark_node;
6174 gcc_assert (!arglist || TREE_CODE (arglist) == TREE_VEC);
6175 gcc_assert (fns && (is_overloaded_fn (fns)
6176 || TREE_CODE (fns) == IDENTIFIER_NODE));
6178 if (BASELINK_P (fns))
6180 BASELINK_FUNCTIONS (fns) = build2 (TEMPLATE_ID_EXPR,
6182 BASELINK_FUNCTIONS (fns),
6187 type = TREE_TYPE (fns);
6188 if (TREE_CODE (fns) == OVERLOAD || !type)
6189 type = unknown_type_node;
6191 return build2 (TEMPLATE_ID_EXPR, type, fns, arglist);
6194 /* Within the scope of a template class S<T>, the name S gets bound
6195 (in build_self_reference) to a TYPE_DECL for the class, not a
6196 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
6197 or one of its enclosing classes, and that type is a template,
6198 return the associated TEMPLATE_DECL. Otherwise, the original
6201 Also handle the case when DECL is a TREE_LIST of ambiguous
6202 injected-class-names from different bases. */
6205 maybe_get_template_decl_from_type_decl (tree decl)
6207 if (decl == NULL_TREE)
6210 /* DR 176: A lookup that finds an injected-class-name (10.2
6211 [class.member.lookup]) can result in an ambiguity in certain cases
6212 (for example, if it is found in more than one base class). If all of
6213 the injected-class-names that are found refer to specializations of
6214 the same class template, and if the name is followed by a
6215 template-argument-list, the reference refers to the class template
6216 itself and not a specialization thereof, and is not ambiguous. */
6217 if (TREE_CODE (decl) == TREE_LIST)
6219 tree t, tmpl = NULL_TREE;
6220 for (t = decl; t; t = TREE_CHAIN (t))
6222 tree elt = maybe_get_template_decl_from_type_decl (TREE_VALUE (t));
6225 else if (tmpl != elt)
6228 if (tmpl && t == NULL_TREE)
6234 return (decl != NULL_TREE
6235 && DECL_SELF_REFERENCE_P (decl)
6236 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
6237 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl;
6240 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
6241 parameters, find the desired type.
6243 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
6245 IN_DECL, if non-NULL, is the template declaration we are trying to
6248 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
6249 the class we are looking up.
6251 Issue error and warning messages under control of COMPLAIN.
6253 If the template class is really a local class in a template
6254 function, then the FUNCTION_CONTEXT is the function in which it is
6257 ??? Note that this function is currently called *twice* for each
6258 template-id: the first time from the parser, while creating the
6259 incomplete type (finish_template_type), and the second type during the
6260 real instantiation (instantiate_template_class). This is surely something
6261 that we want to avoid. It also causes some problems with argument
6262 coercion (see convert_nontype_argument for more information on this). */
6265 lookup_template_class (tree d1,
6270 tsubst_flags_t complain)
6272 tree templ = NULL_TREE, parmlist;
6279 timevar_push (TV_NAME_LOOKUP);
6281 if (TREE_CODE (d1) == IDENTIFIER_NODE)
6283 tree value = innermost_non_namespace_value (d1);
6284 if (value && DECL_TEMPLATE_TEMPLATE_PARM_P (value))
6289 push_decl_namespace (context);
6290 templ = lookup_name (d1);
6291 templ = maybe_get_template_decl_from_type_decl (templ);
6293 pop_decl_namespace ();
6296 context = DECL_CONTEXT (templ);
6298 else if (TREE_CODE (d1) == TYPE_DECL && MAYBE_CLASS_TYPE_P (TREE_TYPE (d1)))
6300 tree type = TREE_TYPE (d1);
6302 /* If we are declaring a constructor, say A<T>::A<T>, we will get
6303 an implicit typename for the second A. Deal with it. */
6304 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
6305 type = TREE_TYPE (type);
6307 if (CLASSTYPE_TEMPLATE_INFO (type))
6309 templ = CLASSTYPE_TI_TEMPLATE (type);
6310 d1 = DECL_NAME (templ);
6313 else if (TREE_CODE (d1) == ENUMERAL_TYPE
6314 || (TYPE_P (d1) && MAYBE_CLASS_TYPE_P (d1)))
6316 templ = TYPE_TI_TEMPLATE (d1);
6317 d1 = DECL_NAME (templ);
6319 else if (TREE_CODE (d1) == TEMPLATE_DECL
6320 && DECL_TEMPLATE_RESULT (d1)
6321 && TREE_CODE (DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL)
6324 d1 = DECL_NAME (templ);
6325 context = DECL_CONTEXT (templ);
6328 /* Issue an error message if we didn't find a template. */
6331 if (complain & tf_error)
6332 error ("%qT is not a template", d1);
6333 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
6336 if (TREE_CODE (templ) != TEMPLATE_DECL
6337 /* Make sure it's a user visible template, if it was named by
6339 || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (templ)
6340 && !PRIMARY_TEMPLATE_P (templ)))
6342 if (complain & tf_error)
6344 error ("non-template type %qT used as a template", d1);
6346 error ("for template declaration %q+D", in_decl);
6348 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
6351 complain &= ~tf_user;
6353 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ))
6355 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
6356 template arguments */
6362 parmlist = DECL_INNERMOST_TEMPLATE_PARMS (templ);
6364 /* Consider an example where a template template parameter declared as
6366 template <class T, class U = std::allocator<T> > class TT
6368 The template parameter level of T and U are one level larger than
6369 of TT. To proper process the default argument of U, say when an
6370 instantiation `TT<int>' is seen, we need to build the full
6371 arguments containing {int} as the innermost level. Outer levels,
6372 available when not appearing as default template argument, can be
6373 obtained from the arguments of the enclosing template.
6375 Suppose that TT is later substituted with std::vector. The above
6376 instantiation is `TT<int, std::allocator<T> >' with TT at
6377 level 1, and T at level 2, while the template arguments at level 1
6378 becomes {std::vector} and the inner level 2 is {int}. */
6380 outer = DECL_CONTEXT (templ);
6382 outer = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer)));
6383 else if (current_template_parms)
6384 /* This is an argument of the current template, so we haven't set
6385 DECL_CONTEXT yet. */
6386 outer = current_template_args ();
6389 arglist = add_to_template_args (outer, arglist);
6391 arglist2 = coerce_template_parms (parmlist, arglist, templ,
6393 /*require_all_args=*/true,
6394 /*use_default_args=*/true);
6395 if (arglist2 == error_mark_node
6396 || (!uses_template_parms (arglist2)
6397 && check_instantiated_args (templ, arglist2, complain)))
6398 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
6400 parm = bind_template_template_parm (TREE_TYPE (templ), arglist2);
6401 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, parm);
6405 tree template_type = TREE_TYPE (templ);
6408 tree found = NULL_TREE;
6411 int is_dependent_type;
6412 int use_partial_inst_tmpl = false;
6414 gen_tmpl = most_general_template (templ);
6415 parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
6416 parm_depth = TMPL_PARMS_DEPTH (parmlist);
6417 arg_depth = TMPL_ARGS_DEPTH (arglist);
6419 if (arg_depth == 1 && parm_depth > 1)
6421 /* We've been given an incomplete set of template arguments.
6424 template <class T> struct S1 {
6425 template <class U> struct S2 {};
6426 template <class U> struct S2<U*> {};
6429 we will be called with an ARGLIST of `U*', but the
6430 TEMPLATE will be `template <class T> template
6431 <class U> struct S1<T>::S2'. We must fill in the missing
6434 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (templ)),
6436 arg_depth = TMPL_ARGS_DEPTH (arglist);
6439 /* Now we should have enough arguments. */
6440 gcc_assert (parm_depth == arg_depth);
6442 /* From here on, we're only interested in the most general
6445 /* Calculate the BOUND_ARGS. These will be the args that are
6446 actually tsubst'd into the definition to create the
6450 /* We have multiple levels of arguments to coerce, at once. */
6452 int saved_depth = TMPL_ARGS_DEPTH (arglist);
6454 tree bound_args = make_tree_vec (parm_depth);
6456 for (i = saved_depth,
6457 t = DECL_TEMPLATE_PARMS (gen_tmpl);
6458 i > 0 && t != NULL_TREE;
6459 --i, t = TREE_CHAIN (t))
6461 tree a = coerce_template_parms (TREE_VALUE (t),
6464 /*require_all_args=*/true,
6465 /*use_default_args=*/true);
6467 /* Don't process further if one of the levels fails. */
6468 if (a == error_mark_node)
6470 /* Restore the ARGLIST to its full size. */
6471 TREE_VEC_LENGTH (arglist) = saved_depth;
6472 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
6475 SET_TMPL_ARGS_LEVEL (bound_args, i, a);
6477 /* We temporarily reduce the length of the ARGLIST so
6478 that coerce_template_parms will see only the arguments
6479 corresponding to the template parameters it is
6481 TREE_VEC_LENGTH (arglist)--;
6484 /* Restore the ARGLIST to its full size. */
6485 TREE_VEC_LENGTH (arglist) = saved_depth;
6487 arglist = bound_args;
6491 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist),
6492 INNERMOST_TEMPLATE_ARGS (arglist),
6495 /*require_all_args=*/true,
6496 /*use_default_args=*/true);
6498 if (arglist == error_mark_node)
6499 /* We were unable to bind the arguments. */
6500 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
6502 /* In the scope of a template class, explicit references to the
6503 template class refer to the type of the template, not any
6504 instantiation of it. For example, in:
6506 template <class T> class C { void f(C<T>); }
6508 the `C<T>' is just the same as `C'. Outside of the
6509 class, however, such a reference is an instantiation. */
6511 || !PRIMARY_TEMPLATE_P (gen_tmpl)
6512 || currently_open_class (template_type))
6513 /* comp_template_args is expensive, check it last. */
6514 && comp_template_args (TYPE_TI_ARGS (template_type),
6516 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, template_type);
6518 /* If we already have this specialization, return it. */
6519 elt.tmpl = gen_tmpl;
6521 hash = hash_specialization (&elt);
6522 entry = (spec_entry *) htab_find_with_hash (type_specializations,
6526 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, entry->spec);
6528 is_dependent_type = uses_template_parms (arglist);
6530 /* If the deduced arguments are invalid, then the binding
6532 if (!is_dependent_type
6533 && check_instantiated_args (gen_tmpl,
6534 INNERMOST_TEMPLATE_ARGS (arglist),
6536 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
6538 if (!is_dependent_type
6539 && !PRIMARY_TEMPLATE_P (gen_tmpl)
6540 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl))
6541 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl)) == NAMESPACE_DECL)
6543 found = xref_tag_from_type (TREE_TYPE (gen_tmpl),
6544 DECL_NAME (gen_tmpl),
6545 /*tag_scope=*/ts_global);
6546 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
6549 context = tsubst (DECL_CONTEXT (gen_tmpl), arglist,
6552 context = global_namespace;
6554 /* Create the type. */
6555 if (TREE_CODE (template_type) == ENUMERAL_TYPE)
6557 if (!is_dependent_type)
6559 set_current_access_from_decl (TYPE_NAME (template_type));
6560 t = start_enum (TYPE_IDENTIFIER (template_type),
6561 tsubst (ENUM_UNDERLYING_TYPE (template_type),
6562 arglist, complain, in_decl),
6563 SCOPED_ENUM_P (template_type));
6567 /* We don't want to call start_enum for this type, since
6568 the values for the enumeration constants may involve
6569 template parameters. And, no one should be interested
6570 in the enumeration constants for such a type. */
6571 t = cxx_make_type (ENUMERAL_TYPE);
6572 SET_SCOPED_ENUM_P (t, SCOPED_ENUM_P (template_type));
6577 t = make_class_type (TREE_CODE (template_type));
6578 CLASSTYPE_DECLARED_CLASS (t)
6579 = CLASSTYPE_DECLARED_CLASS (template_type);
6580 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
6581 TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);
6583 /* A local class. Make sure the decl gets registered properly. */
6584 if (context == current_function_decl)
6585 pushtag (DECL_NAME (gen_tmpl), t, /*tag_scope=*/ts_current);
6587 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type), arglist))
6588 /* This instantiation is another name for the primary
6589 template type. Set the TYPE_CANONICAL field
6591 TYPE_CANONICAL (t) = template_type;
6592 else if (any_template_arguments_need_structural_equality_p (arglist))
6593 /* Some of the template arguments require structural
6594 equality testing, so this template class requires
6595 structural equality testing. */
6596 SET_TYPE_STRUCTURAL_EQUALITY (t);
6599 /* If we called start_enum or pushtag above, this information
6600 will already be set up. */
6603 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
6605 type_decl = create_implicit_typedef (DECL_NAME (gen_tmpl), t);
6606 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
6607 DECL_SOURCE_LOCATION (type_decl)
6608 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type));
6611 type_decl = TYPE_NAME (t);
6613 TREE_PRIVATE (type_decl)
6614 = TREE_PRIVATE (TYPE_STUB_DECL (template_type));
6615 TREE_PROTECTED (type_decl)
6616 = TREE_PROTECTED (TYPE_STUB_DECL (template_type));
6617 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type))
6619 DECL_VISIBILITY_SPECIFIED (type_decl) = 1;
6620 DECL_VISIBILITY (type_decl) = CLASSTYPE_VISIBILITY (template_type);
6623 /* Let's consider the explicit specialization of a member
6624 of a class template specialization that is implicitely instantiated,
6629 template<class U> struct M {}; //#0
6634 struct S<int>::M<char> //#1
6638 [temp.expl.spec]/4 says this is valid.
6640 In this case, when we write:
6643 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
6646 When we encounter #1, we want to store the partial instantiation
6647 of M (template<class T> S<int>::M<T>) in it's CLASSTYPE_TI_TEMPLATE.
6649 For all cases other than this "explicit specialization of member of a
6650 class template", we just want to store the most general template into
6651 the CLASSTYPE_TI_TEMPLATE of M.
6653 This case of "explicit specialization of member of a class template"
6655 1/ the enclosing class is an instantiation of, and therefore not
6656 the same as, the context of the most general template, and
6657 2/ we aren't looking at the partial instantiation itself, i.e.
6658 the innermost arguments are not the same as the innermost parms of
6659 the most general template.
6661 So it's only when 1/ and 2/ happens that we want to use the partial
6662 instantiation of the member template in lieu of its most general
6665 if (PRIMARY_TEMPLATE_P (gen_tmpl)
6666 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist)
6667 /* the enclosing class must be an instantiation... */
6668 && CLASS_TYPE_P (context)
6669 && !same_type_p (context, DECL_CONTEXT (gen_tmpl)))
6671 tree partial_inst_args;
6672 TREE_VEC_LENGTH (arglist)--;
6673 ++processing_template_decl;
6675 tsubst (INNERMOST_TEMPLATE_ARGS
6676 (CLASSTYPE_TI_ARGS (TREE_TYPE (gen_tmpl))),
6677 arglist, complain, NULL_TREE);
6678 --processing_template_decl;
6679 TREE_VEC_LENGTH (arglist)++;
6680 use_partial_inst_tmpl =
6681 /*...and we must not be looking at the partial instantiation
6683 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist),
6687 if (!use_partial_inst_tmpl)
6688 /* This case is easy; there are no member templates involved. */
6692 /* This is a full instantiation of a member template. Find
6693 the partial instantiation of which this is an instance. */
6695 /* Temporarily reduce by one the number of levels in the ARGLIST
6696 so as to avoid comparing the last set of arguments. */
6697 TREE_VEC_LENGTH (arglist)--;
6698 found = tsubst (gen_tmpl, arglist, complain, NULL_TREE);
6699 TREE_VEC_LENGTH (arglist)++;
6700 found = CLASSTYPE_TI_TEMPLATE (found);
6703 SET_TYPE_TEMPLATE_INFO (t, build_template_info (found, arglist));
6706 slot = (spec_entry **) htab_find_slot_with_hash (type_specializations,
6707 &elt, hash, INSERT);
6708 *slot = GGC_NEW (spec_entry);
6711 /* Note this use of the partial instantiation so we can check it
6712 later in maybe_process_partial_specialization. */
6713 DECL_TEMPLATE_INSTANTIATIONS (templ)
6714 = tree_cons (arglist, t,
6715 DECL_TEMPLATE_INSTANTIATIONS (templ));
6717 if (TREE_CODE (t) == ENUMERAL_TYPE && !is_dependent_type)
6718 /* Now that the type has been registered on the instantiations
6719 list, we set up the enumerators. Because the enumeration
6720 constants may involve the enumeration type itself, we make
6721 sure to register the type first, and then create the
6722 constants. That way, doing tsubst_expr for the enumeration
6723 constants won't result in recursive calls here; we'll find
6724 the instantiation and exit above. */
6725 tsubst_enum (template_type, t, arglist);
6727 if (is_dependent_type)
6728 /* If the type makes use of template parameters, the
6729 code that generates debugging information will crash. */
6730 DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1;
6732 /* Possibly limit visibility based on template args. */
6733 TREE_PUBLIC (type_decl) = 1;
6734 determine_visibility (type_decl);
6736 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
6738 timevar_pop (TV_NAME_LOOKUP);
6745 /* True when we should also visit template parameters that occur in
6746 non-deduced contexts. */
6747 bool include_nondeduced_p;
6748 struct pointer_set_t *visited;
6751 /* Called from for_each_template_parm via walk_tree. */
6754 for_each_template_parm_r (tree *tp, int *walk_subtrees, void *d)
6757 struct pair_fn_data *pfd = (struct pair_fn_data *) d;
6758 tree_fn_t fn = pfd->fn;
6759 void *data = pfd->data;
6762 && (pfd->include_nondeduced_p || TREE_CODE (t) != TYPENAME_TYPE)
6763 && for_each_template_parm (TYPE_CONTEXT (t), fn, data, pfd->visited,
6764 pfd->include_nondeduced_p))
6765 return error_mark_node;
6767 switch (TREE_CODE (t))
6770 if (TYPE_PTRMEMFUNC_P (t))
6776 if (!TYPE_TEMPLATE_INFO (t))
6778 else if (for_each_template_parm (TI_ARGS (TYPE_TEMPLATE_INFO (t)),
6779 fn, data, pfd->visited,
6780 pfd->include_nondeduced_p))
6781 return error_mark_node;
6785 if (for_each_template_parm (TYPE_MIN_VALUE (t),
6786 fn, data, pfd->visited,
6787 pfd->include_nondeduced_p)
6788 || for_each_template_parm (TYPE_MAX_VALUE (t),
6789 fn, data, pfd->visited,
6790 pfd->include_nondeduced_p))
6791 return error_mark_node;
6795 /* Since we're not going to walk subtrees, we have to do this
6797 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data,
6798 pfd->visited, pfd->include_nondeduced_p))
6799 return error_mark_node;
6803 /* Check the return type. */
6804 if (for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited,
6805 pfd->include_nondeduced_p))
6806 return error_mark_node;
6808 /* Check the parameter types. Since default arguments are not
6809 instantiated until they are needed, the TYPE_ARG_TYPES may
6810 contain expressions that involve template parameters. But,
6811 no-one should be looking at them yet. And, once they're
6812 instantiated, they don't contain template parameters, so
6813 there's no point in looking at them then, either. */
6817 for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm))
6818 if (for_each_template_parm (TREE_VALUE (parm), fn, data,
6819 pfd->visited, pfd->include_nondeduced_p))
6820 return error_mark_node;
6822 /* Since we've already handled the TYPE_ARG_TYPES, we don't
6823 want walk_tree walking into them itself. */
6829 if (pfd->include_nondeduced_p
6830 && for_each_template_parm (TYPE_FIELDS (t), fn, data,
6832 pfd->include_nondeduced_p))
6833 return error_mark_node;
6838 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
6839 && for_each_template_parm (DECL_TI_ARGS (t), fn, data,
6840 pfd->visited, pfd->include_nondeduced_p))
6841 return error_mark_node;
6846 if (TREE_CODE (t) == CONST_DECL && DECL_TEMPLATE_PARM_P (t)
6847 && for_each_template_parm (DECL_INITIAL (t), fn, data,
6848 pfd->visited, pfd->include_nondeduced_p))
6849 return error_mark_node;
6850 if (DECL_CONTEXT (t)
6851 && pfd->include_nondeduced_p
6852 && for_each_template_parm (DECL_CONTEXT (t), fn, data,
6853 pfd->visited, pfd->include_nondeduced_p))
6854 return error_mark_node;
6857 case BOUND_TEMPLATE_TEMPLATE_PARM:
6858 /* Record template parameters such as `T' inside `TT<T>'. */
6859 if (for_each_template_parm (TYPE_TI_ARGS (t), fn, data, pfd->visited,
6860 pfd->include_nondeduced_p))
6861 return error_mark_node;
6864 case TEMPLATE_TEMPLATE_PARM:
6865 case TEMPLATE_TYPE_PARM:
6866 case TEMPLATE_PARM_INDEX:
6867 if (fn && (*fn)(t, data))
6868 return error_mark_node;
6870 return error_mark_node;
6874 /* A template template parameter is encountered. */
6875 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)
6876 && for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited,
6877 pfd->include_nondeduced_p))
6878 return error_mark_node;
6880 /* Already substituted template template parameter */
6886 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t), fn,
6888 pfd->include_nondeduced_p))
6889 return error_mark_node;
6893 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))
6894 && pfd->include_nondeduced_p
6895 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
6896 (TREE_TYPE (t)), fn, data,
6897 pfd->visited, pfd->include_nondeduced_p))
6898 return error_mark_node;
6903 /* If there's no type, then this thing must be some expression
6904 involving template parameters. */
6905 if (!fn && !TREE_TYPE (t))
6906 return error_mark_node;
6911 case REINTERPRET_CAST_EXPR:
6912 case CONST_CAST_EXPR:
6913 case STATIC_CAST_EXPR:
6914 case DYNAMIC_CAST_EXPR:
6918 case PSEUDO_DTOR_EXPR:
6920 return error_mark_node;
6927 /* We didn't find any template parameters we liked. */
6931 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
6932 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
6933 call FN with the parameter and the DATA.
6934 If FN returns nonzero, the iteration is terminated, and
6935 for_each_template_parm returns 1. Otherwise, the iteration
6936 continues. If FN never returns a nonzero value, the value
6937 returned by for_each_template_parm is 0. If FN is NULL, it is
6938 considered to be the function which always returns 1.
6940 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
6941 parameters that occur in non-deduced contexts. When false, only
6942 visits those template parameters that can be deduced. */
6945 for_each_template_parm (tree t, tree_fn_t fn, void* data,
6946 struct pointer_set_t *visited,
6947 bool include_nondeduced_p)
6949 struct pair_fn_data pfd;
6955 pfd.include_nondeduced_p = include_nondeduced_p;
6957 /* Walk the tree. (Conceptually, we would like to walk without
6958 duplicates, but for_each_template_parm_r recursively calls
6959 for_each_template_parm, so we would need to reorganize a fair
6960 bit to use walk_tree_without_duplicates, so we keep our own
6963 pfd.visited = visited;
6965 pfd.visited = pointer_set_create ();
6966 result = cp_walk_tree (&t,
6967 for_each_template_parm_r,
6969 pfd.visited) != NULL_TREE;
6974 pointer_set_destroy (pfd.visited);
6981 /* Returns true if T depends on any template parameter. */
6984 uses_template_parms (tree t)
6987 int saved_processing_template_decl;
6989 saved_processing_template_decl = processing_template_decl;
6990 if (!saved_processing_template_decl)
6991 processing_template_decl = 1;
6993 dependent_p = dependent_type_p (t);
6994 else if (TREE_CODE (t) == TREE_VEC)
6995 dependent_p = any_dependent_template_arguments_p (t);
6996 else if (TREE_CODE (t) == TREE_LIST)
6997 dependent_p = (uses_template_parms (TREE_VALUE (t))
6998 || uses_template_parms (TREE_CHAIN (t)));
6999 else if (TREE_CODE (t) == TYPE_DECL)
7000 dependent_p = dependent_type_p (TREE_TYPE (t));
7003 || TREE_CODE (t) == TEMPLATE_PARM_INDEX
7004 || TREE_CODE (t) == OVERLOAD
7005 || TREE_CODE (t) == BASELINK
7006 || TREE_CODE (t) == IDENTIFIER_NODE
7007 || TREE_CODE (t) == TRAIT_EXPR
7008 || TREE_CODE (t) == CONSTRUCTOR
7009 || CONSTANT_CLASS_P (t))
7010 dependent_p = (type_dependent_expression_p (t)
7011 || value_dependent_expression_p (t));
7014 gcc_assert (t == error_mark_node);
7015 dependent_p = false;
7018 processing_template_decl = saved_processing_template_decl;
7023 /* Returns true if T depends on any template parameter with level LEVEL. */
7026 uses_template_parms_level (tree t, int level)
7028 return for_each_template_parm (t, template_parm_this_level_p, &level, NULL,
7029 /*include_nondeduced_p=*/true);
7032 static int tinst_depth;
7033 extern int max_tinst_depth;
7034 #ifdef GATHER_STATISTICS
7037 static int tinst_level_tick;
7038 static int last_template_error_tick;
7040 /* We're starting to instantiate D; record the template instantiation context
7041 for diagnostics and to restore it later. */
7044 push_tinst_level (tree d)
7046 struct tinst_level *new_level;
7048 if (tinst_depth >= max_tinst_depth)
7050 /* If the instantiation in question still has unbound template parms,
7051 we don't really care if we can't instantiate it, so just return.
7052 This happens with base instantiation for implicit `typename'. */
7053 if (uses_template_parms (d))
7056 last_template_error_tick = tinst_level_tick;
7057 error ("template instantiation depth exceeds maximum of %d (use "
7058 "-ftemplate-depth= to increase the maximum) instantiating %qD",
7059 max_tinst_depth, d);
7061 print_instantiation_context ();
7066 new_level = GGC_NEW (struct tinst_level);
7067 new_level->decl = d;
7068 new_level->locus = input_location;
7069 new_level->in_system_header_p = in_system_header;
7070 new_level->next = current_tinst_level;
7071 current_tinst_level = new_level;
7074 #ifdef GATHER_STATISTICS
7075 if (tinst_depth > depth_reached)
7076 depth_reached = tinst_depth;
7083 /* We're done instantiating this template; return to the instantiation
7087 pop_tinst_level (void)
7089 /* Restore the filename and line number stashed away when we started
7090 this instantiation. */
7091 input_location = current_tinst_level->locus;
7092 current_tinst_level = current_tinst_level->next;
7097 /* We're instantiating a deferred template; restore the template
7098 instantiation context in which the instantiation was requested, which
7099 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
7102 reopen_tinst_level (struct tinst_level *level)
7104 struct tinst_level *t;
7107 for (t = level; t; t = t->next)
7110 current_tinst_level = level;
7115 /* Returns the TINST_LEVEL which gives the original instantiation
7118 struct tinst_level *
7119 outermost_tinst_level (void)
7121 struct tinst_level *level = current_tinst_level;
7124 level = level->next;
7128 /* Returns TRUE if PARM is a parameter of the template TEMPL. */
7131 parameter_of_template_p (tree parm, tree templ)
7136 if (!parm || !templ)
7139 gcc_assert (DECL_TEMPLATE_PARM_P (parm));
7140 gcc_assert (TREE_CODE (templ) == TEMPLATE_DECL);
7142 parms = DECL_TEMPLATE_PARMS (templ);
7143 parms = INNERMOST_TEMPLATE_PARMS (parms);
7145 for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
7146 if (parm == TREE_VALUE (TREE_VEC_ELT (parms, i)))
7152 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
7153 vector of template arguments, as for tsubst.
7155 Returns an appropriate tsubst'd friend declaration. */
7158 tsubst_friend_function (tree decl, tree args)
7162 if (TREE_CODE (decl) == FUNCTION_DECL
7163 && DECL_TEMPLATE_INSTANTIATION (decl)
7164 && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
7165 /* This was a friend declared with an explicit template
7166 argument list, e.g.:
7170 to indicate that f was a template instantiation, not a new
7171 function declaration. Now, we have to figure out what
7172 instantiation of what template. */
7174 tree template_id, arglist, fns;
7177 tree ns = decl_namespace_context (TYPE_MAIN_DECL (current_class_type));
7179 /* Friend functions are looked up in the containing namespace scope.
7180 We must enter that scope, to avoid finding member functions of the
7181 current class with same name. */
7182 push_nested_namespace (ns);
7183 fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args,
7184 tf_warning_or_error, NULL_TREE,
7185 /*integral_constant_expression_p=*/false);
7186 pop_nested_namespace (ns);
7187 arglist = tsubst (DECL_TI_ARGS (decl), args,
7188 tf_warning_or_error, NULL_TREE);
7189 template_id = lookup_template_function (fns, arglist);
7191 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
7192 tmpl = determine_specialization (template_id, new_friend,
7194 /*need_member_template=*/0,
7195 TREE_VEC_LENGTH (args),
7197 return instantiate_template (tmpl, new_args, tf_error);
7200 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
7202 /* The NEW_FRIEND will look like an instantiation, to the
7203 compiler, but is not an instantiation from the point of view of
7204 the language. For example, we might have had:
7206 template <class T> struct S {
7207 template <class U> friend void f(T, U);
7210 Then, in S<int>, template <class U> void f(int, U) is not an
7211 instantiation of anything. */
7212 if (new_friend == error_mark_node)
7213 return error_mark_node;
7215 DECL_USE_TEMPLATE (new_friend) = 0;
7216 if (TREE_CODE (decl) == TEMPLATE_DECL)
7218 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0;
7219 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend))
7220 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
7223 /* The mangled name for the NEW_FRIEND is incorrect. The function
7224 is not a template instantiation and should not be mangled like
7225 one. Therefore, we forget the mangling here; we'll recompute it
7226 later if we need it. */
7227 if (TREE_CODE (new_friend) != TEMPLATE_DECL)
7229 SET_DECL_RTL (new_friend, NULL_RTX);
7230 SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE);
7233 if (DECL_NAMESPACE_SCOPE_P (new_friend))
7236 tree new_friend_template_info;
7237 tree new_friend_result_template_info;
7239 int new_friend_is_defn;
7241 /* We must save some information from NEW_FRIEND before calling
7242 duplicate decls since that function will free NEW_FRIEND if
7244 new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
7245 new_friend_is_defn =
7246 (DECL_INITIAL (DECL_TEMPLATE_RESULT
7247 (template_for_substitution (new_friend)))
7249 if (TREE_CODE (new_friend) == TEMPLATE_DECL)
7251 /* This declaration is a `primary' template. */
7252 DECL_PRIMARY_TEMPLATE (new_friend) = new_friend;
7254 new_friend_result_template_info
7255 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend));
7258 new_friend_result_template_info = NULL_TREE;
7260 /* Make the init_value nonzero so pushdecl knows this is a defn. */
7261 if (new_friend_is_defn)
7262 DECL_INITIAL (new_friend) = error_mark_node;
7264 /* Inside pushdecl_namespace_level, we will push into the
7265 current namespace. However, the friend function should go
7266 into the namespace of the template. */
7267 ns = decl_namespace_context (new_friend);
7268 push_nested_namespace (ns);
7269 old_decl = pushdecl_namespace_level (new_friend, /*is_friend=*/true);
7270 pop_nested_namespace (ns);
7272 if (old_decl == error_mark_node)
7273 return error_mark_node;
7275 if (old_decl != new_friend)
7277 /* This new friend declaration matched an existing
7278 declaration. For example, given:
7280 template <class T> void f(T);
7281 template <class U> class C {
7282 template <class T> friend void f(T) {}
7285 the friend declaration actually provides the definition
7286 of `f', once C has been instantiated for some type. So,
7287 old_decl will be the out-of-class template declaration,
7288 while new_friend is the in-class definition.
7290 But, if `f' was called before this point, the
7291 instantiation of `f' will have DECL_TI_ARGS corresponding
7292 to `T' but not to `U', references to which might appear
7293 in the definition of `f'. Previously, the most general
7294 template for an instantiation of `f' was the out-of-class
7295 version; now it is the in-class version. Therefore, we
7296 run through all specialization of `f', adding to their
7297 DECL_TI_ARGS appropriately. In particular, they need a
7298 new set of outer arguments, corresponding to the
7299 arguments for this class instantiation.
7301 The same situation can arise with something like this:
7304 template <class T> class C {
7308 when `C<int>' is instantiated. Now, `f(int)' is defined
7311 if (!new_friend_is_defn)
7312 /* On the other hand, if the in-class declaration does
7313 *not* provide a definition, then we don't want to alter
7314 existing definitions. We can just leave everything
7319 tree new_template = TI_TEMPLATE (new_friend_template_info);
7320 tree new_args = TI_ARGS (new_friend_template_info);
7322 /* Overwrite whatever template info was there before, if
7323 any, with the new template information pertaining to
7325 DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
7327 if (TREE_CODE (old_decl) != TEMPLATE_DECL)
7328 /* We should have called reregister_specialization in
7330 gcc_assert (retrieve_specialization (new_template,
7337 /* Indicate that the old function template is a partial
7339 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl))
7340 = new_friend_result_template_info;
7342 gcc_assert (new_template
7343 == most_general_template (new_template));
7344 gcc_assert (new_template != old_decl);
7346 /* Reassign any specializations already in the hash table
7347 to the new more general template, and add the
7348 additional template args. */
7349 for (t = DECL_TEMPLATE_INSTANTIATIONS (old_decl);
7353 tree spec = TREE_VALUE (t);
7356 elt.tmpl = old_decl;
7357 elt.args = DECL_TI_ARGS (spec);
7358 elt.spec = NULL_TREE;
7360 htab_remove_elt (decl_specializations, &elt);
7363 = add_outermost_template_args (new_args,
7364 DECL_TI_ARGS (spec));
7366 register_specialization
7367 (spec, new_template, DECL_TI_ARGS (spec), true, 0);
7370 DECL_TEMPLATE_INSTANTIATIONS (old_decl) = NULL_TREE;
7374 /* The information from NEW_FRIEND has been merged into OLD_DECL
7375 by duplicate_decls. */
7376 new_friend = old_decl;
7381 tree context = DECL_CONTEXT (new_friend);
7385 template <class T> class C {
7386 template <class U> friend void C1<U>::f (); // case 1
7387 friend void C2<T>::f (); // case 2
7389 we only need to make sure CONTEXT is a complete type for
7390 case 2. To distinguish between the two cases, we note that
7391 CONTEXT of case 1 remains dependent type after tsubst while
7392 this isn't true for case 2. */
7393 ++processing_template_decl;
7394 dependent_p = dependent_type_p (context);
7395 --processing_template_decl;
7398 && !complete_type_or_else (context, NULL_TREE))
7399 return error_mark_node;
7401 if (COMPLETE_TYPE_P (context))
7403 /* Check to see that the declaration is really present, and,
7404 possibly obtain an improved declaration. */
7405 tree fn = check_classfn (context,
7406 new_friend, NULL_TREE);
7416 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
7417 template arguments, as for tsubst.
7419 Returns an appropriate tsubst'd friend type or error_mark_node on
7423 tsubst_friend_class (tree friend_tmpl, tree args)
7429 context = DECL_CONTEXT (friend_tmpl);
7433 if (TREE_CODE (context) == NAMESPACE_DECL)
7434 push_nested_namespace (context);
7436 push_nested_class (tsubst (context, args, tf_none, NULL_TREE));
7439 /* Look for a class template declaration. We look for hidden names
7440 because two friend declarations of the same template are the
7441 same. For example, in:
7444 template <typename> friend class F;
7446 template <typename> struct B {
7447 template <typename> friend class F;
7450 both F templates are the same. */
7451 tmpl = lookup_name_real (DECL_NAME (friend_tmpl), 0, 0,
7452 /*block_p=*/true, 0,
7453 LOOKUP_COMPLAIN | LOOKUP_HIDDEN);
7455 /* But, if we don't find one, it might be because we're in a
7456 situation like this:
7464 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
7465 for `S<int>', not the TEMPLATE_DECL. */
7466 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
7468 tmpl = lookup_name_prefer_type (DECL_NAME (friend_tmpl), 1);
7469 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
7472 if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
7474 /* The friend template has already been declared. Just
7475 check to see that the declarations match, and install any new
7476 default parameters. We must tsubst the default parameters,
7477 of course. We only need the innermost template parameters
7478 because that is all that redeclare_class_template will look
7480 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl))
7481 > TMPL_ARGS_DEPTH (args))
7484 location_t saved_input_location;
7485 parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
7486 args, tf_warning_or_error);
7488 saved_input_location = input_location;
7489 input_location = DECL_SOURCE_LOCATION (friend_tmpl);
7490 redeclare_class_template (TREE_TYPE (tmpl), parms);
7491 input_location = saved_input_location;
7495 friend_type = TREE_TYPE (tmpl);
7499 /* The friend template has not already been declared. In this
7500 case, the instantiation of the template class will cause the
7501 injection of this template into the global scope. */
7502 tmpl = tsubst (friend_tmpl, args, tf_warning_or_error, NULL_TREE);
7503 if (tmpl == error_mark_node)
7504 return error_mark_node;
7506 /* The new TMPL is not an instantiation of anything, so we
7507 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
7508 the new type because that is supposed to be the corresponding
7509 template decl, i.e., TMPL. */
7510 DECL_USE_TEMPLATE (tmpl) = 0;
7511 DECL_TEMPLATE_INFO (tmpl) = NULL_TREE;
7512 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0;
7513 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl))
7514 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)));
7516 /* Inject this template into the global scope. */
7517 friend_type = TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl, true));
7522 if (TREE_CODE (context) == NAMESPACE_DECL)
7523 pop_nested_namespace (context);
7525 pop_nested_class ();
7531 /* Returns zero if TYPE cannot be completed later due to circularity.
7532 Otherwise returns one. */
7535 can_complete_type_without_circularity (tree type)
7537 if (type == NULL_TREE || type == error_mark_node)
7539 else if (COMPLETE_TYPE_P (type))
7541 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
7542 return can_complete_type_without_circularity (TREE_TYPE (type));
7543 else if (CLASS_TYPE_P (type)
7544 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type)))
7550 /* Apply any attributes which had to be deferred until instantiation
7551 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
7552 ARGS, COMPLAIN, IN_DECL are as tsubst. */
7555 apply_late_template_attributes (tree *decl_p, tree attributes, int attr_flags,
7556 tree args, tsubst_flags_t complain, tree in_decl)
7558 tree last_dep = NULL_TREE;
7562 for (t = attributes; t; t = TREE_CHAIN (t))
7563 if (ATTR_IS_DEPENDENT (t))
7566 attributes = copy_list (attributes);
7570 if (DECL_P (*decl_p))
7572 if (TREE_TYPE (*decl_p) == error_mark_node)
7574 p = &DECL_ATTRIBUTES (*decl_p);
7577 p = &TYPE_ATTRIBUTES (*decl_p);
7581 tree late_attrs = NULL_TREE;
7582 tree *q = &late_attrs;
7584 for (*p = attributes; *p; )
7587 if (ATTR_IS_DEPENDENT (t))
7589 *p = TREE_CHAIN (t);
7590 TREE_CHAIN (t) = NULL_TREE;
7591 /* If the first attribute argument is an identifier, don't
7592 pass it through tsubst. Attributes like mode, format,
7593 cleanup and several target specific attributes expect it
7596 && TREE_CODE (TREE_VALUE (t)) == TREE_LIST
7597 && TREE_VALUE (TREE_VALUE (t))
7598 && (TREE_CODE (TREE_VALUE (TREE_VALUE (t)))
7599 == IDENTIFIER_NODE))
7602 = tsubst_expr (TREE_CHAIN (TREE_VALUE (t)), args, complain,
7604 /*integral_constant_expression_p=*/false);
7605 if (chain != TREE_CHAIN (TREE_VALUE (t)))
7607 = tree_cons (NULL_TREE, TREE_VALUE (TREE_VALUE (t)),
7612 = tsubst_expr (TREE_VALUE (t), args, complain, in_decl,
7613 /*integral_constant_expression_p=*/false);
7615 q = &TREE_CHAIN (t);
7618 p = &TREE_CHAIN (t);
7621 cplus_decl_attributes (decl_p, late_attrs, attr_flags);
7625 /* Perform (or defer) access check for typedefs that were referenced
7626 from within the template TMPL code.
7627 This is a subroutine of instantiate_template and instantiate_class_template.
7628 TMPL is the template to consider and TARGS is the list of arguments of
7632 perform_typedefs_access_check (tree tmpl, tree targs)
7634 location_t saved_location;
7636 qualified_typedef_usage_t *iter;
7639 || (!CLASS_TYPE_P (tmpl)
7640 && TREE_CODE (tmpl) != FUNCTION_DECL))
7643 saved_location = input_location;
7645 VEC_iterate (qualified_typedef_usage_t,
7646 get_types_needing_access_check (tmpl),
7650 tree type_decl = iter->typedef_decl;
7651 tree type_scope = iter->context;
7653 if (!type_decl || !type_scope || !CLASS_TYPE_P (type_scope))
7656 if (uses_template_parms (type_decl))
7657 type_decl = tsubst (type_decl, targs, tf_error, NULL_TREE);
7658 if (uses_template_parms (type_scope))
7659 type_scope = tsubst (type_scope, targs, tf_error, NULL_TREE);
7661 /* Make access check error messages point to the location
7662 of the use of the typedef. */
7663 input_location = iter->locus;
7664 perform_or_defer_access_check (TYPE_BINFO (type_scope),
7665 type_decl, type_decl);
7667 input_location = saved_location;
7671 instantiate_class_template (tree type)
7673 tree templ, args, pattern, t, member;
7677 unsigned int saved_maximum_field_alignment;
7679 if (type == error_mark_node)
7680 return error_mark_node;
7682 if (TYPE_BEING_DEFINED (type)
7683 || COMPLETE_TYPE_P (type)
7684 || uses_template_parms (type))
7687 /* Figure out which template is being instantiated. */
7688 templ = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
7689 gcc_assert (TREE_CODE (templ) == TEMPLATE_DECL);
7691 /* Determine what specialization of the original template to
7693 t = most_specialized_class (type, templ);
7694 if (t == error_mark_node)
7696 TYPE_BEING_DEFINED (type) = 1;
7697 return error_mark_node;
7701 /* This TYPE is actually an instantiation of a partial
7702 specialization. We replace the innermost set of ARGS with
7703 the arguments appropriate for substitution. For example,
7706 template <class T> struct S {};
7707 template <class T> struct S<T*> {};
7709 and supposing that we are instantiating S<int*>, ARGS will
7710 presently be {int*} -- but we need {int}. */
7711 pattern = TREE_TYPE (t);
7712 args = TREE_PURPOSE (t);
7716 pattern = TREE_TYPE (templ);
7717 args = CLASSTYPE_TI_ARGS (type);
7720 /* If the template we're instantiating is incomplete, then clearly
7721 there's nothing we can do. */
7722 if (!COMPLETE_TYPE_P (pattern))
7725 /* If we've recursively instantiated too many templates, stop. */
7726 if (! push_tinst_level (type))
7729 /* Now we're really doing the instantiation. Mark the type as in
7730 the process of being defined. */
7731 TYPE_BEING_DEFINED (type) = 1;
7733 /* We may be in the middle of deferred access check. Disable
7735 push_deferring_access_checks (dk_no_deferred);
7737 push_to_top_level ();
7738 /* Use #pragma pack from the template context. */
7739 saved_maximum_field_alignment = maximum_field_alignment;
7740 maximum_field_alignment = TYPE_PRECISION (pattern);
7742 SET_CLASSTYPE_INTERFACE_UNKNOWN (type);
7744 /* Set the input location to the most specialized template definition.
7745 This is needed if tsubsting causes an error. */
7746 typedecl = TYPE_MAIN_DECL (pattern);
7747 input_location = DECL_SOURCE_LOCATION (typedecl);
7749 TYPE_HAS_USER_CONSTRUCTOR (type) = TYPE_HAS_USER_CONSTRUCTOR (pattern);
7750 TYPE_HAS_NEW_OPERATOR (type) = TYPE_HAS_NEW_OPERATOR (pattern);
7751 TYPE_HAS_ARRAY_NEW_OPERATOR (type) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern);
7752 TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern);
7753 TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern);
7754 TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern);
7755 TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern);
7756 TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern);
7757 TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern);
7758 TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern);
7759 TYPE_PACKED (type) = TYPE_PACKED (pattern);
7760 TYPE_ALIGN (type) = TYPE_ALIGN (pattern);
7761 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);
7762 TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */
7763 if (ANON_AGGR_TYPE_P (pattern))
7764 SET_ANON_AGGR_TYPE_P (type);
7765 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern))
7767 CLASSTYPE_VISIBILITY_SPECIFIED (type) = 1;
7768 CLASSTYPE_VISIBILITY (type) = CLASSTYPE_VISIBILITY (pattern);
7771 pbinfo = TYPE_BINFO (pattern);
7773 /* We should never instantiate a nested class before its enclosing
7774 class; we need to look up the nested class by name before we can
7775 instantiate it, and that lookup should instantiate the enclosing
7777 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))
7778 || COMPLETE_TYPE_P (TYPE_CONTEXT (type))
7779 || TYPE_BEING_DEFINED (TYPE_CONTEXT (type)));
7781 base_list = NULL_TREE;
7782 if (BINFO_N_BASE_BINFOS (pbinfo))
7785 tree context = TYPE_CONTEXT (type);
7789 /* We must enter the scope containing the type, as that is where
7790 the accessibility of types named in dependent bases are
7792 pushed_scope = push_scope (context ? context : global_namespace);
7794 /* Substitute into each of the bases to determine the actual
7796 for (i = 0; BINFO_BASE_ITERATE (pbinfo, i, pbase_binfo); i++)
7799 tree access = BINFO_BASE_ACCESS (pbinfo, i);
7800 tree expanded_bases = NULL_TREE;
7803 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo)))
7806 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo),
7807 args, tf_error, NULL_TREE);
7808 if (expanded_bases == error_mark_node)
7811 len = TREE_VEC_LENGTH (expanded_bases);
7814 for (idx = 0; idx < len; idx++)
7817 /* Extract the already-expanded base class. */
7818 base = TREE_VEC_ELT (expanded_bases, idx);
7820 /* Substitute to figure out the base class. */
7821 base = tsubst (BINFO_TYPE (pbase_binfo), args, tf_error,
7824 if (base == error_mark_node)
7827 base_list = tree_cons (access, base, base_list);
7828 if (BINFO_VIRTUAL_P (pbase_binfo))
7829 TREE_TYPE (base_list) = integer_type_node;
7833 /* The list is now in reverse order; correct that. */
7834 base_list = nreverse (base_list);
7837 pop_scope (pushed_scope);
7839 /* Now call xref_basetypes to set up all the base-class
7841 xref_basetypes (type, base_list);
7843 apply_late_template_attributes (&type, TYPE_ATTRIBUTES (pattern),
7844 (int) ATTR_FLAG_TYPE_IN_PLACE,
7845 args, tf_error, NULL_TREE);
7847 /* Now that our base classes are set up, enter the scope of the
7848 class, so that name lookups into base classes, etc. will work
7849 correctly. This is precisely analogous to what we do in
7850 begin_class_definition when defining an ordinary non-template
7851 class, except we also need to push the enclosing classes. */
7852 push_nested_class (type);
7854 /* Now members are processed in the order of declaration. */
7855 for (member = CLASSTYPE_DECL_LIST (pattern);
7856 member; member = TREE_CHAIN (member))
7858 tree t = TREE_VALUE (member);
7860 if (TREE_PURPOSE (member))
7864 /* Build new CLASSTYPE_NESTED_UTDS. */
7867 bool class_template_p;
7869 class_template_p = (TREE_CODE (t) != ENUMERAL_TYPE
7870 && TYPE_LANG_SPECIFIC (t)
7871 && CLASSTYPE_IS_TEMPLATE (t));
7872 /* If the member is a class template, then -- even after
7873 substitution -- there may be dependent types in the
7874 template argument list for the class. We increment
7875 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
7876 that function will assume that no types are dependent
7877 when outside of a template. */
7878 if (class_template_p)
7879 ++processing_template_decl;
7880 newtag = tsubst (t, args, tf_error, NULL_TREE);
7881 if (class_template_p)
7882 --processing_template_decl;
7883 if (newtag == error_mark_node)
7886 if (TREE_CODE (newtag) != ENUMERAL_TYPE)
7888 tree name = TYPE_IDENTIFIER (t);
7890 if (class_template_p)
7891 /* Unfortunately, lookup_template_class sets
7892 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
7893 instantiation (i.e., for the type of a member
7894 template class nested within a template class.)
7895 This behavior is required for
7896 maybe_process_partial_specialization to work
7897 correctly, but is not accurate in this case;
7898 the TAG is not an instantiation of anything.
7899 (The corresponding TEMPLATE_DECL is an
7900 instantiation, but the TYPE is not.) */
7901 CLASSTYPE_USE_TEMPLATE (newtag) = 0;
7903 /* Now, we call pushtag to put this NEWTAG into the scope of
7904 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
7905 pushtag calling push_template_decl. We don't have to do
7906 this for enums because it will already have been done in
7909 SET_IDENTIFIER_TYPE_VALUE (name, newtag);
7910 pushtag (name, newtag, /*tag_scope=*/ts_current);
7913 else if (TREE_CODE (t) == FUNCTION_DECL
7914 || DECL_FUNCTION_TEMPLATE_P (t))
7916 /* Build new TYPE_METHODS. */
7919 if (TREE_CODE (t) == TEMPLATE_DECL)
7920 ++processing_template_decl;
7921 r = tsubst (t, args, tf_error, NULL_TREE);
7922 if (TREE_CODE (t) == TEMPLATE_DECL)
7923 --processing_template_decl;
7924 set_current_access_from_decl (r);
7925 finish_member_declaration (r);
7929 /* Build new TYPE_FIELDS. */
7930 if (TREE_CODE (t) == STATIC_ASSERT)
7933 tsubst_expr (STATIC_ASSERT_CONDITION (t), args,
7934 tf_warning_or_error, NULL_TREE,
7935 /*integral_constant_expression_p=*/true);
7936 finish_static_assert (condition,
7937 STATIC_ASSERT_MESSAGE (t),
7938 STATIC_ASSERT_SOURCE_LOCATION (t),
7941 else if (TREE_CODE (t) != CONST_DECL)
7945 /* The file and line for this declaration, to
7946 assist in error message reporting. Since we
7947 called push_tinst_level above, we don't need to
7949 input_location = DECL_SOURCE_LOCATION (t);
7951 if (TREE_CODE (t) == TEMPLATE_DECL)
7952 ++processing_template_decl;
7953 r = tsubst (t, args, tf_warning_or_error, NULL_TREE);
7954 if (TREE_CODE (t) == TEMPLATE_DECL)
7955 --processing_template_decl;
7956 if (TREE_CODE (r) == VAR_DECL)
7960 [t]he initialization (and any associated
7961 side-effects) of a static data member does
7962 not occur unless the static data member is
7963 itself used in a way that requires the
7964 definition of the static data member to
7967 Therefore, we do not substitute into the
7968 initialized for the static data member here. */
7969 finish_static_data_member_decl
7972 /*init_const_expr_p=*/false,
7973 /*asmspec_tree=*/NULL_TREE,
7975 if (DECL_INITIALIZED_IN_CLASS_P (r))
7976 check_static_variable_definition (r, TREE_TYPE (r));
7978 else if (TREE_CODE (r) == FIELD_DECL)
7980 /* Determine whether R has a valid type and can be
7981 completed later. If R is invalid, then it is
7982 replaced by error_mark_node so that it will not be
7983 added to TYPE_FIELDS. */
7984 tree rtype = TREE_TYPE (r);
7985 if (can_complete_type_without_circularity (rtype))
7986 complete_type (rtype);
7988 if (!COMPLETE_TYPE_P (rtype))
7990 cxx_incomplete_type_error (r, rtype);
7991 r = error_mark_node;
7995 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
7996 such a thing will already have been added to the field
7997 list by tsubst_enum in finish_member_declaration in the
7998 CLASSTYPE_NESTED_UTDS case above. */
7999 if (!(TREE_CODE (r) == TYPE_DECL
8000 && TREE_CODE (TREE_TYPE (r)) == ENUMERAL_TYPE
8001 && DECL_ARTIFICIAL (r)))
8003 set_current_access_from_decl (r);
8004 finish_member_declaration (r);
8011 if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t))
8013 /* Build new CLASSTYPE_FRIEND_CLASSES. */
8015 tree friend_type = t;
8016 bool adjust_processing_template_decl = false;
8018 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
8020 /* template <class T> friend class C; */
8021 friend_type = tsubst_friend_class (friend_type, args);
8022 adjust_processing_template_decl = true;
8024 else if (TREE_CODE (friend_type) == UNBOUND_CLASS_TEMPLATE)
8026 /* template <class T> friend class C::D; */
8027 friend_type = tsubst (friend_type, args,
8028 tf_warning_or_error, NULL_TREE);
8029 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
8030 friend_type = TREE_TYPE (friend_type);
8031 adjust_processing_template_decl = true;
8033 else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
8035 /* This could be either
8039 when dependent_type_p is false or
8041 template <class U> friend class T::C;
8044 friend_type = tsubst (friend_type, args,
8045 tf_warning_or_error, NULL_TREE);
8046 /* Bump processing_template_decl for correct
8047 dependent_type_p calculation. */
8048 ++processing_template_decl;
8049 if (dependent_type_p (friend_type))
8050 adjust_processing_template_decl = true;
8051 --processing_template_decl;
8053 else if (!CLASSTYPE_USE_TEMPLATE (friend_type)
8054 && hidden_name_p (TYPE_NAME (friend_type)))
8058 where C hasn't been declared yet. Let's lookup name
8059 from namespace scope directly, bypassing any name that
8060 come from dependent base class. */
8061 tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type));
8063 /* The call to xref_tag_from_type does injection for friend
8065 push_nested_namespace (ns);
8067 xref_tag_from_type (friend_type, NULL_TREE,
8068 /*tag_scope=*/ts_current);
8069 pop_nested_namespace (ns);
8071 else if (uses_template_parms (friend_type))
8072 /* friend class C<T>; */
8073 friend_type = tsubst (friend_type, args,
8074 tf_warning_or_error, NULL_TREE);
8079 where C is already declared or
8081 friend class C<int>;
8083 We don't have to do anything in these cases. */
8085 if (adjust_processing_template_decl)
8086 /* Trick make_friend_class into realizing that the friend
8087 we're adding is a template, not an ordinary class. It's
8088 important that we use make_friend_class since it will
8089 perform some error-checking and output cross-reference
8091 ++processing_template_decl;
8093 if (friend_type != error_mark_node)
8094 make_friend_class (type, friend_type, /*complain=*/false);
8096 if (adjust_processing_template_decl)
8097 --processing_template_decl;
8101 /* Build new DECL_FRIENDLIST. */
8104 /* The file and line for this declaration, to
8105 assist in error message reporting. Since we
8106 called push_tinst_level above, we don't need to
8108 input_location = DECL_SOURCE_LOCATION (t);
8110 if (TREE_CODE (t) == TEMPLATE_DECL)
8112 ++processing_template_decl;
8113 push_deferring_access_checks (dk_no_check);
8116 r = tsubst_friend_function (t, args);
8117 add_friend (type, r, /*complain=*/false);
8118 if (TREE_CODE (t) == TEMPLATE_DECL)
8120 pop_deferring_access_checks ();
8121 --processing_template_decl;
8127 /* Set the file and line number information to whatever is given for
8128 the class itself. This puts error messages involving generated
8129 implicit functions at a predictable point, and the same point
8130 that would be used for non-template classes. */
8131 input_location = DECL_SOURCE_LOCATION (typedecl);
8133 unreverse_member_declarations (type);
8134 finish_struct_1 (type);
8135 TYPE_BEING_DEFINED (type) = 0;
8137 /* Now that the class is complete, instantiate default arguments for
8138 any member functions. We don't do this earlier because the
8139 default arguments may reference members of the class. */
8140 if (!PRIMARY_TEMPLATE_P (templ))
8141 for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t))
8142 if (TREE_CODE (t) == FUNCTION_DECL
8143 /* Implicitly generated member functions will not have template
8144 information; they are not instantiations, but instead are
8145 created "fresh" for each instantiation. */
8146 && DECL_TEMPLATE_INFO (t))
8147 tsubst_default_arguments (t);
8149 /* Some typedefs referenced from within the template code need to be access
8150 checked at template instantiation time, i.e now. These types were
8151 added to the template at parsing time. Let's get those and perform
8152 the access checks then. */
8153 perform_typedefs_access_check (pattern, args);
8154 perform_deferred_access_checks ();
8155 pop_nested_class ();
8156 maximum_field_alignment = saved_maximum_field_alignment;
8157 pop_from_top_level ();
8158 pop_deferring_access_checks ();
8161 /* The vtable for a template class can be emitted in any translation
8162 unit in which the class is instantiated. When there is no key
8163 method, however, finish_struct_1 will already have added TYPE to
8164 the keyed_classes list. */
8165 if (TYPE_CONTAINS_VPTR_P (type) && CLASSTYPE_KEY_METHOD (type))
8166 keyed_classes = tree_cons (NULL_TREE, type, keyed_classes);
8172 tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl)
8178 else if (TYPE_P (t))
8179 r = tsubst (t, args, complain, in_decl);
8182 r = tsubst_expr (t, args, complain, in_decl,
8183 /*integral_constant_expression_p=*/true);
8184 r = fold_non_dependent_expr (r);
8189 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
8190 NONTYPE_ARGUMENT_PACK. */
8193 make_fnparm_pack (tree spec_parm)
8195 /* Collect all of the extra "packed" parameters into an
8199 tree argpack = make_node (NONTYPE_ARGUMENT_PACK);
8200 tree argtypepack = cxx_make_type (TYPE_ARGUMENT_PACK);
8201 int i, len = list_length (spec_parm);
8203 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
8204 parmvec = make_tree_vec (len);
8205 parmtypevec = make_tree_vec (len);
8206 for (i = 0; i < len; i++, spec_parm = TREE_CHAIN (spec_parm))
8208 TREE_VEC_ELT (parmvec, i) = spec_parm;
8209 TREE_VEC_ELT (parmtypevec, i) = TREE_TYPE (spec_parm);
8212 /* Build the argument packs. */
8213 SET_ARGUMENT_PACK_ARGS (argpack, parmvec);
8214 SET_ARGUMENT_PACK_ARGS (argtypepack, parmtypevec);
8215 TREE_TYPE (argpack) = argtypepack;
8220 /* Substitute ARGS into T, which is an pack expansion
8221 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
8222 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
8223 (if only a partial substitution could be performed) or
8224 ERROR_MARK_NODE if there was an error. */
8226 tsubst_pack_expansion (tree t, tree args, tsubst_flags_t complain,
8230 tree pack, packs = NULL_TREE, unsubstituted_packs = NULL_TREE;
8234 bool very_local_specializations = false;
8236 gcc_assert (PACK_EXPANSION_P (t));
8237 pattern = PACK_EXPANSION_PATTERN (t);
8239 /* Determine the argument packs that will instantiate the parameter
8240 packs used in the expansion expression. While we're at it,
8241 compute the number of arguments to be expanded and make sure it
8243 for (pack = PACK_EXPANSION_PARAMETER_PACKS (t); pack;
8244 pack = TREE_CHAIN (pack))
8246 tree parm_pack = TREE_VALUE (pack);
8247 tree arg_pack = NULL_TREE;
8248 tree orig_arg = NULL_TREE;
8250 if (TREE_CODE (parm_pack) == PARM_DECL)
8252 arg_pack = retrieve_local_specialization (parm_pack);
8253 if (arg_pack == NULL_TREE)
8255 /* This can happen for a parameter name used later in a function
8256 declaration (such as in a late-specified return type). Just
8257 make a dummy decl, since it's only used for its type. */
8258 gcc_assert (cp_unevaluated_operand != 0);
8259 arg_pack = tsubst_decl (parm_pack, args, complain);
8260 arg_pack = make_fnparm_pack (arg_pack);
8265 int level, idx, levels;
8266 template_parm_level_and_index (parm_pack, &level, &idx);
8268 levels = TMPL_ARGS_DEPTH (args);
8269 if (level <= levels)
8270 arg_pack = TMPL_ARG (args, level, idx);
8273 orig_arg = arg_pack;
8274 if (arg_pack && TREE_CODE (arg_pack) == ARGUMENT_PACK_SELECT)
8275 arg_pack = ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack);
8277 if (arg_pack && !ARGUMENT_PACK_P (arg_pack))
8278 /* This can only happen if we forget to expand an argument
8279 pack somewhere else. Just return an error, silently. */
8281 result = make_tree_vec (1);
8282 TREE_VEC_ELT (result, 0) = error_mark_node;
8287 && TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack)) == 1
8288 && PACK_EXPANSION_P (TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg_pack), 0)))
8290 tree expansion = TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg_pack), 0);
8291 tree pattern = PACK_EXPANSION_PATTERN (expansion);
8292 if ((TYPE_P (pattern) && same_type_p (pattern, parm_pack))
8293 || (!TYPE_P (pattern) && cp_tree_equal (parm_pack, pattern)))
8294 /* The argument pack that the parameter maps to is just an
8295 expansion of the parameter itself, such as one would
8296 find in the implicit typedef of a class inside the
8297 class itself. Consider this parameter "unsubstituted",
8298 so that we will maintain the outer pack expansion. */
8299 arg_pack = NULL_TREE;
8305 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack));
8307 /* It's all-or-nothing with incomplete argument packs. */
8308 if (incomplete && !ARGUMENT_PACK_INCOMPLETE_P (arg_pack))
8309 return error_mark_node;
8311 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack))
8316 else if (len != my_len)
8319 /* We got explicit args for some packs but not others;
8320 do nothing now and try again after deduction. */
8322 if (TREE_CODE (t) == TYPE_PACK_EXPANSION)
8323 error ("mismatched argument pack lengths while expanding "
8327 error ("mismatched argument pack lengths while expanding "
8330 return error_mark_node;
8333 /* Keep track of the parameter packs and their corresponding
8335 packs = tree_cons (parm_pack, arg_pack, packs);
8336 TREE_TYPE (packs) = orig_arg;
8339 /* We can't substitute for this parameter pack. */
8340 unsubstituted_packs = tree_cons (TREE_PURPOSE (pack),
8342 unsubstituted_packs);
8345 /* We cannot expand this expansion expression, because we don't have
8346 all of the argument packs we need. Substitute into the pattern
8347 and return a PACK_EXPANSION_*. The caller will need to deal with
8349 if (unsubstituted_packs)
8352 if (TREE_CODE (t) == EXPR_PACK_EXPANSION)
8353 new_pat = tsubst_expr (pattern, args, complain, in_decl,
8354 /*integral_constant_expression_p=*/false);
8356 new_pat = tsubst (pattern, args, complain, in_decl);
8357 return make_pack_expansion (new_pat);
8360 /* We could not find any argument packs that work. */
8362 return error_mark_node;
8364 if (!local_specializations)
8366 /* We're in a late-specified return type, so we don't have a local
8367 specializations table. Create one for doing this expansion. */
8368 very_local_specializations = true;
8369 local_specializations = htab_create (37,
8370 hash_local_specialization,
8371 eq_local_specializations,
8375 /* For each argument in each argument pack, substitute into the
8377 result = make_tree_vec (len + incomplete);
8378 for (i = 0; i < len + incomplete; ++i)
8380 /* For parameter pack, change the substitution of the parameter
8381 pack to the ith argument in its argument pack, then expand
8383 for (pack = packs; pack; pack = TREE_CHAIN (pack))
8385 tree parm = TREE_PURPOSE (pack);
8387 if (TREE_CODE (parm) == PARM_DECL)
8389 /* Select the Ith argument from the pack. */
8390 tree arg = make_node (ARGUMENT_PACK_SELECT);
8391 ARGUMENT_PACK_SELECT_FROM_PACK (arg) = TREE_VALUE (pack);
8392 ARGUMENT_PACK_SELECT_INDEX (arg) = i;
8394 register_local_specialization (arg, parm);
8400 template_parm_level_and_index (parm, &level, &idx);
8404 /* Select the Ith argument from the pack. */
8405 value = make_node (ARGUMENT_PACK_SELECT);
8406 ARGUMENT_PACK_SELECT_FROM_PACK (value) = TREE_VALUE (pack);
8407 ARGUMENT_PACK_SELECT_INDEX (value) = i;
8410 /* Update the corresponding argument. */
8411 TMPL_ARG (args, level, idx) = value;
8415 /* Substitute into the PATTERN with the altered arguments. */
8416 if (TREE_CODE (t) == EXPR_PACK_EXPANSION)
8417 TREE_VEC_ELT (result, i) =
8418 tsubst_expr (pattern, args, complain, in_decl,
8419 /*integral_constant_expression_p=*/false);
8421 TREE_VEC_ELT (result, i) = tsubst (pattern, args, complain, in_decl);
8424 /* When we have incomplete argument packs, the last "expanded"
8425 result is itself a pack expansion, which allows us
8426 to deduce more arguments. */
8427 TREE_VEC_ELT (result, i) =
8428 make_pack_expansion (TREE_VEC_ELT (result, i));
8430 if (TREE_VEC_ELT (result, i) == error_mark_node)
8432 result = error_mark_node;
8437 /* Update ARGS to restore the substitution from parameter packs to
8438 their argument packs. */
8439 for (pack = packs; pack; pack = TREE_CHAIN (pack))
8441 tree parm = TREE_PURPOSE (pack);
8443 if (TREE_CODE (parm) == PARM_DECL)
8444 register_local_specialization (TREE_TYPE (pack), parm);
8448 template_parm_level_and_index (parm, &level, &idx);
8450 /* Update the corresponding argument. */
8451 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
8452 TREE_VEC_ELT (TREE_VEC_ELT (args, level -1 ), idx) =
8455 TREE_VEC_ELT (args, idx) = TREE_TYPE (pack);
8459 if (very_local_specializations)
8461 htab_delete (local_specializations);
8462 local_specializations = NULL;
8468 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
8469 TMPL. We do this using DECL_PARM_INDEX, which should work even with
8470 parameter packs; all parms generated from a function parameter pack will
8471 have the same DECL_PARM_INDEX. */
8474 get_pattern_parm (tree parm, tree tmpl)
8476 tree pattern = DECL_TEMPLATE_RESULT (tmpl);
8479 if (DECL_ARTIFICIAL (parm))
8481 for (patparm = DECL_ARGUMENTS (pattern);
8482 patparm; patparm = TREE_CHAIN (patparm))
8483 if (DECL_ARTIFICIAL (patparm)
8484 && DECL_NAME (parm) == DECL_NAME (patparm))
8489 patparm = FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl));
8490 patparm = chain_index (DECL_PARM_INDEX (parm)-1, patparm);
8491 gcc_assert (DECL_PARM_INDEX (patparm)
8492 == DECL_PARM_INDEX (parm));
8498 /* Substitute ARGS into the vector or list of template arguments T. */
8501 tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl)
8504 int len = TREE_VEC_LENGTH (t);
8505 int need_new = 0, i, expanded_len_adjust = 0, out;
8506 tree *elts = (tree *) alloca (len * sizeof (tree));
8508 for (i = 0; i < len; i++)
8510 tree orig_arg = TREE_VEC_ELT (t, i);
8513 if (TREE_CODE (orig_arg) == TREE_VEC)
8514 new_arg = tsubst_template_args (orig_arg, args, complain, in_decl);
8515 else if (PACK_EXPANSION_P (orig_arg))
8517 /* Substitute into an expansion expression. */
8518 new_arg = tsubst_pack_expansion (orig_arg, args, complain, in_decl);
8520 if (TREE_CODE (new_arg) == TREE_VEC)
8521 /* Add to the expanded length adjustment the number of
8522 expanded arguments. We subtract one from this
8523 measurement, because the argument pack expression
8524 itself is already counted as 1 in
8525 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
8526 the argument pack is empty. */
8527 expanded_len_adjust += TREE_VEC_LENGTH (new_arg) - 1;
8529 else if (ARGUMENT_PACK_P (orig_arg))
8531 /* Substitute into each of the arguments. */
8532 new_arg = TYPE_P (orig_arg)
8533 ? cxx_make_type (TREE_CODE (orig_arg))
8534 : make_node (TREE_CODE (orig_arg));
8536 SET_ARGUMENT_PACK_ARGS (
8538 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg),
8539 args, complain, in_decl));
8541 if (ARGUMENT_PACK_ARGS (new_arg) == error_mark_node)
8542 new_arg = error_mark_node;
8544 if (TREE_CODE (new_arg) == NONTYPE_ARGUMENT_PACK) {
8545 TREE_TYPE (new_arg) = tsubst (TREE_TYPE (orig_arg), args,
8547 TREE_CONSTANT (new_arg) = TREE_CONSTANT (orig_arg);
8549 if (TREE_TYPE (new_arg) == error_mark_node)
8550 new_arg = error_mark_node;
8554 new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl);
8556 if (new_arg == error_mark_node)
8557 return error_mark_node;
8560 if (new_arg != orig_arg)
8567 /* Make space for the expanded arguments coming from template
8569 t = make_tree_vec (len + expanded_len_adjust);
8570 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
8571 arguments for a member template.
8572 In that case each TREE_VEC in ORIG_T represents a level of template
8573 arguments, and ORIG_T won't carry any non defaulted argument count.
8574 It will rather be the nested TREE_VECs that will carry one.
8575 In other words, ORIG_T carries a non defaulted argument count only
8576 if it doesn't contain any nested TREE_VEC. */
8577 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t))
8579 int count = GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t);
8580 count += expanded_len_adjust;
8581 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t, count);
8583 for (i = 0, out = 0; i < len; i++)
8585 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t, i))
8586 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t, i)))
8587 && TREE_CODE (elts[i]) == TREE_VEC)
8591 /* Now expand the template argument pack "in place". */
8592 for (idx = 0; idx < TREE_VEC_LENGTH (elts[i]); idx++, out++)
8593 TREE_VEC_ELT (t, out) = TREE_VEC_ELT (elts[i], idx);
8597 TREE_VEC_ELT (t, out) = elts[i];
8605 /* Return the result of substituting ARGS into the template parameters
8606 given by PARMS. If there are m levels of ARGS and m + n levels of
8607 PARMS, then the result will contain n levels of PARMS. For
8608 example, if PARMS is `template <class T> template <class U>
8609 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
8610 result will be `template <int*, double, class V>'. */
8613 tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain)
8618 /* When substituting into a template, we must set
8619 PROCESSING_TEMPLATE_DECL as the template parameters may be
8620 dependent if they are based on one-another, and the dependency
8621 predicates are short-circuit outside of templates. */
8622 ++processing_template_decl;
8624 for (new_parms = &r;
8625 TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args);
8626 new_parms = &(TREE_CHAIN (*new_parms)),
8627 parms = TREE_CHAIN (parms))
8630 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms)));
8633 for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i)
8639 if (parms == error_mark_node)
8642 tuple = TREE_VEC_ELT (TREE_VALUE (parms), i);
8644 if (tuple == error_mark_node)
8647 default_value = TREE_PURPOSE (tuple);
8648 parm_decl = TREE_VALUE (tuple);
8650 parm_decl = tsubst (parm_decl, args, complain, NULL_TREE);
8651 if (TREE_CODE (parm_decl) == PARM_DECL
8652 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl), complain))
8653 parm_decl = error_mark_node;
8654 default_value = tsubst_template_arg (default_value, args,
8655 complain, NULL_TREE);
8657 tuple = build_tree_list (default_value, parm_decl);
8658 TREE_VEC_ELT (new_vec, i) = tuple;
8662 tree_cons (size_int (TMPL_PARMS_DEPTH (parms)
8663 - TMPL_ARGS_DEPTH (args)),
8664 new_vec, NULL_TREE);
8667 --processing_template_decl;
8672 /* Substitute the ARGS into the indicated aggregate (or enumeration)
8673 type T. If T is not an aggregate or enumeration type, it is
8674 handled as if by tsubst. IN_DECL is as for tsubst. If
8675 ENTERING_SCOPE is nonzero, T is the context for a template which
8676 we are presently tsubst'ing. Return the substituted value. */
8679 tsubst_aggr_type (tree t,
8681 tsubst_flags_t complain,
8688 switch (TREE_CODE (t))
8691 if (TYPE_PTRMEMFUNC_P (t))
8692 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl);
8694 /* Else fall through. */
8697 if (TYPE_TEMPLATE_INFO (t) && uses_template_parms (t))
8702 int saved_unevaluated_operand;
8703 int saved_inhibit_evaluation_warnings;
8705 /* In "sizeof(X<I>)" we need to evaluate "I". */
8706 saved_unevaluated_operand = cp_unevaluated_operand;
8707 cp_unevaluated_operand = 0;
8708 saved_inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
8709 c_inhibit_evaluation_warnings = 0;
8711 /* First, determine the context for the type we are looking
8713 context = TYPE_CONTEXT (t);
8716 context = tsubst_aggr_type (context, args, complain,
8717 in_decl, /*entering_scope=*/1);
8718 /* If context is a nested class inside a class template,
8719 it may still need to be instantiated (c++/33959). */
8720 if (TYPE_P (context))
8721 context = complete_type (context);
8724 /* Then, figure out what arguments are appropriate for the
8725 type we are trying to find. For example, given:
8727 template <class T> struct S;
8728 template <class T, class U> void f(T, U) { S<U> su; }
8730 and supposing that we are instantiating f<int, double>,
8731 then our ARGS will be {int, double}, but, when looking up
8732 S we only want {double}. */
8733 argvec = tsubst_template_args (TYPE_TI_ARGS (t), args,
8735 if (argvec == error_mark_node)
8736 r = error_mark_node;
8739 r = lookup_template_class (t, argvec, in_decl, context,
8740 entering_scope, complain);
8741 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
8744 cp_unevaluated_operand = saved_unevaluated_operand;
8745 c_inhibit_evaluation_warnings = saved_inhibit_evaluation_warnings;
8750 /* This is not a template type, so there's nothing to do. */
8754 return tsubst (t, args, complain, in_decl);
8758 /* Substitute into the default argument ARG (a default argument for
8759 FN), which has the indicated TYPE. */
8762 tsubst_default_argument (tree fn, tree type, tree arg)
8764 tree saved_class_ptr = NULL_TREE;
8765 tree saved_class_ref = NULL_TREE;
8767 /* This default argument came from a template. Instantiate the
8768 default argument here, not in tsubst. In the case of
8777 we must be careful to do name lookup in the scope of S<T>,
8778 rather than in the current class. */
8779 push_access_scope (fn);
8780 /* The "this" pointer is not valid in a default argument. */
8783 saved_class_ptr = current_class_ptr;
8784 cp_function_chain->x_current_class_ptr = NULL_TREE;
8785 saved_class_ref = current_class_ref;
8786 cp_function_chain->x_current_class_ref = NULL_TREE;
8789 push_deferring_access_checks(dk_no_deferred);
8790 /* The default argument expression may cause implicitly defined
8791 member functions to be synthesized, which will result in garbage
8792 collection. We must treat this situation as if we were within
8793 the body of function so as to avoid collecting live data on the
8796 arg = tsubst_expr (arg, DECL_TI_ARGS (fn),
8797 tf_warning_or_error, NULL_TREE,
8798 /*integral_constant_expression_p=*/false);
8800 pop_deferring_access_checks();
8802 /* Restore the "this" pointer. */
8805 cp_function_chain->x_current_class_ptr = saved_class_ptr;
8806 cp_function_chain->x_current_class_ref = saved_class_ref;
8809 /* Make sure the default argument is reasonable. */
8810 arg = check_default_argument (type, arg);
8812 pop_access_scope (fn);
8817 /* Substitute into all the default arguments for FN. */
8820 tsubst_default_arguments (tree fn)
8825 tmpl_args = DECL_TI_ARGS (fn);
8827 /* If this function is not yet instantiated, we certainly don't need
8828 its default arguments. */
8829 if (uses_template_parms (tmpl_args))
8832 for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
8834 arg = TREE_CHAIN (arg))
8835 if (TREE_PURPOSE (arg))
8836 TREE_PURPOSE (arg) = tsubst_default_argument (fn,
8838 TREE_PURPOSE (arg));
8841 /* Substitute the ARGS into the T, which is a _DECL. Return the
8842 result of the substitution. Issue error and warning messages under
8843 control of COMPLAIN. */
8846 tsubst_decl (tree t, tree args, tsubst_flags_t complain)
8848 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
8849 location_t saved_loc;
8854 /* Set the filename and linenumber to improve error-reporting. */
8855 saved_loc = input_location;
8856 input_location = DECL_SOURCE_LOCATION (t);
8858 switch (TREE_CODE (t))
8862 /* We can get here when processing a member function template,
8863 member class template, or template template parameter. */
8864 tree decl = DECL_TEMPLATE_RESULT (t);
8869 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
8871 /* Template template parameter is treated here. */
8872 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8873 if (new_type == error_mark_node)
8874 RETURN (error_mark_node);
8877 TREE_CHAIN (r) = NULL_TREE;
8878 TREE_TYPE (r) = new_type;
8879 DECL_TEMPLATE_RESULT (r)
8880 = build_decl (DECL_SOURCE_LOCATION (decl),
8881 TYPE_DECL, DECL_NAME (decl), new_type);
8882 DECL_TEMPLATE_PARMS (r)
8883 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
8885 TYPE_NAME (new_type) = r;
8889 /* We might already have an instance of this template.
8890 The ARGS are for the surrounding class type, so the
8891 full args contain the tsubst'd args for the context,
8892 plus the innermost args from the template decl. */
8893 tmpl_args = DECL_CLASS_TEMPLATE_P (t)
8894 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t))
8895 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t));
8896 /* Because this is a template, the arguments will still be
8897 dependent, even after substitution. If
8898 PROCESSING_TEMPLATE_DECL is not set, the dependency
8899 predicates will short-circuit. */
8900 ++processing_template_decl;
8901 full_args = tsubst_template_args (tmpl_args, args,
8903 --processing_template_decl;
8904 if (full_args == error_mark_node)
8905 RETURN (error_mark_node);
8907 /* If this is a default template template argument,
8908 tsubst might not have changed anything. */
8909 if (full_args == tmpl_args)
8912 hash = hash_tmpl_and_args (t, full_args);
8913 spec = retrieve_specialization (t, full_args, hash);
8914 if (spec != NULL_TREE)
8920 /* Make a new template decl. It will be similar to the
8921 original, but will record the current template arguments.
8922 We also create a new function declaration, which is just
8923 like the old one, but points to this new template, rather
8924 than the old one. */
8926 gcc_assert (DECL_LANG_SPECIFIC (r) != 0);
8927 TREE_CHAIN (r) = NULL_TREE;
8929 DECL_TEMPLATE_INFO (r) = build_template_info (t, args);
8931 if (TREE_CODE (decl) == TYPE_DECL)
8934 ++processing_template_decl;
8935 new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8936 --processing_template_decl;
8937 if (new_type == error_mark_node)
8938 RETURN (error_mark_node);
8940 TREE_TYPE (r) = new_type;
8941 CLASSTYPE_TI_TEMPLATE (new_type) = r;
8942 DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type);
8943 DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type);
8944 DECL_CONTEXT (r) = TYPE_CONTEXT (new_type);
8949 ++processing_template_decl;
8950 new_decl = tsubst (decl, args, complain, in_decl);
8951 --processing_template_decl;
8952 if (new_decl == error_mark_node)
8953 RETURN (error_mark_node);
8955 DECL_TEMPLATE_RESULT (r) = new_decl;
8956 DECL_TI_TEMPLATE (new_decl) = r;
8957 TREE_TYPE (r) = TREE_TYPE (new_decl);
8958 DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl);
8959 DECL_CONTEXT (r) = DECL_CONTEXT (new_decl);
8962 SET_DECL_IMPLICIT_INSTANTIATION (r);
8963 DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE;
8964 DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE;
8966 /* The template parameters for this new template are all the
8967 template parameters for the old template, except the
8968 outermost level of parameters. */
8969 DECL_TEMPLATE_PARMS (r)
8970 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
8973 if (PRIMARY_TEMPLATE_P (t))
8974 DECL_PRIMARY_TEMPLATE (r) = r;
8976 if (TREE_CODE (decl) != TYPE_DECL)
8977 /* Record this non-type partial instantiation. */
8978 register_specialization (r, t,
8979 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r)),
8987 tree argvec = NULL_TREE;
8995 /* Nobody should be tsubst'ing into non-template functions. */
8996 gcc_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE);
8998 if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL)
9003 /* If T is not dependent, just return it. We have to
9004 increment PROCESSING_TEMPLATE_DECL because
9005 value_dependent_expression_p assumes that nothing is
9006 dependent when PROCESSING_TEMPLATE_DECL is zero. */
9007 ++processing_template_decl;
9008 dependent_p = value_dependent_expression_p (t);
9009 --processing_template_decl;
9013 /* Calculate the most general template of which R is a
9014 specialization, and the complete set of arguments used to
9016 gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
9017 argvec = tsubst_template_args (DECL_TI_ARGS
9018 (DECL_TEMPLATE_RESULT (gen_tmpl)),
9019 args, complain, in_decl);
9021 /* Check to see if we already have this specialization. */
9022 hash = hash_tmpl_and_args (gen_tmpl, argvec);
9023 spec = retrieve_specialization (gen_tmpl, argvec, hash);
9031 /* We can see more levels of arguments than parameters if
9032 there was a specialization of a member template, like
9035 template <class T> struct S { template <class U> void f(); }
9036 template <> template <class U> void S<int>::f(U);
9038 Here, we'll be substituting into the specialization,
9039 because that's where we can find the code we actually
9040 want to generate, but we'll have enough arguments for
9041 the most general template.
9043 We also deal with the peculiar case:
9045 template <class T> struct S {
9046 template <class U> friend void f();
9048 template <class U> void f() {}
9050 template void f<double>();
9052 Here, the ARGS for the instantiation of will be {int,
9053 double}. But, we only need as many ARGS as there are
9054 levels of template parameters in CODE_PATTERN. We are
9055 careful not to get fooled into reducing the ARGS in
9058 template <class T> struct S { template <class U> void f(U); }
9059 template <class T> template <> void S<T>::f(int) {}
9061 which we can spot because the pattern will be a
9062 specialization in this case. */
9063 args_depth = TMPL_ARGS_DEPTH (args);
9065 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t)));
9066 if (args_depth > parms_depth
9067 && !DECL_TEMPLATE_SPECIALIZATION (t))
9068 args = get_innermost_template_args (args, parms_depth);
9072 /* This special case arises when we have something like this:
9074 template <class T> struct S {
9075 friend void f<int>(int, double);
9078 Here, the DECL_TI_TEMPLATE for the friend declaration
9079 will be an IDENTIFIER_NODE. We are being called from
9080 tsubst_friend_function, and we want only to create a
9081 new decl (R) with appropriate types so that we can call
9082 determine_specialization. */
9083 gen_tmpl = NULL_TREE;
9086 if (DECL_CLASS_SCOPE_P (t))
9088 if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t)))
9092 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
9093 complain, t, /*entering_scope=*/1);
9098 ctx = DECL_CONTEXT (t);
9100 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
9101 if (type == error_mark_node)
9102 RETURN (error_mark_node);
9104 /* We do NOT check for matching decls pushed separately at this
9105 point, as they may not represent instantiations of this
9106 template, and in any case are considered separate under the
9109 DECL_USE_TEMPLATE (r) = 0;
9110 TREE_TYPE (r) = type;
9111 /* Clear out the mangled name and RTL for the instantiation. */
9112 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
9113 SET_DECL_RTL (r, NULL_RTX);
9114 /* Leave DECL_INITIAL set on deleted instantiations. */
9115 if (!DECL_DELETED_FN (r))
9116 DECL_INITIAL (r) = NULL_TREE;
9117 DECL_CONTEXT (r) = ctx;
9119 if (member && DECL_CONV_FN_P (r))
9120 /* Type-conversion operator. Reconstruct the name, in
9121 case it's the name of one of the template's parameters. */
9122 DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type));
9124 DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args,
9126 DECL_RESULT (r) = NULL_TREE;
9128 TREE_STATIC (r) = 0;
9129 TREE_PUBLIC (r) = TREE_PUBLIC (t);
9130 DECL_EXTERNAL (r) = 1;
9131 /* If this is an instantiation of a function with internal
9132 linkage, we already know what object file linkage will be
9133 assigned to the instantiation. */
9134 DECL_INTERFACE_KNOWN (r) = !TREE_PUBLIC (r);
9135 DECL_DEFER_OUTPUT (r) = 0;
9136 TREE_CHAIN (r) = NULL_TREE;
9137 DECL_PENDING_INLINE_INFO (r) = 0;
9138 DECL_PENDING_INLINE_P (r) = 0;
9139 DECL_SAVED_TREE (r) = NULL_TREE;
9140 DECL_STRUCT_FUNCTION (r) = NULL;
9142 /* We'll re-clone as appropriate in instantiate_template. */
9143 DECL_CLONED_FUNCTION (r) = NULL_TREE;
9145 /* If we aren't complaining now, return on error before we register
9146 the specialization so that we'll complain eventually. */
9147 if ((complain & tf_error) == 0
9148 && IDENTIFIER_OPNAME_P (DECL_NAME (r))
9149 && !grok_op_properties (r, /*complain=*/false))
9150 RETURN (error_mark_node);
9152 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
9153 this in the special friend case mentioned above where
9154 GEN_TMPL is NULL. */
9157 DECL_TEMPLATE_INFO (r)
9158 = build_template_info (gen_tmpl, argvec);
9159 SET_DECL_IMPLICIT_INSTANTIATION (r);
9160 register_specialization (r, gen_tmpl, argvec, false, hash);
9162 /* We're not supposed to instantiate default arguments
9163 until they are called, for a template. But, for a
9166 template <class T> void f ()
9167 { extern void g(int i = T()); }
9169 we should do the substitution when the template is
9170 instantiated. We handle the member function case in
9171 instantiate_class_template since the default arguments
9172 might refer to other members of the class. */
9174 && !PRIMARY_TEMPLATE_P (gen_tmpl)
9175 && !uses_template_parms (argvec))
9176 tsubst_default_arguments (r);
9179 DECL_TEMPLATE_INFO (r) = NULL_TREE;
9181 /* Copy the list of befriending classes. */
9182 for (friends = &DECL_BEFRIENDING_CLASSES (r);
9184 friends = &TREE_CHAIN (*friends))
9186 *friends = copy_node (*friends);
9187 TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends),
9192 if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r))
9194 maybe_retrofit_in_chrg (r);
9195 if (DECL_CONSTRUCTOR_P (r))
9196 grok_ctor_properties (ctx, r);
9197 /* If this is an instantiation of a member template, clone it.
9198 If it isn't, that'll be handled by
9199 clone_constructors_and_destructors. */
9200 if (PRIMARY_TEMPLATE_P (gen_tmpl))
9201 clone_function_decl (r, /*update_method_vec_p=*/0);
9203 else if ((complain & tf_error) != 0
9204 && IDENTIFIER_OPNAME_P (DECL_NAME (r))
9205 && !grok_op_properties (r, /*complain=*/true))
9206 RETURN (error_mark_node);
9208 if (DECL_FRIEND_P (t) && DECL_FRIEND_CONTEXT (t))
9209 SET_DECL_FRIEND_CONTEXT (r,
9210 tsubst (DECL_FRIEND_CONTEXT (t),
9211 args, complain, in_decl));
9213 /* Possibly limit visibility based on template args. */
9214 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
9215 if (DECL_VISIBILITY_SPECIFIED (t))
9217 DECL_VISIBILITY_SPECIFIED (r) = 0;
9219 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
9221 determine_visibility (r);
9222 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r)
9223 && !processing_template_decl)
9224 defaulted_late_check (r);
9226 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
9227 args, complain, in_decl);
9233 tree type = NULL_TREE;
9235 tree expanded_types = NULL_TREE;
9236 tree prev_r = NULL_TREE;
9237 tree first_r = NULL_TREE;
9239 if (FUNCTION_PARAMETER_PACK_P (t))
9241 /* If there is a local specialization that isn't a
9242 parameter pack, it means that we're doing a "simple"
9243 substitution from inside tsubst_pack_expansion. Just
9244 return the local specialization (which will be a single
9246 tree spec = retrieve_local_specialization (t);
9248 && TREE_CODE (spec) == PARM_DECL
9249 && TREE_CODE (TREE_TYPE (spec)) != TYPE_PACK_EXPANSION)
9252 /* Expand the TYPE_PACK_EXPANSION that provides the types for
9253 the parameters in this function parameter pack. */
9254 expanded_types = tsubst_pack_expansion (TREE_TYPE (t), args,
9256 if (TREE_CODE (expanded_types) == TREE_VEC)
9258 len = TREE_VEC_LENGTH (expanded_types);
9260 /* Zero-length parameter packs are boring. Just substitute
9263 RETURN (tsubst (TREE_CHAIN (t), args, complain,
9268 /* All we did was update the type. Make a note of that. */
9269 type = expanded_types;
9270 expanded_types = NULL_TREE;
9274 /* Loop through all of the parameter's we'll build. When T is
9275 a function parameter pack, LEN is the number of expanded
9276 types in EXPANDED_TYPES; otherwise, LEN is 1. */
9278 for (i = 0; i < len; ++i)
9282 if (DECL_TEMPLATE_PARM_P (t))
9283 SET_DECL_TEMPLATE_PARM_P (r);
9285 /* An argument of a function parameter pack is not a parameter
9287 FUNCTION_PARAMETER_PACK_P (r) = false;
9290 /* We're on the Ith parameter of the function parameter
9293 /* Get the Ith type. */
9294 type = TREE_VEC_ELT (expanded_types, i);
9297 /* Rename the parameter to include the index. */
9299 make_ith_pack_parameter_name (DECL_NAME (r), i);
9302 /* We're dealing with a normal parameter. */
9303 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
9305 type = type_decays_to (type);
9306 TREE_TYPE (r) = type;
9307 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
9309 if (DECL_INITIAL (r))
9311 if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
9312 DECL_INITIAL (r) = TREE_TYPE (r);
9314 DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
9318 DECL_CONTEXT (r) = NULL_TREE;
9320 if (!DECL_TEMPLATE_PARM_P (r))
9321 DECL_ARG_TYPE (r) = type_passed_as (type);
9323 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
9324 args, complain, in_decl);
9326 /* Keep track of the first new parameter we
9327 generate. That's what will be returned to the
9332 /* Build a proper chain of parameters when substituting
9333 into a function parameter pack. */
9335 TREE_CHAIN (prev_r) = r;
9339 TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args,
9340 complain, TREE_CHAIN (t));
9342 /* FIRST_R contains the start of the chain we've built. */
9352 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
9353 if (type == error_mark_node)
9354 RETURN (error_mark_node);
9355 TREE_TYPE (r) = type;
9356 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
9358 /* DECL_INITIAL gives the number of bits in a bit-field. */
9360 = tsubst_expr (DECL_INITIAL (t), args,
9362 /*integral_constant_expression_p=*/true);
9363 /* We don't have to set DECL_CONTEXT here; it is set by
9364 finish_member_declaration. */
9365 TREE_CHAIN (r) = NULL_TREE;
9366 if (VOID_TYPE_P (type))
9367 error ("instantiation of %q+D as type %qT", r, type);
9369 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
9370 args, complain, in_decl);
9375 /* We reach here only for member using decls. */
9376 if (DECL_DEPENDENT_P (t))
9378 r = do_class_using_decl
9379 (tsubst_copy (USING_DECL_SCOPE (t), args, complain, in_decl),
9380 tsubst_copy (DECL_NAME (t), args, complain, in_decl));
9382 r = error_mark_node;
9385 TREE_PROTECTED (r) = TREE_PROTECTED (t);
9386 TREE_PRIVATE (r) = TREE_PRIVATE (t);
9392 TREE_CHAIN (r) = NULL_TREE;
9399 tree argvec = NULL_TREE;
9400 tree gen_tmpl = NULL_TREE;
9402 tree tmpl = NULL_TREE;
9404 tree type = NULL_TREE;
9407 if (TREE_CODE (t) == TYPE_DECL
9408 && t == TYPE_MAIN_DECL (TREE_TYPE (t)))
9410 /* If this is the canonical decl, we don't have to
9411 mess with instantiations, and often we can't (for
9412 typename, template type parms and such). Note that
9413 TYPE_NAME is not correct for the above test if
9414 we've copied the type for a typedef. */
9415 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
9416 if (type == error_mark_node)
9417 RETURN (error_mark_node);
9418 r = TYPE_NAME (type);
9422 /* Check to see if we already have the specialization we
9425 if (DECL_CLASS_SCOPE_P (t) || DECL_NAMESPACE_SCOPE_P (t))
9427 /* T is a static data member or namespace-scope entity.
9428 We have to substitute into namespace-scope variables
9429 (even though such entities are never templates) because
9432 template <class T> void f() { extern T t; }
9434 where the entity referenced is not known until
9435 instantiation time. */
9437 ctx = DECL_CONTEXT (t);
9438 if (DECL_CLASS_SCOPE_P (t))
9440 ctx = tsubst_aggr_type (ctx, args,
9442 in_decl, /*entering_scope=*/1);
9443 /* If CTX is unchanged, then T is in fact the
9444 specialization we want. That situation occurs when
9445 referencing a static data member within in its own
9446 class. We can use pointer equality, rather than
9447 same_type_p, because DECL_CONTEXT is always
9449 if (ctx == DECL_CONTEXT (t))
9455 tmpl = DECL_TI_TEMPLATE (t);
9456 gen_tmpl = most_general_template (tmpl);
9457 argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl);
9458 hash = hash_tmpl_and_args (gen_tmpl, argvec);
9459 spec = retrieve_specialization (gen_tmpl, argvec, hash);
9464 /* A local variable. */
9466 /* Subsequent calls to pushdecl will fill this in. */
9468 spec = retrieve_local_specialization (t);
9470 /* If we already have the specialization we need, there is
9471 nothing more to do. */
9478 /* Create a new node for the specialization we need. */
9480 if (type == NULL_TREE)
9482 if (is_typedef_decl (t))
9483 type = DECL_ORIGINAL_TYPE (t);
9485 type = TREE_TYPE (t);
9486 type = tsubst (type, args, complain, in_decl);
9488 if (TREE_CODE (r) == VAR_DECL)
9490 /* Even if the original location is out of scope, the
9491 newly substituted one is not. */
9492 DECL_DEAD_FOR_LOCAL (r) = 0;
9493 DECL_INITIALIZED_P (r) = 0;
9494 DECL_TEMPLATE_INSTANTIATED (r) = 0;
9495 if (type == error_mark_node)
9496 RETURN (error_mark_node);
9497 if (TREE_CODE (type) == FUNCTION_TYPE)
9499 /* It may seem that this case cannot occur, since:
9504 declares a function, not a variable. However:
9507 template <typename T> void g() { T t; }
9508 template void g<f>();
9510 is an attempt to declare a variable with function
9512 error ("variable %qD has function type",
9513 /* R is not yet sufficiently initialized, so we
9514 just use its name. */
9516 RETURN (error_mark_node);
9518 type = complete_type (type);
9519 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
9520 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t);
9521 type = check_var_type (DECL_NAME (r), type);
9523 if (DECL_HAS_VALUE_EXPR_P (t))
9525 tree ve = DECL_VALUE_EXPR (t);
9526 ve = tsubst_expr (ve, args, complain, in_decl,
9527 /*constant_expression_p=*/false);
9528 SET_DECL_VALUE_EXPR (r, ve);
9531 else if (DECL_SELF_REFERENCE_P (t))
9532 SET_DECL_SELF_REFERENCE_P (r);
9533 TREE_TYPE (r) = type;
9534 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
9535 DECL_CONTEXT (r) = ctx;
9536 /* Clear out the mangled name and RTL for the instantiation. */
9537 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
9538 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
9539 SET_DECL_RTL (r, NULL_RTX);
9540 /* The initializer must not be expanded until it is required;
9542 DECL_INITIAL (r) = NULL_TREE;
9543 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
9544 SET_DECL_RTL (r, NULL_RTX);
9545 DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0;
9546 if (TREE_CODE (r) == VAR_DECL)
9548 /* Possibly limit visibility based on template args. */
9549 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
9550 if (DECL_VISIBILITY_SPECIFIED (t))
9552 DECL_VISIBILITY_SPECIFIED (r) = 0;
9554 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
9556 determine_visibility (r);
9561 /* A static data member declaration is always marked
9562 external when it is declared in-class, even if an
9563 initializer is present. We mimic the non-template
9565 DECL_EXTERNAL (r) = 1;
9567 register_specialization (r, gen_tmpl, argvec, false, hash);
9568 DECL_TEMPLATE_INFO (r) = build_template_info (tmpl, argvec);
9569 SET_DECL_IMPLICIT_INSTANTIATION (r);
9571 else if (cp_unevaluated_operand)
9573 /* We're substituting this var in a decltype outside of its
9574 scope, such as for a lambda return type. Don't add it to
9575 local_specializations, do perform auto deduction. */
9576 tree auto_node = type_uses_auto (type);
9578 = tsubst_expr (DECL_INITIAL (t), args, complain, in_decl,
9579 /*constant_expression_p=*/false);
9581 if (auto_node && init && describable_type (init))
9583 type = do_auto_deduction (type, init, auto_node);
9584 TREE_TYPE (r) = type;
9588 register_local_specialization (r, t);
9590 TREE_CHAIN (r) = NULL_TREE;
9592 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r),
9594 args, complain, in_decl);
9596 /* Preserve a typedef that names a type. */
9597 if (is_typedef_decl (r))
9599 DECL_ORIGINAL_TYPE (r) = NULL_TREE;
9600 set_underlying_type (r);
9613 /* Restore the file and line information. */
9614 input_location = saved_loc;
9619 /* Substitute into the ARG_TYPES of a function type. */
9622 tsubst_arg_types (tree arg_types,
9624 tsubst_flags_t complain,
9627 tree remaining_arg_types;
9628 tree type = NULL_TREE;
9630 tree expanded_args = NULL_TREE;
9633 if (!arg_types || arg_types == void_list_node)
9636 remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types),
9637 args, complain, in_decl);
9638 if (remaining_arg_types == error_mark_node)
9639 return error_mark_node;
9641 if (PACK_EXPANSION_P (TREE_VALUE (arg_types)))
9643 /* For a pack expansion, perform substitution on the
9644 entire expression. Later on, we'll handle the arguments
9646 expanded_args = tsubst_pack_expansion (TREE_VALUE (arg_types),
9647 args, complain, in_decl);
9649 if (TREE_CODE (expanded_args) == TREE_VEC)
9650 /* So that we'll spin through the parameters, one by one. */
9651 i = TREE_VEC_LENGTH (expanded_args);
9654 /* We only partially substituted into the parameter
9655 pack. Our type is TYPE_PACK_EXPANSION. */
9656 type = expanded_args;
9657 expanded_args = NULL_TREE;
9665 type = TREE_VEC_ELT (expanded_args, i);
9667 type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
9669 if (type == error_mark_node)
9670 return error_mark_node;
9671 if (VOID_TYPE_P (type))
9673 if (complain & tf_error)
9675 error ("invalid parameter type %qT", type);
9677 error ("in declaration %q+D", in_decl);
9679 return error_mark_node;
9682 /* Do array-to-pointer, function-to-pointer conversion, and ignore
9683 top-level qualifiers as required. */
9684 type = TYPE_MAIN_VARIANT (type_decays_to (type));
9686 /* We do not substitute into default arguments here. The standard
9687 mandates that they be instantiated only when needed, which is
9688 done in build_over_call. */
9689 default_arg = TREE_PURPOSE (arg_types);
9691 if (default_arg && TREE_CODE (default_arg) == DEFAULT_ARG)
9693 /* We've instantiated a template before its default arguments
9694 have been parsed. This can happen for a nested template
9695 class, and is not an error unless we require the default
9696 argument in a call of this function. */
9697 remaining_arg_types =
9698 tree_cons (default_arg, type, remaining_arg_types);
9699 VEC_safe_push (tree, gc, DEFARG_INSTANTIATIONS (default_arg),
9700 remaining_arg_types);
9703 remaining_arg_types =
9704 hash_tree_cons (default_arg, type, remaining_arg_types);
9707 return remaining_arg_types;
9710 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
9711 *not* handle the exception-specification for FNTYPE, because the
9712 initial substitution of explicitly provided template parameters
9713 during argument deduction forbids substitution into the
9714 exception-specification:
9718 All references in the function type of the function template to the
9719 corresponding template parameters are replaced by the specified tem-
9720 plate argument values. If a substitution in a template parameter or
9721 in the function type of the function template results in an invalid
9722 type, type deduction fails. [Note: The equivalent substitution in
9723 exception specifications is done only when the function is instanti-
9724 ated, at which point a program is ill-formed if the substitution
9725 results in an invalid type.] */
9728 tsubst_function_type (tree t,
9730 tsubst_flags_t complain,
9737 /* The TYPE_CONTEXT is not used for function/method types. */
9738 gcc_assert (TYPE_CONTEXT (t) == NULL_TREE);
9740 /* Substitute the return type. */
9741 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
9742 if (return_type == error_mark_node)
9743 return error_mark_node;
9744 /* The standard does not presently indicate that creation of a
9745 function type with an invalid return type is a deduction failure.
9746 However, that is clearly analogous to creating an array of "void"
9747 or a reference to a reference. This is core issue #486. */
9748 if (TREE_CODE (return_type) == ARRAY_TYPE
9749 || TREE_CODE (return_type) == FUNCTION_TYPE)
9751 if (complain & tf_error)
9753 if (TREE_CODE (return_type) == ARRAY_TYPE)
9754 error ("function returning an array");
9756 error ("function returning a function");
9758 return error_mark_node;
9761 /* Substitute the argument types. */
9762 arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args,
9764 if (arg_types == error_mark_node)
9765 return error_mark_node;
9767 /* Construct a new type node and return it. */
9768 if (TREE_CODE (t) == FUNCTION_TYPE)
9769 fntype = build_function_type (return_type, arg_types);
9772 tree r = TREE_TYPE (TREE_VALUE (arg_types));
9773 if (! MAYBE_CLASS_TYPE_P (r))
9777 Type deduction may fail for any of the following
9780 -- Attempting to create "pointer to member of T" when T
9781 is not a class type. */
9782 if (complain & tf_error)
9783 error ("creating pointer to member function of non-class type %qT",
9785 return error_mark_node;
9788 fntype = build_method_type_directly (r, return_type,
9789 TREE_CHAIN (arg_types));
9791 fntype = cp_build_qualified_type_real (fntype, TYPE_QUALS (t), complain);
9792 fntype = cp_build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t));
9797 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
9798 ARGS into that specification, and return the substituted
9799 specification. If there is no specification, return NULL_TREE. */
9802 tsubst_exception_specification (tree fntype,
9804 tsubst_flags_t complain,
9810 specs = TYPE_RAISES_EXCEPTIONS (fntype);
9811 new_specs = NULL_TREE;
9814 if (! TREE_VALUE (specs))
9821 tree expanded_specs = NULL_TREE;
9823 if (PACK_EXPANSION_P (TREE_VALUE (specs)))
9825 /* Expand the pack expansion type. */
9826 expanded_specs = tsubst_pack_expansion (TREE_VALUE (specs),
9830 if (expanded_specs == error_mark_node)
9831 return error_mark_node;
9832 else if (TREE_CODE (expanded_specs) == TREE_VEC)
9833 len = TREE_VEC_LENGTH (expanded_specs);
9836 /* We're substituting into a member template, so
9837 we got a TYPE_PACK_EXPANSION back. Add that
9838 expansion and move on. */
9839 gcc_assert (TREE_CODE (expanded_specs)
9840 == TYPE_PACK_EXPANSION);
9841 new_specs = add_exception_specifier (new_specs,
9844 specs = TREE_CHAIN (specs);
9849 for (i = 0; i < len; ++i)
9852 spec = TREE_VEC_ELT (expanded_specs, i);
9854 spec = tsubst (TREE_VALUE (specs), args, complain, in_decl);
9855 if (spec == error_mark_node)
9857 new_specs = add_exception_specifier (new_specs, spec,
9861 specs = TREE_CHAIN (specs);
9867 /* Take the tree structure T and replace template parameters used
9868 therein with the argument vector ARGS. IN_DECL is an associated
9869 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
9870 Issue error and warning messages under control of COMPLAIN. Note
9871 that we must be relatively non-tolerant of extensions here, in
9872 order to preserve conformance; if we allow substitutions that
9873 should not be allowed, we may allow argument deductions that should
9874 not succeed, and therefore report ambiguous overload situations
9875 where there are none. In theory, we could allow the substitution,
9876 but indicate that it should have failed, and allow our caller to
9877 make sure that the right thing happens, but we don't try to do this
9880 This function is used for dealing with types, decls and the like;
9881 for expressions, use tsubst_expr or tsubst_copy. */
9884 tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
9888 if (t == NULL_TREE || t == error_mark_node
9889 || t == integer_type_node
9890 || t == void_type_node
9891 || t == char_type_node
9892 || t == unknown_type_node
9893 || TREE_CODE (t) == NAMESPACE_DECL)
9897 return tsubst_decl (t, args, complain);
9899 if (args == NULL_TREE)
9902 if (TREE_CODE (t) == IDENTIFIER_NODE)
9903 type = IDENTIFIER_TYPE_VALUE (t);
9905 type = TREE_TYPE (t);
9907 gcc_assert (type != unknown_type_node);
9909 /* Reuse typedefs. We need to do this to handle dependent attributes,
9910 such as attribute aligned. */
9913 && TYPE_NAME (t) != TYPE_MAIN_DECL (t))
9915 tree decl = TYPE_NAME (t);
9917 if (DECL_CLASS_SCOPE_P (decl)
9918 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl))
9919 && uses_template_parms (DECL_CONTEXT (decl)))
9921 tree tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
9922 tree gen_args = tsubst (DECL_TI_ARGS (decl), args, complain, in_decl);
9923 r = retrieve_specialization (tmpl, gen_args, 0);
9925 else if (DECL_FUNCTION_SCOPE_P (decl)
9926 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl))
9927 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl))))
9928 r = retrieve_local_specialization (decl);
9930 /* The typedef is from a non-template context. */
9936 r = cp_build_qualified_type_real
9937 (r, cp_type_quals (t) | cp_type_quals (r),
9938 complain | tf_ignore_bad_quals);
9941 /* Else we must be instantiating the typedef, so fall through. */
9945 && TREE_CODE (t) != TYPENAME_TYPE
9946 && TREE_CODE (t) != TEMPLATE_TYPE_PARM
9947 && TREE_CODE (t) != IDENTIFIER_NODE
9948 && TREE_CODE (t) != FUNCTION_TYPE
9949 && TREE_CODE (t) != METHOD_TYPE)
9950 type = tsubst (type, args, complain, in_decl);
9951 if (type == error_mark_node)
9952 return error_mark_node;
9954 switch (TREE_CODE (t))
9959 return tsubst_aggr_type (t, args, complain, in_decl,
9960 /*entering_scope=*/0);
9963 case IDENTIFIER_NODE:
9975 if (t == integer_type_node)
9978 if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
9979 && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
9983 tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);
9985 max = tsubst_expr (omax, args, complain, in_decl,
9986 /*integral_constant_expression_p=*/false);
9988 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
9990 if (TREE_CODE (max) == NOP_EXPR
9991 && TREE_SIDE_EFFECTS (omax)
9992 && !TREE_TYPE (max))
9993 TREE_TYPE (max) = TREE_TYPE (TREE_OPERAND (max, 0));
9995 max = fold_decl_constant_value (max);
9997 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
9998 with TREE_SIDE_EFFECTS that indicates this is not an integral
9999 constant expression. */
10000 if (processing_template_decl
10001 && TREE_SIDE_EFFECTS (omax) && TREE_CODE (omax) == NOP_EXPR)
10003 gcc_assert (TREE_CODE (max) == NOP_EXPR);
10004 TREE_SIDE_EFFECTS (max) = 1;
10007 if (TREE_CODE (max) != INTEGER_CST
10008 && !at_function_scope_p ()
10009 && !TREE_SIDE_EFFECTS (max)
10010 && !value_dependent_expression_p (max))
10012 if (complain & tf_error)
10013 error ("array bound is not an integer constant");
10014 return error_mark_node;
10019 Type deduction may fail for any of the following
10022 Attempting to create an array with a size that is
10023 zero or negative. */
10024 if (integer_zerop (max) && !(complain & tf_error))
10025 /* We must fail if performing argument deduction (as
10026 indicated by the state of complain), so that
10027 another substitution can be found. */
10028 return error_mark_node;
10029 else if (TREE_CODE (max) == INTEGER_CST
10030 && INT_CST_LT (max, integer_zero_node))
10032 if (complain & tf_error)
10033 error ("creating array with negative size (%qE)", max);
10035 return error_mark_node;
10038 return compute_array_index_type (NULL_TREE, max);
10041 case TEMPLATE_TYPE_PARM:
10042 case TEMPLATE_TEMPLATE_PARM:
10043 case BOUND_TEMPLATE_TEMPLATE_PARM:
10044 case TEMPLATE_PARM_INDEX:
10049 tree arg = NULL_TREE;
10053 gcc_assert (TREE_VEC_LENGTH (args) > 0);
10054 template_parm_level_and_index (t, &level, &idx);
10056 levels = TMPL_ARGS_DEPTH (args);
10057 if (level <= levels)
10059 arg = TMPL_ARG (args, level, idx);
10061 if (arg && TREE_CODE (arg) == ARGUMENT_PACK_SELECT)
10062 /* See through ARGUMENT_PACK_SELECT arguments. */
10063 arg = ARGUMENT_PACK_SELECT_ARG (arg);
10066 if (arg == error_mark_node)
10067 return error_mark_node;
10068 else if (arg != NULL_TREE)
10070 if (ARGUMENT_PACK_P (arg))
10071 /* If ARG is an argument pack, we don't actually want to
10072 perform a substitution here, because substitutions
10073 for argument packs are only done
10074 element-by-element. We can get to this point when
10075 substituting the type of a non-type template
10076 parameter pack, when that type actually contains
10077 template parameter packs from an outer template, e.g.,
10079 template<typename... Types> struct A {
10080 template<Types... Values> struct B { };
10084 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
10087 gcc_assert (TYPE_P (arg));
10089 /* cv-quals from the template are discarded when
10090 substituting in a function or reference type. */
10091 if (TREE_CODE (arg) == FUNCTION_TYPE
10092 || TREE_CODE (arg) == METHOD_TYPE
10093 || TREE_CODE (arg) == REFERENCE_TYPE)
10094 quals = cp_type_quals (arg);
10096 quals = cp_type_quals (arg) | cp_type_quals (t);
10098 return cp_build_qualified_type_real
10099 (arg, quals, complain | tf_ignore_bad_quals);
10101 else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
10103 /* We are processing a type constructed from a
10104 template template parameter. */
10105 tree argvec = tsubst (TYPE_TI_ARGS (t),
10106 args, complain, in_decl);
10107 if (argvec == error_mark_node)
10108 return error_mark_node;
10110 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
10111 are resolving nested-types in the signature of a
10112 member function templates. Otherwise ARG is a
10113 TEMPLATE_DECL and is the real template to be
10115 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
10116 arg = TYPE_NAME (arg);
10118 r = lookup_template_class (arg,
10120 DECL_CONTEXT (arg),
10121 /*entering_scope=*/0,
10123 return cp_build_qualified_type_real
10124 (r, TYPE_QUALS (t), complain);
10127 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
10132 /* This can happen during the attempted tsubst'ing in
10133 unify. This means that we don't yet have any information
10134 about the template parameter in question. */
10137 /* If we get here, we must have been looking at a parm for a
10138 more deeply nested template. Make a new version of this
10139 template parameter, but with a lower level. */
10140 switch (TREE_CODE (t))
10142 case TEMPLATE_TYPE_PARM:
10143 case TEMPLATE_TEMPLATE_PARM:
10144 case BOUND_TEMPLATE_TEMPLATE_PARM:
10145 if (cp_type_quals (t))
10147 r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
10148 r = cp_build_qualified_type_real
10149 (r, cp_type_quals (t),
10150 complain | (TREE_CODE (t) == TEMPLATE_TYPE_PARM
10151 ? tf_ignore_bad_quals : 0));
10156 TEMPLATE_TYPE_PARM_INDEX (r)
10157 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t),
10158 r, levels, args, complain);
10159 TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r);
10160 TYPE_MAIN_VARIANT (r) = r;
10161 TYPE_POINTER_TO (r) = NULL_TREE;
10162 TYPE_REFERENCE_TO (r) = NULL_TREE;
10164 if (TREE_CODE (r) == TEMPLATE_TEMPLATE_PARM)
10165 /* We have reduced the level of the template
10166 template parameter, but not the levels of its
10167 template parameters, so canonical_type_parameter
10168 will not be able to find the canonical template
10169 template parameter for this level. Thus, we
10170 require structural equality checking to compare
10171 TEMPLATE_TEMPLATE_PARMs. */
10172 SET_TYPE_STRUCTURAL_EQUALITY (r);
10173 else if (TYPE_STRUCTURAL_EQUALITY_P (t))
10174 SET_TYPE_STRUCTURAL_EQUALITY (r);
10176 TYPE_CANONICAL (r) = canonical_type_parameter (r);
10178 if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
10180 tree argvec = tsubst (TYPE_TI_ARGS (t), args,
10181 complain, in_decl);
10182 if (argvec == error_mark_node)
10183 return error_mark_node;
10185 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r)
10186 = build_template_info (TYPE_TI_TEMPLATE (t), argvec);
10191 case TEMPLATE_PARM_INDEX:
10192 r = reduce_template_parm_level (t, type, levels, args, complain);
10196 gcc_unreachable ();
10204 tree purpose, value, chain;
10206 if (t == void_list_node)
10209 purpose = TREE_PURPOSE (t);
10212 purpose = tsubst (purpose, args, complain, in_decl);
10213 if (purpose == error_mark_node)
10214 return error_mark_node;
10216 value = TREE_VALUE (t);
10219 value = tsubst (value, args, complain, in_decl);
10220 if (value == error_mark_node)
10221 return error_mark_node;
10223 chain = TREE_CHAIN (t);
10224 if (chain && chain != void_type_node)
10226 chain = tsubst (chain, args, complain, in_decl);
10227 if (chain == error_mark_node)
10228 return error_mark_node;
10230 if (purpose == TREE_PURPOSE (t)
10231 && value == TREE_VALUE (t)
10232 && chain == TREE_CHAIN (t))
10234 return hash_tree_cons (purpose, value, chain);
10238 /* We should never be tsubsting a binfo. */
10239 gcc_unreachable ();
10242 /* A vector of template arguments. */
10243 gcc_assert (!type);
10244 return tsubst_template_args (t, args, complain, in_decl);
10247 case REFERENCE_TYPE:
10249 enum tree_code code;
10251 if (type == TREE_TYPE (t) && TREE_CODE (type) != METHOD_TYPE)
10254 code = TREE_CODE (t);
10259 Type deduction may fail for any of the following
10262 -- Attempting to create a pointer to reference type.
10263 -- Attempting to create a reference to a reference type or
10264 a reference to void.
10266 Core issue 106 says that creating a reference to a reference
10267 during instantiation is no longer a cause for failure. We
10268 only enforce this check in strict C++98 mode. */
10269 if ((TREE_CODE (type) == REFERENCE_TYPE
10270 && (((cxx_dialect == cxx98) && flag_iso) || code != REFERENCE_TYPE))
10271 || (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE))
10273 static location_t last_loc;
10275 /* We keep track of the last time we issued this error
10276 message to avoid spewing a ton of messages during a
10277 single bad template instantiation. */
10278 if (complain & tf_error
10279 && last_loc != input_location)
10281 if (TREE_CODE (type) == VOID_TYPE)
10282 error ("forming reference to void");
10283 else if (code == POINTER_TYPE)
10284 error ("forming pointer to reference type %qT", type);
10286 error ("forming reference to reference type %qT", type);
10287 last_loc = input_location;
10290 return error_mark_node;
10292 else if (code == POINTER_TYPE)
10294 r = build_pointer_type (type);
10295 if (TREE_CODE (type) == METHOD_TYPE)
10296 r = build_ptrmemfunc_type (r);
10298 else if (TREE_CODE (type) == REFERENCE_TYPE)
10299 /* In C++0x, during template argument substitution, when there is an
10300 attempt to create a reference to a reference type, reference
10301 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
10303 "If a template-argument for a template-parameter T names a type
10304 that is a reference to a type A, an attempt to create the type
10305 'lvalue reference to cv T' creates the type 'lvalue reference to
10306 A,' while an attempt to create the type type rvalue reference to
10307 cv T' creates the type T"
10309 r = cp_build_reference_type
10311 TYPE_REF_IS_RVALUE (t) && TYPE_REF_IS_RVALUE (type));
10313 r = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
10314 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
10316 if (r != error_mark_node)
10317 /* Will this ever be needed for TYPE_..._TO values? */
10324 r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
10325 if (r == error_mark_node || !MAYBE_CLASS_TYPE_P (r))
10329 Type deduction may fail for any of the following
10332 -- Attempting to create "pointer to member of T" when T
10333 is not a class type. */
10334 if (complain & tf_error)
10335 error ("creating pointer to member of non-class type %qT", r);
10336 return error_mark_node;
10338 if (TREE_CODE (type) == REFERENCE_TYPE)
10340 if (complain & tf_error)
10341 error ("creating pointer to member reference type %qT", type);
10342 return error_mark_node;
10344 if (TREE_CODE (type) == VOID_TYPE)
10346 if (complain & tf_error)
10347 error ("creating pointer to member of type void");
10348 return error_mark_node;
10350 gcc_assert (TREE_CODE (type) != METHOD_TYPE);
10351 if (TREE_CODE (type) == FUNCTION_TYPE)
10353 /* The type of the implicit object parameter gets its
10354 cv-qualifiers from the FUNCTION_TYPE. */
10356 tree method_type = build_memfn_type (type, r, cp_type_quals (type));
10357 memptr = build_ptrmemfunc_type (build_pointer_type (method_type));
10358 return cp_build_qualified_type_real (memptr, cp_type_quals (t),
10362 return cp_build_qualified_type_real (build_ptrmem_type (r, type),
10366 case FUNCTION_TYPE:
10371 fntype = tsubst_function_type (t, args, complain, in_decl);
10372 if (fntype == error_mark_node)
10373 return error_mark_node;
10375 /* Substitute the exception specification. */
10376 specs = tsubst_exception_specification (t, args, complain,
10378 if (specs == error_mark_node)
10379 return error_mark_node;
10381 fntype = build_exception_variant (fntype, specs);
10386 tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
10387 if (domain == error_mark_node)
10388 return error_mark_node;
10390 /* As an optimization, we avoid regenerating the array type if
10391 it will obviously be the same as T. */
10392 if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
10395 /* These checks should match the ones in grokdeclarator.
10399 The deduction may fail for any of the following reasons:
10401 -- Attempting to create an array with an element type that
10402 is void, a function type, or a reference type, or [DR337]
10403 an abstract class type. */
10404 if (TREE_CODE (type) == VOID_TYPE
10405 || TREE_CODE (type) == FUNCTION_TYPE
10406 || TREE_CODE (type) == REFERENCE_TYPE)
10408 if (complain & tf_error)
10409 error ("creating array of %qT", type);
10410 return error_mark_node;
10412 if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
10414 if (complain & tf_error)
10415 error ("creating array of %qT, which is an abstract class type",
10417 return error_mark_node;
10420 r = build_cplus_array_type (type, domain);
10422 if (TYPE_USER_ALIGN (t))
10424 TYPE_ALIGN (r) = TYPE_ALIGN (t);
10425 TYPE_USER_ALIGN (r) = 1;
10434 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
10435 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
10437 if (e1 == error_mark_node || e2 == error_mark_node)
10438 return error_mark_node;
10440 return fold_build2_loc (input_location,
10441 TREE_CODE (t), TREE_TYPE (t), e1, e2);
10447 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
10448 if (e == error_mark_node)
10449 return error_mark_node;
10451 return fold_build1_loc (input_location, TREE_CODE (t), TREE_TYPE (t), e);
10454 case TYPENAME_TYPE:
10456 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
10457 in_decl, /*entering_scope=*/1);
10458 tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
10459 complain, in_decl);
10461 if (ctx == error_mark_node || f == error_mark_node)
10462 return error_mark_node;
10464 if (!MAYBE_CLASS_TYPE_P (ctx))
10466 if (complain & tf_error)
10467 error ("%qT is not a class, struct, or union type", ctx);
10468 return error_mark_node;
10470 else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
10472 /* Normally, make_typename_type does not require that the CTX
10473 have complete type in order to allow things like:
10475 template <class T> struct S { typename S<T>::X Y; };
10477 But, such constructs have already been resolved by this
10478 point, so here CTX really should have complete type, unless
10479 it's a partial instantiation. */
10480 if (!(complain & tf_no_class_instantiations))
10481 ctx = complete_type (ctx);
10482 if (!COMPLETE_TYPE_P (ctx))
10484 if (complain & tf_error)
10485 cxx_incomplete_type_error (NULL_TREE, ctx);
10486 return error_mark_node;
10490 f = make_typename_type (ctx, f, typename_type,
10491 (complain & tf_error) | tf_keep_type_decl);
10492 if (f == error_mark_node)
10494 if (TREE_CODE (f) == TYPE_DECL)
10496 complain |= tf_ignore_bad_quals;
10500 if (TREE_CODE (f) != TYPENAME_TYPE)
10502 if (TYPENAME_IS_ENUM_P (t) && TREE_CODE (f) != ENUMERAL_TYPE)
10503 error ("%qT resolves to %qT, which is not an enumeration type",
10505 else if (TYPENAME_IS_CLASS_P (t) && !CLASS_TYPE_P (f))
10506 error ("%qT resolves to %qT, which is is not a class type",
10510 return cp_build_qualified_type_real
10511 (f, cp_type_quals (f) | cp_type_quals (t), complain);
10514 case UNBOUND_CLASS_TEMPLATE:
10516 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
10517 in_decl, /*entering_scope=*/1);
10518 tree name = TYPE_IDENTIFIER (t);
10519 tree parm_list = DECL_TEMPLATE_PARMS (TYPE_NAME (t));
10521 if (ctx == error_mark_node || name == error_mark_node)
10522 return error_mark_node;
10525 parm_list = tsubst_template_parms (parm_list, args, complain);
10526 return make_unbound_class_template (ctx, name, parm_list, complain);
10532 gcc_unreachable ();
10536 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
10537 tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl,
10538 /*integral_constant_expression_p=*/false);
10539 if (e1 == error_mark_node || e2 == error_mark_node)
10540 return error_mark_node;
10542 return build_nt (ARRAY_REF, e1, e2, NULL_TREE, NULL_TREE);
10547 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
10548 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
10549 if (e1 == error_mark_node || e2 == error_mark_node)
10550 return error_mark_node;
10552 return build_qualified_name (/*type=*/NULL_TREE,
10553 e1, e2, QUALIFIED_NAME_IS_TEMPLATE (t));
10560 ++cp_unevaluated_operand;
10561 ++c_inhibit_evaluation_warnings;
10563 type = tsubst_expr (TYPEOF_TYPE_EXPR (t), args,
10565 /*integral_constant_expression_p=*/false);
10567 --cp_unevaluated_operand;
10568 --c_inhibit_evaluation_warnings;
10570 type = finish_typeof (type);
10571 return cp_build_qualified_type_real (type,
10573 | cp_type_quals (type),
10577 case DECLTYPE_TYPE:
10581 ++cp_unevaluated_operand;
10582 ++c_inhibit_evaluation_warnings;
10584 type = tsubst_expr (DECLTYPE_TYPE_EXPR (t), args,
10586 /*integral_constant_expression_p=*/false);
10588 --cp_unevaluated_operand;
10589 --c_inhibit_evaluation_warnings;
10591 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t))
10592 type = lambda_capture_field_type (type);
10593 else if (DECLTYPE_FOR_LAMBDA_RETURN (t))
10594 type = lambda_return_type (type);
10596 type = finish_decltype_type
10597 (type, DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t));
10598 return cp_build_qualified_type_real (type,
10600 | cp_type_quals (type),
10604 case TYPE_ARGUMENT_PACK:
10605 case NONTYPE_ARGUMENT_PACK:
10607 tree r = TYPE_P (t)
10608 ? cxx_make_type (TREE_CODE (t))
10609 : make_node (TREE_CODE (t));
10611 tsubst_template_args (ARGUMENT_PACK_ARGS (t),
10615 SET_ARGUMENT_PACK_ARGS (r, packed_out);
10617 /* For template nontype argument packs, also substitute into
10619 if (TREE_CODE (t) == NONTYPE_ARGUMENT_PACK)
10620 TREE_TYPE (r) = tsubst (TREE_TYPE (t), args, complain, in_decl);
10627 sorry ("use of %qs in template",
10628 tree_code_name [(int) TREE_CODE (t)]);
10629 return error_mark_node;
10633 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
10634 type of the expression on the left-hand side of the "." or "->"
10638 tsubst_baselink (tree baselink, tree object_type,
10639 tree args, tsubst_flags_t complain, tree in_decl)
10642 tree qualifying_scope;
10645 tree template_args = 0;
10646 bool template_id_p = false;
10648 /* A baselink indicates a function from a base class. Both the
10649 BASELINK_ACCESS_BINFO and the base class referenced may
10650 indicate bases of the template class, rather than the
10651 instantiated class. In addition, lookups that were not
10652 ambiguous before may be ambiguous now. Therefore, we perform
10653 the lookup again. */
10654 qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink));
10655 qualifying_scope = tsubst (qualifying_scope, args,
10656 complain, in_decl);
10657 fns = BASELINK_FUNCTIONS (baselink);
10658 optype = tsubst (BASELINK_OPTYPE (baselink), args, complain, in_decl);
10659 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
10661 template_id_p = true;
10662 template_args = TREE_OPERAND (fns, 1);
10663 fns = TREE_OPERAND (fns, 0);
10665 template_args = tsubst_template_args (template_args, args,
10666 complain, in_decl);
10668 name = DECL_NAME (get_first_fn (fns));
10669 if (IDENTIFIER_TYPENAME_P (name))
10670 name = mangle_conv_op_name_for_type (optype);
10671 baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1);
10673 /* If lookup found a single function, mark it as used at this
10674 point. (If it lookup found multiple functions the one selected
10675 later by overload resolution will be marked as used at that
10677 if (BASELINK_P (baselink))
10678 fns = BASELINK_FUNCTIONS (baselink);
10679 if (!template_id_p && !really_overloaded_fn (fns))
10680 mark_used (OVL_CURRENT (fns));
10682 /* Add back the template arguments, if present. */
10683 if (BASELINK_P (baselink) && template_id_p)
10684 BASELINK_FUNCTIONS (baselink)
10685 = build_nt (TEMPLATE_ID_EXPR,
10686 BASELINK_FUNCTIONS (baselink),
10688 /* Update the conversion operator type. */
10689 BASELINK_OPTYPE (baselink) = optype;
10692 object_type = current_class_type;
10693 return adjust_result_of_qualified_name_lookup (baselink,
10698 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
10699 true if the qualified-id will be a postfix-expression in-and-of
10700 itself; false if more of the postfix-expression follows the
10701 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
10705 tsubst_qualified_id (tree qualified_id, tree args,
10706 tsubst_flags_t complain, tree in_decl,
10707 bool done, bool address_p)
10713 tree template_args;
10715 gcc_assert (TREE_CODE (qualified_id) == SCOPE_REF);
10717 /* Figure out what name to look up. */
10718 name = TREE_OPERAND (qualified_id, 1);
10719 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
10721 is_template = true;
10722 template_args = TREE_OPERAND (name, 1);
10724 template_args = tsubst_template_args (template_args, args,
10725 complain, in_decl);
10726 name = TREE_OPERAND (name, 0);
10730 is_template = false;
10731 template_args = NULL_TREE;
10734 /* Substitute into the qualifying scope. When there are no ARGS, we
10735 are just trying to simplify a non-dependent expression. In that
10736 case the qualifying scope may be dependent, and, in any case,
10737 substituting will not help. */
10738 scope = TREE_OPERAND (qualified_id, 0);
10741 scope = tsubst (scope, args, complain, in_decl);
10742 expr = tsubst_copy (name, args, complain, in_decl);
10747 if (dependent_scope_p (scope))
10748 return build_qualified_name (NULL_TREE, scope, expr,
10749 QUALIFIED_NAME_IS_TEMPLATE (qualified_id));
10751 if (!BASELINK_P (name) && !DECL_P (expr))
10753 if (TREE_CODE (expr) == BIT_NOT_EXPR)
10755 /* A BIT_NOT_EXPR is used to represent a destructor. */
10756 if (!check_dtor_name (scope, TREE_OPERAND (expr, 0)))
10758 error ("qualifying type %qT does not match destructor name ~%qT",
10759 scope, TREE_OPERAND (expr, 0));
10760 expr = error_mark_node;
10763 expr = lookup_qualified_name (scope, complete_dtor_identifier,
10764 /*is_type_p=*/0, false);
10767 expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0, false);
10768 if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL
10769 ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL)
10771 if (complain & tf_error)
10773 error ("dependent-name %qE is parsed as a non-type, but "
10774 "instantiation yields a type", qualified_id);
10775 inform (input_location, "say %<typename %E%> if a type is meant", qualified_id);
10777 return error_mark_node;
10783 check_accessibility_of_qualified_id (expr, /*object_type=*/NULL_TREE,
10785 /* Remember that there was a reference to this entity. */
10789 if (expr == error_mark_node || TREE_CODE (expr) == TREE_LIST)
10791 if (complain & tf_error)
10792 qualified_name_lookup_error (scope,
10793 TREE_OPERAND (qualified_id, 1),
10794 expr, input_location);
10795 return error_mark_node;
10799 expr = lookup_template_function (expr, template_args);
10801 if (expr == error_mark_node && complain & tf_error)
10802 qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1),
10803 expr, input_location);
10804 else if (TYPE_P (scope))
10806 expr = (adjust_result_of_qualified_name_lookup
10807 (expr, scope, current_class_type));
10808 expr = (finish_qualified_id_expr
10809 (scope, expr, done, address_p,
10810 QUALIFIED_NAME_IS_TEMPLATE (qualified_id),
10811 /*template_arg_p=*/false));
10814 /* Expressions do not generally have reference type. */
10815 if (TREE_CODE (expr) != SCOPE_REF
10816 /* However, if we're about to form a pointer-to-member, we just
10817 want the referenced member referenced. */
10818 && TREE_CODE (expr) != OFFSET_REF)
10819 expr = convert_from_reference (expr);
10824 /* Like tsubst, but deals with expressions. This function just replaces
10825 template parms; to finish processing the resultant expression, use
10829 tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
10831 enum tree_code code;
10834 if (t == NULL_TREE || t == error_mark_node || args == NULL_TREE)
10837 code = TREE_CODE (t);
10842 r = retrieve_local_specialization (t);
10847 /* This can happen for a parameter name used later in a function
10848 declaration (such as in a late-specified return type). Just
10849 make a dummy decl, since it's only used for its type. */
10850 gcc_assert (cp_unevaluated_operand != 0);
10851 /* We copy T because want to tsubst the PARM_DECL only,
10852 not the following PARM_DECLs that are chained to T. */
10854 r = tsubst_decl (c, args, complain);
10855 /* Give it the template pattern as its context; its true context
10856 hasn't been instantiated yet and this is good enough for
10858 DECL_CONTEXT (r) = DECL_CONTEXT (t);
10861 if (TREE_CODE (r) == ARGUMENT_PACK_SELECT)
10862 r = ARGUMENT_PACK_SELECT_ARG (r);
10871 if (DECL_TEMPLATE_PARM_P (t))
10872 return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
10873 /* There is no need to substitute into namespace-scope
10875 if (DECL_NAMESPACE_SCOPE_P (t))
10877 /* If ARGS is NULL, then T is known to be non-dependent. */
10878 if (args == NULL_TREE)
10879 return integral_constant_value (t);
10881 /* Unfortunately, we cannot just call lookup_name here.
10884 template <int I> int f() {
10886 struct S { void g() { E e = a; } };
10889 When we instantiate f<7>::S::g(), say, lookup_name is not
10890 clever enough to find f<7>::a. */
10892 = tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl,
10893 /*entering_scope=*/0);
10895 for (v = TYPE_VALUES (enum_type);
10897 v = TREE_CHAIN (v))
10898 if (TREE_PURPOSE (v) == DECL_NAME (t))
10899 return TREE_VALUE (v);
10901 /* We didn't find the name. That should never happen; if
10902 name-lookup found it during preliminary parsing, we
10903 should find it again here during instantiation. */
10904 gcc_unreachable ();
10909 if (DECL_CONTEXT (t))
10913 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
10914 /*entering_scope=*/1);
10915 if (ctx != DECL_CONTEXT (t))
10917 tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
10920 if (complain & tf_error)
10921 error ("using invalid field %qD", t);
10922 return error_mark_node;
10931 case FUNCTION_DECL:
10932 if ((DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
10933 || local_variable_p (t))
10934 t = tsubst (t, args, complain, in_decl);
10939 return tsubst_baselink (t, current_class_type, args, complain, in_decl);
10941 case TEMPLATE_DECL:
10942 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
10943 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
10944 args, complain, in_decl);
10945 else if (DECL_FUNCTION_TEMPLATE_P (t) && DECL_MEMBER_TEMPLATE_P (t))
10946 return tsubst (t, args, complain, in_decl);
10947 else if (DECL_CLASS_SCOPE_P (t)
10948 && uses_template_parms (DECL_CONTEXT (t)))
10950 /* Template template argument like the following example need
10953 template <template <class> class TT> struct C {};
10954 template <class T> struct D {
10955 template <class U> struct E {};
10960 We are processing the template argument `E' in #1 for
10961 the template instantiation #2. Originally, `E' is a
10962 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
10963 have to substitute this with one having context `D<int>'. */
10965 tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
10966 return lookup_field (context, DECL_NAME(t), 0, false);
10969 /* Ordinary template template argument. */
10973 case REINTERPRET_CAST_EXPR:
10974 case CONST_CAST_EXPR:
10975 case STATIC_CAST_EXPR:
10976 case DYNAMIC_CAST_EXPR:
10979 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
10980 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
10983 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
10985 /* We only want to compute the number of arguments. */
10986 tree expanded = tsubst_pack_expansion (TREE_OPERAND (t, 0), args,
10987 complain, in_decl);
10990 if (TREE_CODE (expanded) == TREE_VEC)
10991 len = TREE_VEC_LENGTH (expanded);
10993 if (expanded == error_mark_node)
10994 return error_mark_node;
10995 else if (PACK_EXPANSION_P (expanded)
10996 || (TREE_CODE (expanded) == TREE_VEC
10998 && PACK_EXPANSION_P (TREE_VEC_ELT (expanded, len-1))))
11000 if (TREE_CODE (expanded) == TREE_VEC)
11001 expanded = TREE_VEC_ELT (expanded, len - 1);
11003 if (TYPE_P (expanded))
11004 return cxx_sizeof_or_alignof_type (expanded, SIZEOF_EXPR,
11005 complain & tf_error);
11007 return cxx_sizeof_or_alignof_expr (expanded, SIZEOF_EXPR,
11008 complain & tf_error);
11011 return build_int_cst (size_type_node, len);
11017 case TRUTH_NOT_EXPR:
11020 case UNARY_PLUS_EXPR: /* Unary + */
11025 case REALPART_EXPR:
11026 case IMAGPART_EXPR:
11028 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
11029 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
11031 case COMPONENT_REF:
11036 object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
11037 name = TREE_OPERAND (t, 1);
11038 if (TREE_CODE (name) == BIT_NOT_EXPR)
11040 name = tsubst_copy (TREE_OPERAND (name, 0), args,
11041 complain, in_decl);
11042 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
11044 else if (TREE_CODE (name) == SCOPE_REF
11045 && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
11047 tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
11048 complain, in_decl);
11049 name = TREE_OPERAND (name, 1);
11050 name = tsubst_copy (TREE_OPERAND (name, 0), args,
11051 complain, in_decl);
11052 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
11053 name = build_qualified_name (/*type=*/NULL_TREE,
11055 /*template_p=*/false);
11057 else if (TREE_CODE (name) == BASELINK)
11058 name = tsubst_baselink (name,
11059 non_reference (TREE_TYPE (object)),
11063 name = tsubst_copy (name, args, complain, in_decl);
11064 return build_nt (COMPONENT_REF, object, name, NULL_TREE);
11070 case TRUNC_DIV_EXPR:
11071 case CEIL_DIV_EXPR:
11072 case FLOOR_DIV_EXPR:
11073 case ROUND_DIV_EXPR:
11074 case EXACT_DIV_EXPR:
11078 case TRUNC_MOD_EXPR:
11079 case FLOOR_MOD_EXPR:
11080 case TRUTH_ANDIF_EXPR:
11081 case TRUTH_ORIF_EXPR:
11082 case TRUTH_AND_EXPR:
11083 case TRUTH_OR_EXPR:
11096 case COMPOUND_EXPR:
11099 case PREDECREMENT_EXPR:
11100 case PREINCREMENT_EXPR:
11101 case POSTDECREMENT_EXPR:
11102 case POSTINCREMENT_EXPR:
11104 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
11105 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
11108 return build_qualified_name (/*type=*/NULL_TREE,
11109 tsubst_copy (TREE_OPERAND (t, 0),
11110 args, complain, in_decl),
11111 tsubst_copy (TREE_OPERAND (t, 1),
11112 args, complain, in_decl),
11113 QUALIFIED_NAME_IS_TEMPLATE (t));
11118 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
11119 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
11120 NULL_TREE, NULL_TREE);
11124 int n = VL_EXP_OPERAND_LENGTH (t);
11125 tree result = build_vl_exp (CALL_EXPR, n);
11127 for (i = 0; i < n; i++)
11128 TREE_OPERAND (t, i) = tsubst_copy (TREE_OPERAND (t, i), args,
11129 complain, in_decl);
11135 case PSEUDO_DTOR_EXPR:
11138 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
11139 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
11140 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
11141 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
11148 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
11149 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
11150 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
11151 NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
11158 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
11159 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
11160 DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
11161 DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
11165 case TEMPLATE_ID_EXPR:
11167 /* Substituted template arguments */
11168 tree fn = TREE_OPERAND (t, 0);
11169 tree targs = TREE_OPERAND (t, 1);
11171 fn = tsubst_copy (fn, args, complain, in_decl);
11173 targs = tsubst_template_args (targs, args, complain, in_decl);
11175 return lookup_template_function (fn, targs);
11180 tree purpose, value, chain;
11182 if (t == void_list_node)
11185 purpose = TREE_PURPOSE (t);
11187 purpose = tsubst_copy (purpose, args, complain, in_decl);
11188 value = TREE_VALUE (t);
11190 value = tsubst_copy (value, args, complain, in_decl);
11191 chain = TREE_CHAIN (t);
11192 if (chain && chain != void_type_node)
11193 chain = tsubst_copy (chain, args, complain, in_decl);
11194 if (purpose == TREE_PURPOSE (t)
11195 && value == TREE_VALUE (t)
11196 && chain == TREE_CHAIN (t))
11198 return tree_cons (purpose, value, chain);
11203 case ENUMERAL_TYPE:
11205 case TEMPLATE_TYPE_PARM:
11206 case TEMPLATE_TEMPLATE_PARM:
11207 case BOUND_TEMPLATE_TEMPLATE_PARM:
11208 case TEMPLATE_PARM_INDEX:
11210 case REFERENCE_TYPE:
11212 case FUNCTION_TYPE:
11215 case TYPENAME_TYPE:
11216 case UNBOUND_CLASS_TEMPLATE:
11218 case DECLTYPE_TYPE:
11220 return tsubst (t, args, complain, in_decl);
11222 case IDENTIFIER_NODE:
11223 if (IDENTIFIER_TYPENAME_P (t))
11225 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
11226 return mangle_conv_op_name_for_type (new_type);
11232 /* This is handled by tsubst_copy_and_build. */
11233 gcc_unreachable ();
11236 return build_x_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain,
11238 tsubst (TREE_TYPE (t), args, complain, in_decl));
11240 case CLEANUP_POINT_EXPR:
11241 /* We shouldn't have built any of these during initial template
11242 generation. Instead, they should be built during instantiation
11243 in response to the saved STMT_IS_FULL_EXPR_P setting. */
11244 gcc_unreachable ();
11247 mark_used (TREE_OPERAND (t, 1));
11250 case EXPR_PACK_EXPANSION:
11251 error ("invalid use of pack expansion expression");
11252 return error_mark_node;
11254 case NONTYPE_ARGUMENT_PACK:
11255 error ("use %<...%> to expand argument pack");
11256 return error_mark_node;
11263 /* Like tsubst_copy, but specifically for OpenMP clauses. */
11266 tsubst_omp_clauses (tree clauses, tree args, tsubst_flags_t complain,
11269 tree new_clauses = NULL, nc, oc;
11271 for (oc = clauses; oc ; oc = OMP_CLAUSE_CHAIN (oc))
11273 nc = copy_node (oc);
11274 OMP_CLAUSE_CHAIN (nc) = new_clauses;
11277 switch (OMP_CLAUSE_CODE (nc))
11279 case OMP_CLAUSE_LASTPRIVATE:
11280 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc))
11282 OMP_CLAUSE_LASTPRIVATE_STMT (nc) = push_stmt_list ();
11283 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc), args, complain,
11284 in_decl, /*integral_constant_expression_p=*/false);
11285 OMP_CLAUSE_LASTPRIVATE_STMT (nc)
11286 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc));
11289 case OMP_CLAUSE_PRIVATE:
11290 case OMP_CLAUSE_SHARED:
11291 case OMP_CLAUSE_FIRSTPRIVATE:
11292 case OMP_CLAUSE_REDUCTION:
11293 case OMP_CLAUSE_COPYIN:
11294 case OMP_CLAUSE_COPYPRIVATE:
11295 case OMP_CLAUSE_IF:
11296 case OMP_CLAUSE_NUM_THREADS:
11297 case OMP_CLAUSE_SCHEDULE:
11298 case OMP_CLAUSE_COLLAPSE:
11299 OMP_CLAUSE_OPERAND (nc, 0)
11300 = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 0), args, complain,
11301 in_decl, /*integral_constant_expression_p=*/false);
11303 case OMP_CLAUSE_NOWAIT:
11304 case OMP_CLAUSE_ORDERED:
11305 case OMP_CLAUSE_DEFAULT:
11306 case OMP_CLAUSE_UNTIED:
11309 gcc_unreachable ();
11313 return finish_omp_clauses (nreverse (new_clauses));
11316 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
11319 tsubst_copy_asm_operands (tree t, tree args, tsubst_flags_t complain,
11322 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
11324 tree purpose, value, chain;
11329 if (TREE_CODE (t) != TREE_LIST)
11330 return tsubst_copy_and_build (t, args, complain, in_decl,
11331 /*function_p=*/false,
11332 /*integral_constant_expression_p=*/false);
11334 if (t == void_list_node)
11337 purpose = TREE_PURPOSE (t);
11339 purpose = RECUR (purpose);
11340 value = TREE_VALUE (t);
11341 if (value && TREE_CODE (value) != LABEL_DECL)
11342 value = RECUR (value);
11343 chain = TREE_CHAIN (t);
11344 if (chain && chain != void_type_node)
11345 chain = RECUR (chain);
11346 return tree_cons (purpose, value, chain);
11350 /* Substitute one OMP_FOR iterator. */
11353 tsubst_omp_for_iterator (tree t, int i, tree declv, tree initv,
11354 tree condv, tree incrv, tree *clauses,
11355 tree args, tsubst_flags_t complain, tree in_decl,
11356 bool integral_constant_expression_p)
11358 #define RECUR(NODE) \
11359 tsubst_expr ((NODE), args, complain, in_decl, \
11360 integral_constant_expression_p)
11361 tree decl, init, cond, incr, auto_node;
11363 init = TREE_VEC_ELT (OMP_FOR_INIT (t), i);
11364 gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
11365 decl = RECUR (TREE_OPERAND (init, 0));
11366 init = TREE_OPERAND (init, 1);
11367 auto_node = type_uses_auto (TREE_TYPE (decl));
11368 if (auto_node && init)
11370 tree init_expr = init;
11371 if (TREE_CODE (init_expr) == DECL_EXPR)
11372 init_expr = DECL_INITIAL (DECL_EXPR_DECL (init_expr));
11373 init_expr = RECUR (init_expr);
11375 = do_auto_deduction (TREE_TYPE (decl), init_expr, auto_node);
11377 gcc_assert (!type_dependent_expression_p (decl));
11379 if (!CLASS_TYPE_P (TREE_TYPE (decl)))
11381 cond = RECUR (TREE_VEC_ELT (OMP_FOR_COND (t), i));
11382 incr = TREE_VEC_ELT (OMP_FOR_INCR (t), i);
11383 if (TREE_CODE (incr) == MODIFY_EXPR)
11384 incr = build_x_modify_expr (RECUR (TREE_OPERAND (incr, 0)), NOP_EXPR,
11385 RECUR (TREE_OPERAND (incr, 1)),
11388 incr = RECUR (incr);
11389 TREE_VEC_ELT (declv, i) = decl;
11390 TREE_VEC_ELT (initv, i) = init;
11391 TREE_VEC_ELT (condv, i) = cond;
11392 TREE_VEC_ELT (incrv, i) = incr;
11396 if (init && TREE_CODE (init) != DECL_EXPR)
11399 for (c = *clauses; c ; c = OMP_CLAUSE_CHAIN (c))
11401 if ((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_PRIVATE
11402 || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE)
11403 && OMP_CLAUSE_DECL (c) == decl)
11405 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
11406 && OMP_CLAUSE_DECL (c) == decl)
11407 error ("iteration variable %qD should not be firstprivate", decl);
11408 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
11409 && OMP_CLAUSE_DECL (c) == decl)
11410 error ("iteration variable %qD should not be reduction", decl);
11414 c = build_omp_clause (input_location, OMP_CLAUSE_PRIVATE);
11415 OMP_CLAUSE_DECL (c) = decl;
11416 c = finish_omp_clauses (c);
11419 OMP_CLAUSE_CHAIN (c) = *clauses;
11424 cond = TREE_VEC_ELT (OMP_FOR_COND (t), i);
11425 if (COMPARISON_CLASS_P (cond))
11426 cond = build2 (TREE_CODE (cond), boolean_type_node,
11427 RECUR (TREE_OPERAND (cond, 0)),
11428 RECUR (TREE_OPERAND (cond, 1)));
11430 cond = RECUR (cond);
11431 incr = TREE_VEC_ELT (OMP_FOR_INCR (t), i);
11432 switch (TREE_CODE (incr))
11434 case PREINCREMENT_EXPR:
11435 case PREDECREMENT_EXPR:
11436 case POSTINCREMENT_EXPR:
11437 case POSTDECREMENT_EXPR:
11438 incr = build2 (TREE_CODE (incr), TREE_TYPE (decl),
11439 RECUR (TREE_OPERAND (incr, 0)), NULL_TREE);
11442 if (TREE_CODE (TREE_OPERAND (incr, 1)) == PLUS_EXPR
11443 || TREE_CODE (TREE_OPERAND (incr, 1)) == MINUS_EXPR)
11445 tree rhs = TREE_OPERAND (incr, 1);
11446 incr = build2 (MODIFY_EXPR, TREE_TYPE (decl),
11447 RECUR (TREE_OPERAND (incr, 0)),
11448 build2 (TREE_CODE (rhs), TREE_TYPE (decl),
11449 RECUR (TREE_OPERAND (rhs, 0)),
11450 RECUR (TREE_OPERAND (rhs, 1))));
11453 incr = RECUR (incr);
11456 if (TREE_CODE (TREE_OPERAND (incr, 1)) == PLUS_EXPR
11457 || TREE_CODE (TREE_OPERAND (incr, 1)) == MINUS_EXPR)
11459 tree lhs = RECUR (TREE_OPERAND (incr, 0));
11460 incr = build2 (MODIFY_EXPR, TREE_TYPE (decl), lhs,
11461 build2 (TREE_CODE (TREE_OPERAND (incr, 1)),
11462 TREE_TYPE (decl), lhs,
11463 RECUR (TREE_OPERAND (incr, 2))));
11465 else if (TREE_CODE (TREE_OPERAND (incr, 1)) == NOP_EXPR
11466 && (TREE_CODE (TREE_OPERAND (incr, 2)) == PLUS_EXPR
11467 || (TREE_CODE (TREE_OPERAND (incr, 2)) == MINUS_EXPR)))
11469 tree rhs = TREE_OPERAND (incr, 2);
11470 incr = build2 (MODIFY_EXPR, TREE_TYPE (decl),
11471 RECUR (TREE_OPERAND (incr, 0)),
11472 build2 (TREE_CODE (rhs), TREE_TYPE (decl),
11473 RECUR (TREE_OPERAND (rhs, 0)),
11474 RECUR (TREE_OPERAND (rhs, 1))));
11477 incr = RECUR (incr);
11480 incr = RECUR (incr);
11484 TREE_VEC_ELT (declv, i) = decl;
11485 TREE_VEC_ELT (initv, i) = init;
11486 TREE_VEC_ELT (condv, i) = cond;
11487 TREE_VEC_ELT (incrv, i) = incr;
11491 /* Like tsubst_copy for expressions, etc. but also does semantic
11495 tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl,
11496 bool integral_constant_expression_p)
11498 #define RECUR(NODE) \
11499 tsubst_expr ((NODE), args, complain, in_decl, \
11500 integral_constant_expression_p)
11504 if (t == NULL_TREE || t == error_mark_node)
11507 if (EXPR_HAS_LOCATION (t))
11508 input_location = EXPR_LOCATION (t);
11509 if (STATEMENT_CODE_P (TREE_CODE (t)))
11510 current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
11512 switch (TREE_CODE (t))
11514 case STATEMENT_LIST:
11516 tree_stmt_iterator i;
11517 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
11518 RECUR (tsi_stmt (i));
11522 case CTOR_INITIALIZER:
11523 finish_mem_initializers (tsubst_initializer_list
11524 (TREE_OPERAND (t, 0), args));
11528 finish_return_stmt (RECUR (TREE_OPERAND (t, 0)));
11532 tmp = RECUR (EXPR_STMT_EXPR (t));
11533 if (EXPR_STMT_STMT_EXPR_RESULT (t))
11534 finish_stmt_expr_expr (tmp, cur_stmt_expr);
11536 finish_expr_stmt (tmp);
11540 do_using_directive (RECUR (USING_STMT_NAMESPACE (t)));
11548 decl = DECL_EXPR_DECL (t);
11549 if (TREE_CODE (decl) == LABEL_DECL)
11550 finish_label_decl (DECL_NAME (decl));
11551 else if (TREE_CODE (decl) == USING_DECL)
11553 tree scope = USING_DECL_SCOPE (decl);
11554 tree name = DECL_NAME (decl);
11557 scope = RECUR (scope);
11558 decl = lookup_qualified_name (scope, name,
11559 /*is_type_p=*/false,
11560 /*complain=*/false);
11561 if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
11562 qualified_name_lookup_error (scope, name, decl, input_location);
11564 do_local_using_decl (decl, scope, name);
11568 init = DECL_INITIAL (decl);
11569 decl = tsubst (decl, args, complain, in_decl);
11570 if (decl != error_mark_node)
11572 /* By marking the declaration as instantiated, we avoid
11573 trying to instantiate it. Since instantiate_decl can't
11574 handle local variables, and since we've already done
11575 all that needs to be done, that's the right thing to
11577 if (TREE_CODE (decl) == VAR_DECL)
11578 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
11579 if (TREE_CODE (decl) == VAR_DECL
11580 && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
11581 /* Anonymous aggregates are a special case. */
11582 finish_anon_union (decl);
11585 maybe_push_decl (decl);
11586 if (TREE_CODE (decl) == VAR_DECL
11587 && DECL_PRETTY_FUNCTION_P (decl))
11589 /* For __PRETTY_FUNCTION__ we have to adjust the
11591 const char *const name
11592 = cxx_printable_name (current_function_decl, 2);
11593 init = cp_fname_init (name, &TREE_TYPE (decl));
11597 tree t = RECUR (init);
11600 /* If we had an initializer but it
11601 instantiated to nothing,
11602 value-initialize the object. This will
11603 only occur when the initializer was a
11604 pack expansion where the parameter packs
11605 used in that expansion were of length
11607 init = build_value_init (TREE_TYPE (decl));
11612 cp_finish_decl (decl, init, false, NULL_TREE, 0);
11617 /* A DECL_EXPR can also be used as an expression, in the condition
11618 clause of an if/for/while construct. */
11623 stmt = begin_for_stmt ();
11624 RECUR (FOR_INIT_STMT (t));
11625 finish_for_init_stmt (stmt);
11626 tmp = RECUR (FOR_COND (t));
11627 finish_for_cond (tmp, stmt);
11628 tmp = RECUR (FOR_EXPR (t));
11629 finish_for_expr (tmp, stmt);
11630 RECUR (FOR_BODY (t));
11631 finish_for_stmt (stmt);
11635 stmt = begin_while_stmt ();
11636 tmp = RECUR (WHILE_COND (t));
11637 finish_while_stmt_cond (tmp, stmt);
11638 RECUR (WHILE_BODY (t));
11639 finish_while_stmt (stmt);
11643 stmt = begin_do_stmt ();
11644 RECUR (DO_BODY (t));
11645 finish_do_body (stmt);
11646 tmp = RECUR (DO_COND (t));
11647 finish_do_stmt (tmp, stmt);
11651 stmt = begin_if_stmt ();
11652 tmp = RECUR (IF_COND (t));
11653 finish_if_stmt_cond (tmp, stmt);
11654 RECUR (THEN_CLAUSE (t));
11655 finish_then_clause (stmt);
11657 if (ELSE_CLAUSE (t))
11659 begin_else_clause (stmt);
11660 RECUR (ELSE_CLAUSE (t));
11661 finish_else_clause (stmt);
11664 finish_if_stmt (stmt);
11668 if (BIND_EXPR_BODY_BLOCK (t))
11669 stmt = begin_function_body ();
11671 stmt = begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t)
11672 ? BCS_TRY_BLOCK : 0);
11674 RECUR (BIND_EXPR_BODY (t));
11676 if (BIND_EXPR_BODY_BLOCK (t))
11677 finish_function_body (stmt);
11679 finish_compound_stmt (stmt);
11683 finish_break_stmt ();
11686 case CONTINUE_STMT:
11687 finish_continue_stmt ();
11691 stmt = begin_switch_stmt ();
11692 tmp = RECUR (SWITCH_STMT_COND (t));
11693 finish_switch_cond (tmp, stmt);
11694 RECUR (SWITCH_STMT_BODY (t));
11695 finish_switch_stmt (stmt);
11698 case CASE_LABEL_EXPR:
11699 finish_case_label (EXPR_LOCATION (t),
11700 RECUR (CASE_LOW (t)),
11701 RECUR (CASE_HIGH (t)));
11706 tree decl = LABEL_EXPR_LABEL (t);
11709 label = finish_label_stmt (DECL_NAME (decl));
11710 if (DECL_ATTRIBUTES (decl) != NULL_TREE)
11711 cplus_decl_attributes (&label, DECL_ATTRIBUTES (decl), 0);
11716 tmp = GOTO_DESTINATION (t);
11717 if (TREE_CODE (tmp) != LABEL_DECL)
11718 /* Computed goto's must be tsubst'd into. On the other hand,
11719 non-computed gotos must not be; the identifier in question
11720 will have no binding. */
11723 tmp = DECL_NAME (tmp);
11724 finish_goto_stmt (tmp);
11728 tmp = finish_asm_stmt
11729 (ASM_VOLATILE_P (t),
11730 RECUR (ASM_STRING (t)),
11731 tsubst_copy_asm_operands (ASM_OUTPUTS (t), args, complain, in_decl),
11732 tsubst_copy_asm_operands (ASM_INPUTS (t), args, complain, in_decl),
11733 tsubst_copy_asm_operands (ASM_CLOBBERS (t), args, complain, in_decl),
11734 tsubst_copy_asm_operands (ASM_LABELS (t), args, complain, in_decl));
11736 tree asm_expr = tmp;
11737 if (TREE_CODE (asm_expr) == CLEANUP_POINT_EXPR)
11738 asm_expr = TREE_OPERAND (asm_expr, 0);
11739 ASM_INPUT_P (asm_expr) = ASM_INPUT_P (t);
11746 stmt = begin_try_block ();
11747 RECUR (TRY_STMTS (t));
11748 finish_cleanup_try_block (stmt);
11749 finish_cleanup (RECUR (TRY_HANDLERS (t)), stmt);
11753 tree compound_stmt = NULL_TREE;
11755 if (FN_TRY_BLOCK_P (t))
11756 stmt = begin_function_try_block (&compound_stmt);
11758 stmt = begin_try_block ();
11760 RECUR (TRY_STMTS (t));
11762 if (FN_TRY_BLOCK_P (t))
11763 finish_function_try_block (stmt);
11765 finish_try_block (stmt);
11767 RECUR (TRY_HANDLERS (t));
11768 if (FN_TRY_BLOCK_P (t))
11769 finish_function_handler_sequence (stmt, compound_stmt);
11771 finish_handler_sequence (stmt);
11777 tree decl = HANDLER_PARMS (t);
11781 decl = tsubst (decl, args, complain, in_decl);
11782 /* Prevent instantiate_decl from trying to instantiate
11783 this variable. We've already done all that needs to be
11785 if (decl != error_mark_node)
11786 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
11788 stmt = begin_handler ();
11789 finish_handler_parms (decl, stmt);
11790 RECUR (HANDLER_BODY (t));
11791 finish_handler (stmt);
11796 tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
11799 case STATIC_ASSERT:
11802 tsubst_expr (STATIC_ASSERT_CONDITION (t),
11805 /*integral_constant_expression_p=*/true);
11806 finish_static_assert (condition,
11807 STATIC_ASSERT_MESSAGE (t),
11808 STATIC_ASSERT_SOURCE_LOCATION (t),
11809 /*member_p=*/false);
11814 tmp = tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t),
11815 args, complain, in_decl);
11816 stmt = begin_omp_parallel ();
11817 RECUR (OMP_PARALLEL_BODY (t));
11818 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp, stmt))
11819 = OMP_PARALLEL_COMBINED (t);
11823 tmp = tsubst_omp_clauses (OMP_TASK_CLAUSES (t),
11824 args, complain, in_decl);
11825 stmt = begin_omp_task ();
11826 RECUR (OMP_TASK_BODY (t));
11827 finish_omp_task (tmp, stmt);
11832 tree clauses, body, pre_body;
11833 tree declv, initv, condv, incrv;
11836 clauses = tsubst_omp_clauses (OMP_FOR_CLAUSES (t),
11837 args, complain, in_decl);
11838 declv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
11839 initv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
11840 condv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
11841 incrv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
11843 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (t)); i++)
11844 tsubst_omp_for_iterator (t, i, declv, initv, condv, incrv,
11845 &clauses, args, complain, in_decl,
11846 integral_constant_expression_p);
11848 stmt = begin_omp_structured_block ();
11850 for (i = 0; i < TREE_VEC_LENGTH (initv); i++)
11851 if (TREE_VEC_ELT (initv, i) == NULL
11852 || TREE_CODE (TREE_VEC_ELT (initv, i)) != DECL_EXPR)
11853 TREE_VEC_ELT (initv, i) = RECUR (TREE_VEC_ELT (initv, i));
11854 else if (CLASS_TYPE_P (TREE_TYPE (TREE_VEC_ELT (initv, i))))
11856 tree init = RECUR (TREE_VEC_ELT (initv, i));
11857 gcc_assert (init == TREE_VEC_ELT (declv, i));
11858 TREE_VEC_ELT (initv, i) = NULL_TREE;
11862 tree decl_expr = TREE_VEC_ELT (initv, i);
11863 tree init = DECL_INITIAL (DECL_EXPR_DECL (decl_expr));
11864 gcc_assert (init != NULL);
11865 TREE_VEC_ELT (initv, i) = RECUR (init);
11866 DECL_INITIAL (DECL_EXPR_DECL (decl_expr)) = NULL;
11868 DECL_INITIAL (DECL_EXPR_DECL (decl_expr)) = init;
11871 pre_body = push_stmt_list ();
11872 RECUR (OMP_FOR_PRE_BODY (t));
11873 pre_body = pop_stmt_list (pre_body);
11875 body = push_stmt_list ();
11876 RECUR (OMP_FOR_BODY (t));
11877 body = pop_stmt_list (body);
11879 t = finish_omp_for (EXPR_LOCATION (t), declv, initv, condv, incrv,
11880 body, pre_body, clauses);
11882 add_stmt (finish_omp_structured_block (stmt));
11888 tmp = tsubst_omp_clauses (OMP_CLAUSES (t), args, complain, in_decl);
11889 stmt = push_stmt_list ();
11890 RECUR (OMP_BODY (t));
11891 stmt = pop_stmt_list (stmt);
11894 OMP_BODY (t) = stmt;
11895 OMP_CLAUSES (t) = tmp;
11903 stmt = push_stmt_list ();
11904 RECUR (OMP_BODY (t));
11905 stmt = pop_stmt_list (stmt);
11908 OMP_BODY (t) = stmt;
11913 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t));
11915 tree op1 = TREE_OPERAND (t, 1);
11916 tree lhs = RECUR (TREE_OPERAND (op1, 0));
11917 tree rhs = RECUR (TREE_OPERAND (op1, 1));
11918 finish_omp_atomic (TREE_CODE (op1), lhs, rhs);
11922 case EXPR_PACK_EXPANSION:
11923 error ("invalid use of pack expansion expression");
11924 return error_mark_node;
11926 case NONTYPE_ARGUMENT_PACK:
11927 error ("use %<...%> to expand argument pack");
11928 return error_mark_node;
11931 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t)));
11933 return tsubst_copy_and_build (t, args, complain, in_decl,
11934 /*function_p=*/false,
11935 integral_constant_expression_p);
11942 /* T is a postfix-expression that is not being used in a function
11943 call. Return the substituted version of T. */
11946 tsubst_non_call_postfix_expression (tree t, tree args,
11947 tsubst_flags_t complain,
11950 if (TREE_CODE (t) == SCOPE_REF)
11951 t = tsubst_qualified_id (t, args, complain, in_decl,
11952 /*done=*/false, /*address_p=*/false);
11954 t = tsubst_copy_and_build (t, args, complain, in_decl,
11955 /*function_p=*/false,
11956 /*integral_constant_expression_p=*/false);
11961 /* Like tsubst but deals with expressions and performs semantic
11962 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
11965 tsubst_copy_and_build (tree t,
11967 tsubst_flags_t complain,
11970 bool integral_constant_expression_p)
11972 #define RECUR(NODE) \
11973 tsubst_copy_and_build (NODE, args, complain, in_decl, \
11974 /*function_p=*/false, \
11975 integral_constant_expression_p)
11979 if (t == NULL_TREE || t == error_mark_node)
11982 switch (TREE_CODE (t))
11986 /* Fall through. */
11987 case IDENTIFIER_NODE:
11991 bool non_integral_constant_expression_p;
11992 const char *error_msg;
11994 if (IDENTIFIER_TYPENAME_P (t))
11996 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
11997 t = mangle_conv_op_name_for_type (new_type);
12000 /* Look up the name. */
12001 decl = lookup_name (t);
12003 /* By convention, expressions use ERROR_MARK_NODE to indicate
12004 failure, not NULL_TREE. */
12005 if (decl == NULL_TREE)
12006 decl = error_mark_node;
12008 decl = finish_id_expression (t, decl, NULL_TREE,
12010 integral_constant_expression_p,
12011 /*allow_non_integral_constant_expression_p=*/false,
12012 &non_integral_constant_expression_p,
12013 /*template_p=*/false,
12015 /*address_p=*/false,
12016 /*template_arg_p=*/false,
12021 if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE)
12022 decl = unqualified_name_lookup_error (decl);
12026 case TEMPLATE_ID_EXPR:
12029 tree templ = RECUR (TREE_OPERAND (t, 0));
12030 tree targs = TREE_OPERAND (t, 1);
12033 targs = tsubst_template_args (targs, args, complain, in_decl);
12035 if (TREE_CODE (templ) == COMPONENT_REF)
12037 object = TREE_OPERAND (templ, 0);
12038 templ = TREE_OPERAND (templ, 1);
12041 object = NULL_TREE;
12042 templ = lookup_template_function (templ, targs);
12045 return build3 (COMPONENT_REF, TREE_TYPE (templ),
12046 object, templ, NULL_TREE);
12048 return baselink_for_fns (templ);
12053 tree r = RECUR (TREE_OPERAND (t, 0));
12055 if (REFERENCE_REF_P (t))
12057 /* A type conversion to reference type will be enclosed in
12058 such an indirect ref, but the substitution of the cast
12059 will have also added such an indirect ref. */
12060 if (TREE_CODE (TREE_TYPE (r)) == REFERENCE_TYPE)
12061 r = convert_from_reference (r);
12064 r = build_x_indirect_ref (r, RO_UNARY_STAR, complain);
12070 (tsubst (TREE_TYPE (t), args, complain, in_decl),
12071 RECUR (TREE_OPERAND (t, 0)));
12074 case REINTERPRET_CAST_EXPR:
12075 case CONST_CAST_EXPR:
12076 case DYNAMIC_CAST_EXPR:
12077 case STATIC_CAST_EXPR:
12082 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
12083 if (integral_constant_expression_p
12084 && !cast_valid_in_integral_constant_expression_p (type))
12086 if (complain & tf_error)
12087 error ("a cast to a type other than an integral or "
12088 "enumeration type cannot appear in a constant-expression");
12089 return error_mark_node;
12092 op = RECUR (TREE_OPERAND (t, 0));
12094 switch (TREE_CODE (t))
12097 return build_functional_cast (type, op, complain);
12098 case REINTERPRET_CAST_EXPR:
12099 return build_reinterpret_cast (type, op, complain);
12100 case CONST_CAST_EXPR:
12101 return build_const_cast (type, op, complain);
12102 case DYNAMIC_CAST_EXPR:
12103 return build_dynamic_cast (type, op, complain);
12104 case STATIC_CAST_EXPR:
12105 return build_static_cast (type, op, complain);
12107 gcc_unreachable ();
12111 case POSTDECREMENT_EXPR:
12112 case POSTINCREMENT_EXPR:
12113 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
12114 args, complain, in_decl);
12115 return build_x_unary_op (TREE_CODE (t), op1, complain);
12117 case PREDECREMENT_EXPR:
12118 case PREINCREMENT_EXPR:
12122 case TRUTH_NOT_EXPR:
12123 case UNARY_PLUS_EXPR: /* Unary + */
12124 case REALPART_EXPR:
12125 case IMAGPART_EXPR:
12126 return build_x_unary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0)),
12130 op1 = TREE_OPERAND (t, 0);
12131 if (TREE_CODE (op1) == SCOPE_REF)
12132 op1 = tsubst_qualified_id (op1, args, complain, in_decl,
12133 /*done=*/true, /*address_p=*/true);
12135 op1 = tsubst_non_call_postfix_expression (op1, args, complain,
12137 if (TREE_CODE (op1) == LABEL_DECL)
12138 return finish_label_address_expr (DECL_NAME (op1),
12139 EXPR_LOCATION (op1));
12140 return build_x_unary_op (ADDR_EXPR, op1, complain);
12145 case TRUNC_DIV_EXPR:
12146 case CEIL_DIV_EXPR:
12147 case FLOOR_DIV_EXPR:
12148 case ROUND_DIV_EXPR:
12149 case EXACT_DIV_EXPR:
12153 case TRUNC_MOD_EXPR:
12154 case FLOOR_MOD_EXPR:
12155 case TRUTH_ANDIF_EXPR:
12156 case TRUTH_ORIF_EXPR:
12157 case TRUTH_AND_EXPR:
12158 case TRUTH_OR_EXPR:
12173 return build_x_binary_op
12175 RECUR (TREE_OPERAND (t, 0)),
12176 (TREE_NO_WARNING (TREE_OPERAND (t, 0))
12178 : TREE_CODE (TREE_OPERAND (t, 0))),
12179 RECUR (TREE_OPERAND (t, 1)),
12180 (TREE_NO_WARNING (TREE_OPERAND (t, 1))
12182 : TREE_CODE (TREE_OPERAND (t, 1))),
12183 /*overloaded_p=*/NULL,
12187 return tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
12188 /*address_p=*/false);
12190 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
12191 args, complain, in_decl);
12192 return build_x_array_ref (op1, RECUR (TREE_OPERAND (t, 1)), complain);
12195 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
12196 return tsubst_copy (t, args, complain, in_decl);
12200 op1 = TREE_OPERAND (t, 0);
12203 /* When there are no ARGS, we are trying to evaluate a
12204 non-dependent expression from the parser. Trying to do
12205 the substitutions may not work. */
12207 op1 = TREE_TYPE (op1);
12211 ++cp_unevaluated_operand;
12212 ++c_inhibit_evaluation_warnings;
12213 op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
12214 /*function_p=*/false,
12215 /*integral_constant_expression_p=*/false);
12216 --cp_unevaluated_operand;
12217 --c_inhibit_evaluation_warnings;
12220 return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t),
12221 complain & tf_error);
12223 return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t),
12224 complain & tf_error);
12228 tree r = build_x_modify_expr
12229 (RECUR (TREE_OPERAND (t, 0)),
12230 TREE_CODE (TREE_OPERAND (t, 1)),
12231 RECUR (TREE_OPERAND (t, 2)),
12233 /* TREE_NO_WARNING must be set if either the expression was
12234 parenthesized or it uses an operator such as >>= rather
12235 than plain assignment. In the former case, it was already
12236 set and must be copied. In the latter case,
12237 build_x_modify_expr sets it and it must not be reset
12239 if (TREE_NO_WARNING (t))
12240 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
12245 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
12246 args, complain, in_decl);
12247 /* Remember that there was a reference to this entity. */
12250 return build_x_arrow (op1);
12254 tree placement = RECUR (TREE_OPERAND (t, 0));
12255 tree init = RECUR (TREE_OPERAND (t, 3));
12256 VEC(tree,gc) *placement_vec;
12257 VEC(tree,gc) *init_vec;
12260 if (placement == NULL_TREE)
12261 placement_vec = NULL;
12264 placement_vec = make_tree_vector ();
12265 for (; placement != NULL_TREE; placement = TREE_CHAIN (placement))
12266 VEC_safe_push (tree, gc, placement_vec, TREE_VALUE (placement));
12269 /* If there was an initializer in the original tree, but it
12270 instantiated to an empty list, then we should pass a
12271 non-NULL empty vector to tell build_new that it was an
12272 empty initializer() rather than no initializer. This can
12273 only happen when the initializer is a pack expansion whose
12274 parameter packs are of length zero. */
12275 if (init == NULL_TREE && TREE_OPERAND (t, 3) == NULL_TREE)
12279 init_vec = make_tree_vector ();
12280 if (init == void_zero_node)
12281 gcc_assert (init_vec != NULL);
12284 for (; init != NULL_TREE; init = TREE_CHAIN (init))
12285 VEC_safe_push (tree, gc, init_vec, TREE_VALUE (init));
12289 ret = build_new (&placement_vec,
12290 RECUR (TREE_OPERAND (t, 1)),
12291 RECUR (TREE_OPERAND (t, 2)),
12293 NEW_EXPR_USE_GLOBAL (t),
12296 if (placement_vec != NULL)
12297 release_tree_vector (placement_vec);
12298 if (init_vec != NULL)
12299 release_tree_vector (init_vec);
12305 return delete_sanity
12306 (RECUR (TREE_OPERAND (t, 0)),
12307 RECUR (TREE_OPERAND (t, 1)),
12308 DELETE_EXPR_USE_VEC (t),
12309 DELETE_EXPR_USE_GLOBAL (t));
12311 case COMPOUND_EXPR:
12312 return build_x_compound_expr (RECUR (TREE_OPERAND (t, 0)),
12313 RECUR (TREE_OPERAND (t, 1)),
12319 VEC(tree,gc) *call_args;
12320 unsigned int nargs, i;
12325 function = CALL_EXPR_FN (t);
12326 /* When we parsed the expression, we determined whether or
12327 not Koenig lookup should be performed. */
12328 koenig_p = KOENIG_LOOKUP_P (t);
12329 if (TREE_CODE (function) == SCOPE_REF)
12331 qualified_p = true;
12332 function = tsubst_qualified_id (function, args, complain, in_decl,
12334 /*address_p=*/false);
12338 if (TREE_CODE (function) == COMPONENT_REF)
12340 tree op = TREE_OPERAND (function, 1);
12342 qualified_p = (TREE_CODE (op) == SCOPE_REF
12343 || (BASELINK_P (op)
12344 && BASELINK_QUALIFIED_P (op)));
12347 qualified_p = false;
12349 function = tsubst_copy_and_build (function, args, complain,
12352 integral_constant_expression_p);
12354 if (BASELINK_P (function))
12355 qualified_p = true;
12358 nargs = call_expr_nargs (t);
12359 call_args = make_tree_vector ();
12360 for (i = 0; i < nargs; ++i)
12362 tree arg = CALL_EXPR_ARG (t, i);
12364 if (!PACK_EXPANSION_P (arg))
12365 VEC_safe_push (tree, gc, call_args,
12366 RECUR (CALL_EXPR_ARG (t, i)));
12369 /* Expand the pack expansion and push each entry onto
12371 arg = tsubst_pack_expansion (arg, args, complain, in_decl);
12372 if (TREE_CODE (arg) == TREE_VEC)
12374 unsigned int len, j;
12376 len = TREE_VEC_LENGTH (arg);
12377 for (j = 0; j < len; ++j)
12379 tree value = TREE_VEC_ELT (arg, j);
12380 if (value != NULL_TREE)
12381 value = convert_from_reference (value);
12382 VEC_safe_push (tree, gc, call_args, value);
12387 /* A partial substitution. Add one entry. */
12388 VEC_safe_push (tree, gc, call_args, arg);
12393 /* We do not perform argument-dependent lookup if normal
12394 lookup finds a non-function, in accordance with the
12395 expected resolution of DR 218. */
12397 && ((is_overloaded_fn (function)
12398 /* If lookup found a member function, the Koenig lookup is
12399 not appropriate, even if an unqualified-name was used
12400 to denote the function. */
12401 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function)))
12402 || TREE_CODE (function) == IDENTIFIER_NODE)
12403 /* Only do this when substitution turns a dependent call
12404 into a non-dependent call. */
12405 && type_dependent_expression_p_push (t)
12406 && !any_type_dependent_arguments_p (call_args))
12407 function = perform_koenig_lookup (function, call_args);
12409 if (TREE_CODE (function) == IDENTIFIER_NODE)
12411 unqualified_name_lookup_error (function);
12412 release_tree_vector (call_args);
12413 return error_mark_node;
12416 /* Remember that there was a reference to this entity. */
12417 if (DECL_P (function))
12418 mark_used (function);
12420 if (TREE_CODE (function) == OFFSET_REF)
12421 ret = build_offset_ref_call_from_tree (function, &call_args);
12422 else if (TREE_CODE (function) == COMPONENT_REF)
12424 if (!BASELINK_P (TREE_OPERAND (function, 1)))
12425 ret = finish_call_expr (function, &call_args,
12426 /*disallow_virtual=*/false,
12427 /*koenig_p=*/false,
12430 ret = (build_new_method_call
12431 (TREE_OPERAND (function, 0),
12432 TREE_OPERAND (function, 1),
12433 &call_args, NULL_TREE,
12434 qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL,
12439 ret = finish_call_expr (function, &call_args,
12440 /*disallow_virtual=*/qualified_p,
12444 release_tree_vector (call_args);
12450 return build_x_conditional_expr
12451 (RECUR (TREE_OPERAND (t, 0)),
12452 RECUR (TREE_OPERAND (t, 1)),
12453 RECUR (TREE_OPERAND (t, 2)),
12456 case PSEUDO_DTOR_EXPR:
12457 return finish_pseudo_destructor_expr
12458 (RECUR (TREE_OPERAND (t, 0)),
12459 RECUR (TREE_OPERAND (t, 1)),
12460 RECUR (TREE_OPERAND (t, 2)));
12464 tree purpose, value, chain;
12466 if (t == void_list_node)
12469 if ((TREE_PURPOSE (t) && PACK_EXPANSION_P (TREE_PURPOSE (t)))
12470 || (TREE_VALUE (t) && PACK_EXPANSION_P (TREE_VALUE (t))))
12472 /* We have pack expansions, so expand those and
12473 create a new list out of it. */
12474 tree purposevec = NULL_TREE;
12475 tree valuevec = NULL_TREE;
12479 /* Expand the argument expressions. */
12480 if (TREE_PURPOSE (t))
12481 purposevec = tsubst_pack_expansion (TREE_PURPOSE (t), args,
12482 complain, in_decl);
12483 if (TREE_VALUE (t))
12484 valuevec = tsubst_pack_expansion (TREE_VALUE (t), args,
12485 complain, in_decl);
12487 /* Build the rest of the list. */
12488 chain = TREE_CHAIN (t);
12489 if (chain && chain != void_type_node)
12490 chain = RECUR (chain);
12492 /* Determine the number of arguments. */
12493 if (purposevec && TREE_CODE (purposevec) == TREE_VEC)
12495 len = TREE_VEC_LENGTH (purposevec);
12496 gcc_assert (!valuevec || len == TREE_VEC_LENGTH (valuevec));
12498 else if (TREE_CODE (valuevec) == TREE_VEC)
12499 len = TREE_VEC_LENGTH (valuevec);
12502 /* Since we only performed a partial substitution into
12503 the argument pack, we only return a single list
12505 if (purposevec == TREE_PURPOSE (t)
12506 && valuevec == TREE_VALUE (t)
12507 && chain == TREE_CHAIN (t))
12510 return tree_cons (purposevec, valuevec, chain);
12513 /* Convert the argument vectors into a TREE_LIST */
12517 /* Grab the Ith values. */
12519 purpose = purposevec ? TREE_VEC_ELT (purposevec, i)
12522 = valuevec ? convert_from_reference (TREE_VEC_ELT (valuevec, i))
12525 /* Build the list (backwards). */
12526 chain = tree_cons (purpose, value, chain);
12532 purpose = TREE_PURPOSE (t);
12534 purpose = RECUR (purpose);
12535 value = TREE_VALUE (t);
12537 value = RECUR (value);
12538 chain = TREE_CHAIN (t);
12539 if (chain && chain != void_type_node)
12540 chain = RECUR (chain);
12541 if (purpose == TREE_PURPOSE (t)
12542 && value == TREE_VALUE (t)
12543 && chain == TREE_CHAIN (t))
12545 return tree_cons (purpose, value, chain);
12548 case COMPONENT_REF:
12554 object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
12555 args, complain, in_decl);
12556 /* Remember that there was a reference to this entity. */
12557 if (DECL_P (object))
12558 mark_used (object);
12559 object_type = TREE_TYPE (object);
12561 member = TREE_OPERAND (t, 1);
12562 if (BASELINK_P (member))
12563 member = tsubst_baselink (member,
12564 non_reference (TREE_TYPE (object)),
12565 args, complain, in_decl);
12567 member = tsubst_copy (member, args, complain, in_decl);
12568 if (member == error_mark_node)
12569 return error_mark_node;
12571 if (object_type && !CLASS_TYPE_P (object_type))
12573 if (SCALAR_TYPE_P (object_type))
12575 tree s = NULL_TREE;
12576 tree dtor = member;
12578 if (TREE_CODE (dtor) == SCOPE_REF)
12580 s = TREE_OPERAND (dtor, 0);
12581 dtor = TREE_OPERAND (dtor, 1);
12583 if (TREE_CODE (dtor) == BIT_NOT_EXPR)
12585 dtor = TREE_OPERAND (dtor, 0);
12587 return finish_pseudo_destructor_expr (object, s, dtor);
12591 else if (TREE_CODE (member) == SCOPE_REF
12592 && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
12597 /* Lookup the template functions now that we know what the
12599 tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
12600 args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
12601 member = lookup_qualified_name (TREE_OPERAND (member, 0), tmpl,
12602 /*is_type_p=*/false,
12603 /*complain=*/false);
12604 if (BASELINK_P (member))
12606 BASELINK_FUNCTIONS (member)
12607 = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
12609 member = (adjust_result_of_qualified_name_lookup
12610 (member, BINFO_TYPE (BASELINK_BINFO (member)),
12615 qualified_name_lookup_error (object_type, tmpl, member,
12617 return error_mark_node;
12620 else if (TREE_CODE (member) == SCOPE_REF
12621 && !CLASS_TYPE_P (TREE_OPERAND (member, 0))
12622 && TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL)
12624 if (complain & tf_error)
12626 if (TYPE_P (TREE_OPERAND (member, 0)))
12627 error ("%qT is not a class or namespace",
12628 TREE_OPERAND (member, 0));
12630 error ("%qD is not a class or namespace",
12631 TREE_OPERAND (member, 0));
12633 return error_mark_node;
12635 else if (TREE_CODE (member) == FIELD_DECL)
12636 return finish_non_static_data_member (member, object, NULL_TREE);
12638 return finish_class_member_access_expr (object, member,
12639 /*template_p=*/false,
12645 (RECUR (TREE_OPERAND (t, 0)));
12649 VEC(constructor_elt,gc) *n;
12650 constructor_elt *ce;
12651 unsigned HOST_WIDE_INT idx;
12652 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
12653 bool process_index_p;
12655 bool need_copy_p = false;
12658 if (type == error_mark_node)
12659 return error_mark_node;
12661 /* digest_init will do the wrong thing if we let it. */
12662 if (type && TYPE_PTRMEMFUNC_P (type))
12665 /* We do not want to process the index of aggregate
12666 initializers as they are identifier nodes which will be
12667 looked up by digest_init. */
12668 process_index_p = !(type && MAYBE_CLASS_TYPE_P (type));
12670 n = VEC_copy (constructor_elt, gc, CONSTRUCTOR_ELTS (t));
12671 newlen = VEC_length (constructor_elt, n);
12672 for (idx = 0; VEC_iterate (constructor_elt, n, idx, ce); idx++)
12674 if (ce->index && process_index_p)
12675 ce->index = RECUR (ce->index);
12677 if (PACK_EXPANSION_P (ce->value))
12679 /* Substitute into the pack expansion. */
12680 ce->value = tsubst_pack_expansion (ce->value, args, complain,
12683 if (ce->value == error_mark_node)
12685 else if (TREE_VEC_LENGTH (ce->value) == 1)
12686 /* Just move the argument into place. */
12687 ce->value = TREE_VEC_ELT (ce->value, 0);
12690 /* Update the length of the final CONSTRUCTOR
12691 arguments vector, and note that we will need to
12693 newlen = newlen + TREE_VEC_LENGTH (ce->value) - 1;
12694 need_copy_p = true;
12698 ce->value = RECUR (ce->value);
12703 VEC(constructor_elt,gc) *old_n = n;
12705 n = VEC_alloc (constructor_elt, gc, newlen);
12706 for (idx = 0; VEC_iterate (constructor_elt, old_n, idx, ce);
12709 if (TREE_CODE (ce->value) == TREE_VEC)
12711 int i, len = TREE_VEC_LENGTH (ce->value);
12712 for (i = 0; i < len; ++i)
12713 CONSTRUCTOR_APPEND_ELT (n, 0,
12714 TREE_VEC_ELT (ce->value, i));
12717 CONSTRUCTOR_APPEND_ELT (n, 0, ce->value);
12721 r = build_constructor (init_list_type_node, n);
12722 CONSTRUCTOR_IS_DIRECT_INIT (r) = CONSTRUCTOR_IS_DIRECT_INIT (t);
12724 if (TREE_HAS_CONSTRUCTOR (t))
12725 return finish_compound_literal (type, r);
12732 tree operand_0 = RECUR (TREE_OPERAND (t, 0));
12733 if (TYPE_P (operand_0))
12734 return get_typeid (operand_0);
12735 return build_typeid (operand_0);
12745 tree r = tsubst_copy (t, args, complain, in_decl);
12747 if (TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
12748 /* If the original type was a reference, we'll be wrapped in
12749 the appropriate INDIRECT_REF. */
12750 r = convert_from_reference (r);
12755 return build_x_va_arg (RECUR (TREE_OPERAND (t, 0)),
12756 tsubst_copy (TREE_TYPE (t), args, complain,
12759 case OFFSETOF_EXPR:
12760 return finish_offsetof (RECUR (TREE_OPERAND (t, 0)));
12764 tree type1 = tsubst_copy (TRAIT_EXPR_TYPE1 (t), args,
12765 complain, in_decl);
12767 tree type2 = TRAIT_EXPR_TYPE2 (t);
12769 type2 = tsubst_copy (type2, args, complain, in_decl);
12771 return finish_trait_expr (TRAIT_EXPR_KIND (t), type1, type2);
12776 tree old_stmt_expr = cur_stmt_expr;
12777 tree stmt_expr = begin_stmt_expr ();
12779 cur_stmt_expr = stmt_expr;
12780 tsubst_expr (STMT_EXPR_STMT (t), args, complain, in_decl,
12781 integral_constant_expression_p);
12782 stmt_expr = finish_stmt_expr (stmt_expr, false);
12783 cur_stmt_expr = old_stmt_expr;
12785 /* If the resulting list of expression statement is empty,
12786 fold it further into void_zero_node. */
12787 if (empty_expr_stmt_p (stmt_expr))
12788 stmt_expr = void_zero_node;
12794 t = tsubst_copy (t, args, complain, in_decl);
12795 /* As in finish_id_expression, we resolve enumeration constants
12796 to their underlying values. */
12797 if (TREE_CODE (t) == CONST_DECL)
12799 used_types_insert (TREE_TYPE (t));
12800 return DECL_INITIAL (t);
12806 tree r = build_lambda_expr ();
12808 tree type = tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
12809 TREE_TYPE (r) = type;
12810 CLASSTYPE_LAMBDA_EXPR (type) = r;
12812 LAMBDA_EXPR_LOCATION (r)
12813 = LAMBDA_EXPR_LOCATION (t);
12814 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r)
12815 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t);
12816 LAMBDA_EXPR_MUTABLE_P (r) = LAMBDA_EXPR_MUTABLE_P (t);
12817 LAMBDA_EXPR_DISCRIMINATOR (r)
12818 = (LAMBDA_EXPR_DISCRIMINATOR (t));
12819 LAMBDA_EXPR_CAPTURE_LIST (r)
12820 = RECUR (LAMBDA_EXPR_CAPTURE_LIST (t));
12821 LAMBDA_EXPR_THIS_CAPTURE (r)
12822 = RECUR (LAMBDA_EXPR_THIS_CAPTURE (t));
12823 LAMBDA_EXPR_EXTRA_SCOPE (r)
12824 = RECUR (LAMBDA_EXPR_EXTRA_SCOPE (t));
12826 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
12827 determine_visibility (TYPE_NAME (type));
12828 /* Now that we know visibility, instantiate the type so we have a
12829 declaration of the op() for later calls to lambda_function. */
12830 complete_type (type);
12832 type = tsubst (LAMBDA_EXPR_RETURN_TYPE (t), args, complain, in_decl);
12834 apply_lambda_return_type (r, type);
12836 return build_lambda_object (r);
12840 /* Handle Objective-C++ constructs, if appropriate. */
12843 = objcp_tsubst_copy_and_build (t, args, complain,
12844 in_decl, /*function_p=*/false);
12848 return tsubst_copy (t, args, complain, in_decl);
12854 /* Verify that the instantiated ARGS are valid. For type arguments,
12855 make sure that the type's linkage is ok. For non-type arguments,
12856 make sure they are constants if they are integral or enumerations.
12857 Emit an error under control of COMPLAIN, and return TRUE on error. */
12860 check_instantiated_arg (tree tmpl, tree t, tsubst_flags_t complain)
12862 if (ARGUMENT_PACK_P (t))
12864 tree vec = ARGUMENT_PACK_ARGS (t);
12865 int len = TREE_VEC_LENGTH (vec);
12866 bool result = false;
12869 for (i = 0; i < len; ++i)
12870 if (check_instantiated_arg (tmpl, TREE_VEC_ELT (vec, i), complain))
12874 else if (TYPE_P (t))
12876 /* [basic.link]: A name with no linkage (notably, the name
12877 of a class or enumeration declared in a local scope)
12878 shall not be used to declare an entity with linkage.
12879 This implies that names with no linkage cannot be used as
12882 DR 757 relaxes this restriction for C++0x. */
12883 tree nt = (cxx_dialect > cxx98 ? NULL_TREE
12884 : no_linkage_check (t, /*relaxed_p=*/false));
12888 /* DR 488 makes use of a type with no linkage cause
12889 type deduction to fail. */
12890 if (complain & tf_error)
12892 if (TYPE_ANONYMOUS_P (nt))
12893 error ("%qT is/uses anonymous type", t);
12895 error ("template argument for %qD uses local type %qT",
12900 /* In order to avoid all sorts of complications, we do not
12901 allow variably-modified types as template arguments. */
12902 else if (variably_modified_type_p (t, NULL_TREE))
12904 if (complain & tf_error)
12905 error ("%qT is a variably modified type", t);
12909 /* A non-type argument of integral or enumerated type must be a
12911 else if (TREE_TYPE (t)
12912 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t))
12913 && !TREE_CONSTANT (t))
12915 if (complain & tf_error)
12916 error ("integral expression %qE is not constant", t);
12923 check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain)
12925 int ix, len = DECL_NTPARMS (tmpl);
12926 bool result = false;
12928 for (ix = 0; ix != len; ix++)
12930 if (check_instantiated_arg (tmpl, TREE_VEC_ELT (args, ix), complain))
12933 if (result && (complain & tf_error))
12934 error (" trying to instantiate %qD", tmpl);
12938 /* Instantiate the indicated variable or function template TMPL with
12939 the template arguments in TARG_PTR. */
12942 instantiate_template (tree tmpl, tree orig_args, tsubst_flags_t complain)
12944 tree targ_ptr = orig_args;
12948 HOST_WIDE_INT saved_processing_template_decl;
12950 if (tmpl == error_mark_node)
12951 return error_mark_node;
12953 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
12955 /* If this function is a clone, handle it specially. */
12956 if (DECL_CLONED_FUNCTION_P (tmpl))
12961 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
12962 DECL_CLONED_FUNCTION. */
12963 spec = instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl),
12964 targ_ptr, complain);
12965 if (spec == error_mark_node)
12966 return error_mark_node;
12968 /* Look for the clone. */
12969 FOR_EACH_CLONE (clone, spec)
12970 if (DECL_NAME (clone) == DECL_NAME (tmpl))
12972 /* We should always have found the clone by now. */
12973 gcc_unreachable ();
12977 /* Check to see if we already have this specialization. */
12978 gen_tmpl = most_general_template (tmpl);
12979 if (tmpl != gen_tmpl)
12980 /* The TMPL is a partial instantiation. To get a full set of
12981 arguments we must add the arguments used to perform the
12982 partial instantiation. */
12983 targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl),
12986 /* It would be nice to avoid hashing here and then again in tsubst_decl,
12987 but it doesn't seem to be on the hot path. */
12988 spec = retrieve_specialization (gen_tmpl, targ_ptr, 0);
12990 gcc_assert (tmpl == gen_tmpl
12991 || ((fndecl = retrieve_specialization (tmpl, orig_args, 0))
12993 || fndecl == NULL_TREE);
12995 if (spec != NULL_TREE)
12998 if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr),
13000 return error_mark_node;
13002 /* We are building a FUNCTION_DECL, during which the access of its
13003 parameters and return types have to be checked. However this
13004 FUNCTION_DECL which is the desired context for access checking
13005 is not built yet. We solve this chicken-and-egg problem by
13006 deferring all checks until we have the FUNCTION_DECL. */
13007 push_deferring_access_checks (dk_deferred);
13009 /* Although PROCESSING_TEMPLATE_DECL may be true at this point
13010 (because, for example, we have encountered a non-dependent
13011 function call in the body of a template function and must now
13012 determine which of several overloaded functions will be called),
13013 within the instantiation itself we are not processing a
13015 saved_processing_template_decl = processing_template_decl;
13016 processing_template_decl = 0;
13017 /* Substitute template parameters to obtain the specialization. */
13018 fndecl = tsubst (DECL_TEMPLATE_RESULT (gen_tmpl),
13019 targ_ptr, complain, gen_tmpl);
13020 processing_template_decl = saved_processing_template_decl;
13021 if (fndecl == error_mark_node)
13022 return error_mark_node;
13024 /* Now we know the specialization, compute access previously
13026 push_access_scope (fndecl);
13028 /* Some typedefs referenced from within the template code need to be access
13029 checked at template instantiation time, i.e now. These types were
13030 added to the template at parsing time. Let's get those and perfom
13031 the acces checks then. */
13032 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (tmpl), targ_ptr);
13033 perform_deferred_access_checks ();
13034 pop_access_scope (fndecl);
13035 pop_deferring_access_checks ();
13037 /* The DECL_TI_TEMPLATE should always be the immediate parent
13038 template, not the most general template. */
13039 DECL_TI_TEMPLATE (fndecl) = tmpl;
13041 /* If we've just instantiated the main entry point for a function,
13042 instantiate all the alternate entry points as well. We do this
13043 by cloning the instantiation of the main entry point, not by
13044 instantiating the template clones. */
13045 if (TREE_CHAIN (gen_tmpl) && DECL_CLONED_FUNCTION_P (TREE_CHAIN (gen_tmpl)))
13046 clone_function_decl (fndecl, /*update_method_vec_p=*/0);
13051 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
13052 NARGS elements of the arguments that are being used when calling
13053 it. TARGS is a vector into which the deduced template arguments
13056 Return zero for success, 2 for an incomplete match that doesn't resolve
13057 all the types, and 1 for complete failure. An error message will be
13058 printed only for an incomplete match.
13060 If FN is a conversion operator, or we are trying to produce a specific
13061 specialization, RETURN_TYPE is the return type desired.
13063 The EXPLICIT_TARGS are explicit template arguments provided via a
13066 The parameter STRICT is one of:
13069 We are deducing arguments for a function call, as in
13070 [temp.deduct.call].
13073 We are deducing arguments for a conversion function, as in
13074 [temp.deduct.conv].
13077 We are deducing arguments when doing an explicit instantiation
13078 as in [temp.explicit], when determining an explicit specialization
13079 as in [temp.expl.spec], or when taking the address of a function
13080 template, as in [temp.deduct.funcaddr]. */
13083 fn_type_unification (tree fn,
13084 tree explicit_targs,
13087 unsigned int nargs,
13089 unification_kind_t strict,
13095 bool incomplete_argument_packs_p = false;
13097 gcc_assert (TREE_CODE (fn) == TEMPLATE_DECL);
13099 fntype = TREE_TYPE (fn);
13100 if (explicit_targs)
13104 The specified template arguments must match the template
13105 parameters in kind (i.e., type, nontype, template), and there
13106 must not be more arguments than there are parameters;
13107 otherwise type deduction fails.
13109 Nontype arguments must match the types of the corresponding
13110 nontype template parameters, or must be convertible to the
13111 types of the corresponding nontype parameters as specified in
13112 _temp.arg.nontype_, otherwise type deduction fails.
13114 All references in the function type of the function template
13115 to the corresponding template parameters are replaced by the
13116 specified template argument values. If a substitution in a
13117 template parameter or in the function type of the function
13118 template results in an invalid type, type deduction fails. */
13119 tree tparms = DECL_INNERMOST_TEMPLATE_PARMS (fn);
13120 int i, len = TREE_VEC_LENGTH (tparms);
13121 tree converted_args;
13122 bool incomplete = false;
13124 if (explicit_targs == error_mark_node)
13128 = (coerce_template_parms (tparms, explicit_targs, NULL_TREE, tf_none,
13129 /*require_all_args=*/false,
13130 /*use_default_args=*/false));
13131 if (converted_args == error_mark_node)
13134 /* Substitute the explicit args into the function type. This is
13135 necessary so that, for instance, explicitly declared function
13136 arguments can match null pointed constants. If we were given
13137 an incomplete set of explicit args, we must not do semantic
13138 processing during substitution as we could create partial
13140 for (i = 0; i < len; i++)
13142 tree parm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
13143 bool parameter_pack = false;
13145 /* Dig out the actual parm. */
13146 if (TREE_CODE (parm) == TYPE_DECL
13147 || TREE_CODE (parm) == TEMPLATE_DECL)
13149 parm = TREE_TYPE (parm);
13150 parameter_pack = TEMPLATE_TYPE_PARAMETER_PACK (parm);
13152 else if (TREE_CODE (parm) == PARM_DECL)
13154 parm = DECL_INITIAL (parm);
13155 parameter_pack = TEMPLATE_PARM_PARAMETER_PACK (parm);
13158 if (parameter_pack)
13162 template_parm_level_and_index (parm, &level, &idx);
13164 /* Mark the argument pack as "incomplete". We could
13165 still deduce more arguments during unification. */
13166 targ = TMPL_ARG (converted_args, level, idx);
13169 ARGUMENT_PACK_INCOMPLETE_P(targ) = 1;
13170 ARGUMENT_PACK_EXPLICIT_ARGS (targ)
13171 = ARGUMENT_PACK_ARGS (targ);
13174 /* We have some incomplete argument packs. */
13175 incomplete_argument_packs_p = true;
13179 if (incomplete_argument_packs_p)
13180 /* Any substitution is guaranteed to be incomplete if there
13181 are incomplete argument packs, because we can still deduce
13185 incomplete = NUM_TMPL_ARGS (explicit_targs) != NUM_TMPL_ARGS (targs);
13187 processing_template_decl += incomplete;
13188 fntype = tsubst (fntype, converted_args, tf_none, NULL_TREE);
13189 processing_template_decl -= incomplete;
13191 if (fntype == error_mark_node)
13194 /* Place the explicitly specified arguments in TARGS. */
13195 for (i = NUM_TMPL_ARGS (converted_args); i--;)
13196 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i);
13199 /* Never do unification on the 'this' parameter. */
13200 parms = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (fntype));
13206 parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms);
13207 new_args = XALLOCAVEC (tree, nargs + 1);
13208 new_args[0] = return_type;
13209 memcpy (new_args + 1, args, nargs * sizeof (tree));
13214 /* We allow incomplete unification without an error message here
13215 because the standard doesn't seem to explicitly prohibit it. Our
13216 callers must be ready to deal with unification failures in any
13218 result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
13219 targs, parms, args, nargs, /*subr=*/0,
13222 if (result == 0 && incomplete_argument_packs_p)
13224 int i, len = NUM_TMPL_ARGS (targs);
13226 /* Clear the "incomplete" flags on all argument packs. */
13227 for (i = 0; i < len; i++)
13229 tree arg = TREE_VEC_ELT (targs, i);
13230 if (ARGUMENT_PACK_P (arg))
13232 ARGUMENT_PACK_INCOMPLETE_P (arg) = 0;
13233 ARGUMENT_PACK_EXPLICIT_ARGS (arg) = NULL_TREE;
13238 /* Now that we have bindings for all of the template arguments,
13239 ensure that the arguments deduced for the template template
13240 parameters have compatible template parameter lists. We cannot
13241 check this property before we have deduced all template
13242 arguments, because the template parameter types of a template
13243 template parameter might depend on prior template parameters
13244 deduced after the template template parameter. The following
13245 ill-formed example illustrates this issue:
13247 template<typename T, template<T> class C> void f(C<5>, T);
13249 template<int N> struct X {};
13252 f(X<5>(), 5l); // error: template argument deduction fails
13255 The template parameter list of 'C' depends on the template type
13256 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
13257 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
13258 time that we deduce 'C'. */
13260 && !template_template_parm_bindings_ok_p
13261 (DECL_INNERMOST_TEMPLATE_PARMS (fn), targs))
13265 /* All is well so far. Now, check:
13269 When all template arguments have been deduced, all uses of
13270 template parameters in nondeduced contexts are replaced with
13271 the corresponding deduced argument values. If the
13272 substitution results in an invalid type, as described above,
13273 type deduction fails. */
13275 tree substed = tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE);
13276 if (substed == error_mark_node)
13279 /* If we're looking for an exact match, check that what we got
13280 is indeed an exact match. It might not be if some template
13281 parameters are used in non-deduced contexts. */
13282 if (strict == DEDUCE_EXACT)
13287 = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (substed));
13289 sarg = tree_cons (NULL_TREE, TREE_TYPE (substed), sarg);
13290 for (i = 0; i < nargs && sarg; ++i, sarg = TREE_CHAIN (sarg))
13291 if (!same_type_p (args[i], TREE_VALUE (sarg)))
13299 /* Adjust types before performing type deduction, as described in
13300 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
13301 sections are symmetric. PARM is the type of a function parameter
13302 or the return type of the conversion function. ARG is the type of
13303 the argument passed to the call, or the type of the value
13304 initialized with the result of the conversion function.
13305 ARG_EXPR is the original argument expression, which may be null. */
13308 maybe_adjust_types_for_deduction (unification_kind_t strict,
13322 /* Swap PARM and ARG throughout the remainder of this
13323 function; the handling is precisely symmetric since PARM
13324 will initialize ARG rather than vice versa. */
13332 /* Core issue #873: Do the DR606 thing (see below) for these cases,
13333 too, but here handle it by stripping the reference from PARM
13334 rather than by adding it to ARG. */
13335 if (TREE_CODE (*parm) == REFERENCE_TYPE
13336 && TYPE_REF_IS_RVALUE (*parm)
13337 && TREE_CODE (TREE_TYPE (*parm)) == TEMPLATE_TYPE_PARM
13338 && cp_type_quals (TREE_TYPE (*parm)) == TYPE_UNQUALIFIED
13339 && TREE_CODE (*arg) == REFERENCE_TYPE
13340 && !TYPE_REF_IS_RVALUE (*arg))
13341 *parm = TREE_TYPE (*parm);
13342 /* Nothing else to do in this case. */
13346 gcc_unreachable ();
13349 if (TREE_CODE (*parm) != REFERENCE_TYPE)
13351 /* [temp.deduct.call]
13353 If P is not a reference type:
13355 --If A is an array type, the pointer type produced by the
13356 array-to-pointer standard conversion (_conv.array_) is
13357 used in place of A for type deduction; otherwise,
13359 --If A is a function type, the pointer type produced by
13360 the function-to-pointer standard conversion
13361 (_conv.func_) is used in place of A for type deduction;
13364 --If A is a cv-qualified type, the top level
13365 cv-qualifiers of A's type are ignored for type
13367 if (TREE_CODE (*arg) == ARRAY_TYPE)
13368 *arg = build_pointer_type (TREE_TYPE (*arg));
13369 else if (TREE_CODE (*arg) == FUNCTION_TYPE)
13370 *arg = build_pointer_type (*arg);
13372 *arg = TYPE_MAIN_VARIANT (*arg);
13375 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
13376 of the form T&&, where T is a template parameter, and the argument
13377 is an lvalue, T is deduced as A& */
13378 if (TREE_CODE (*parm) == REFERENCE_TYPE
13379 && TYPE_REF_IS_RVALUE (*parm)
13380 && TREE_CODE (TREE_TYPE (*parm)) == TEMPLATE_TYPE_PARM
13381 && cp_type_quals (TREE_TYPE (*parm)) == TYPE_UNQUALIFIED
13382 && arg_expr && real_lvalue_p (arg_expr))
13383 *arg = build_reference_type (*arg);
13385 /* [temp.deduct.call]
13387 If P is a cv-qualified type, the top level cv-qualifiers
13388 of P's type are ignored for type deduction. If P is a
13389 reference type, the type referred to by P is used for
13391 *parm = TYPE_MAIN_VARIANT (*parm);
13392 if (TREE_CODE (*parm) == REFERENCE_TYPE)
13394 *parm = TREE_TYPE (*parm);
13395 result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
13398 /* DR 322. For conversion deduction, remove a reference type on parm
13399 too (which has been swapped into ARG). */
13400 if (strict == DEDUCE_CONV && TREE_CODE (*arg) == REFERENCE_TYPE)
13401 *arg = TREE_TYPE (*arg);
13406 /* Most parms like fn_type_unification.
13408 If SUBR is 1, we're being called recursively (to unify the
13409 arguments of a function or method parameter of a function
13413 type_unification_real (tree tparms,
13417 unsigned int xnargs,
13419 unification_kind_t strict,
13422 tree parm, arg, arg_expr;
13424 int ntparms = TREE_VEC_LENGTH (tparms);
13426 int saw_undeduced = 0;
13429 unsigned int nargs;
13432 gcc_assert (TREE_CODE (tparms) == TREE_VEC);
13433 gcc_assert (xparms == NULL_TREE || TREE_CODE (xparms) == TREE_LIST);
13434 gcc_assert (ntparms > 0);
13436 /* Reset the number of non-defaulted template arguments contained
13438 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs) = NULL_TREE;
13443 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL | UNIFY_ALLOW_MORE_CV_QUAL
13444 | UNIFY_ALLOW_DERIVED);
13448 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
13452 sub_strict = UNIFY_ALLOW_NONE;
13456 gcc_unreachable ();
13465 while (parms && parms != void_list_node
13468 if (TREE_CODE (TREE_VALUE (parms)) == TYPE_PACK_EXPANSION)
13471 parm = TREE_VALUE (parms);
13472 parms = TREE_CHAIN (parms);
13477 if (arg == error_mark_node)
13479 if (arg == unknown_type_node)
13480 /* We can't deduce anything from this, but we might get all the
13481 template args from other function args. */
13484 /* Conversions will be performed on a function argument that
13485 corresponds with a function parameter that contains only
13486 non-deducible template parameters and explicitly specified
13487 template parameters. */
13488 if (!uses_template_parms (parm))
13493 type = TREE_TYPE (arg);
13497 if (same_type_p (parm, type))
13499 if (strict != DEDUCE_EXACT
13500 && can_convert_arg (parm, type, TYPE_P (arg) ? NULL_TREE : arg,
13509 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
13510 if (type_unknown_p (arg))
13512 /* [temp.deduct.type]
13514 A template-argument can be deduced from a pointer to
13515 function or pointer to member function argument if
13516 the set of overloaded functions does not contain
13517 function templates and at most one of a set of
13518 overloaded functions provides a unique match. */
13519 if (resolve_overloaded_unification
13520 (tparms, targs, parm, arg, strict, sub_strict))
13526 arg = unlowered_expr_type (arg);
13527 if (arg == error_mark_node)
13532 int arg_strict = sub_strict;
13535 arg_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg,
13538 if (arg == init_list_type_node && arg_expr)
13540 if (unify (tparms, targs, parm, arg, arg_strict))
13547 && parms != void_list_node
13548 && TREE_CODE (TREE_VALUE (parms)) == TYPE_PACK_EXPANSION)
13550 /* Unify the remaining arguments with the pack expansion type. */
13552 tree parmvec = make_tree_vec (1);
13554 /* Allocate a TREE_VEC and copy in all of the arguments */
13555 argvec = make_tree_vec (nargs - ia);
13556 for (i = 0; ia < nargs; ++ia, ++i)
13557 TREE_VEC_ELT (argvec, i) = args[ia];
13559 /* Copy the parameter into parmvec. */
13560 TREE_VEC_ELT (parmvec, 0) = TREE_VALUE (parms);
13561 if (unify_pack_expansion (tparms, targs, parmvec, argvec, strict,
13562 /*call_args_p=*/true, /*subr=*/subr))
13565 /* Advance to the end of the list of parameters. */
13566 parms = TREE_CHAIN (parms);
13569 /* Fail if we've reached the end of the parm list, and more args
13570 are present, and the parm list isn't variadic. */
13571 if (ia < nargs && parms == void_list_node)
13573 /* Fail if parms are left and they don't have default values. */
13574 if (parms && parms != void_list_node
13575 && TREE_PURPOSE (parms) == NULL_TREE)
13579 for (i = 0; i < ntparms; i++)
13580 if (!TREE_VEC_ELT (targs, i))
13584 if (TREE_VEC_ELT (tparms, i) == error_mark_node)
13587 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
13589 /* If this is an undeduced nontype parameter that depends on
13590 a type parameter, try another pass; its type may have been
13591 deduced from a later argument than the one from which
13592 this parameter can be deduced. */
13593 if (TREE_CODE (tparm) == PARM_DECL
13594 && uses_template_parms (TREE_TYPE (tparm))
13595 && !saw_undeduced++)
13598 /* Core issue #226 (C++0x) [temp.deduct]:
13600 If a template argument has not been deduced, its
13601 default template argument, if any, is used.
13603 When we are in C++98 mode, TREE_PURPOSE will either
13604 be NULL_TREE or ERROR_MARK_NODE, so we do not need
13605 to explicitly check cxx_dialect here. */
13606 if (TREE_PURPOSE (TREE_VEC_ELT (tparms, i)))
13608 tree parm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
13609 tree arg = TREE_PURPOSE (TREE_VEC_ELT (tparms, i));
13610 arg = tsubst_template_arg (arg, targs, tf_none, NULL_TREE);
13611 arg = convert_template_argument (parm, arg, targs, tf_none,
13613 if (arg == error_mark_node)
13617 TREE_VEC_ELT (targs, i) = arg;
13618 /* The position of the first default template argument,
13619 is also the number of non-defaulted arguments in TARGS.
13621 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs))
13622 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs, i);
13627 /* If the type parameter is a parameter pack, then it will
13628 be deduced to an empty parameter pack. */
13629 if (template_parameter_pack_p (tparm))
13633 if (TREE_CODE (tparm) == TEMPLATE_PARM_INDEX)
13635 arg = make_node (NONTYPE_ARGUMENT_PACK);
13636 TREE_TYPE (arg) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm));
13637 TREE_CONSTANT (arg) = 1;
13640 arg = cxx_make_type (TYPE_ARGUMENT_PACK);
13642 SET_ARGUMENT_PACK_ARGS (arg, make_tree_vec (0));
13644 TREE_VEC_ELT (targs, i) = arg;
13650 #ifdef ENABLE_CHECKING
13651 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs))
13652 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs, TREE_VEC_LENGTH (targs));
13658 /* Subroutine of type_unification_real. Args are like the variables
13659 at the call site. ARG is an overloaded function (or template-id);
13660 we try deducing template args from each of the overloads, and if
13661 only one succeeds, we go with that. Modifies TARGS and returns
13662 true on success. */
13665 resolve_overloaded_unification (tree tparms,
13669 unification_kind_t strict,
13672 tree tempargs = copy_node (targs);
13674 tree goodfn = NULL_TREE;
13677 if (TREE_CODE (arg) == ADDR_EXPR)
13679 arg = TREE_OPERAND (arg, 0);
13685 if (TREE_CODE (arg) == COMPONENT_REF)
13686 /* Handle `&x' where `x' is some static or non-static member
13688 arg = TREE_OPERAND (arg, 1);
13690 if (TREE_CODE (arg) == OFFSET_REF)
13691 arg = TREE_OPERAND (arg, 1);
13693 /* Strip baselink information. */
13694 if (BASELINK_P (arg))
13695 arg = BASELINK_FUNCTIONS (arg);
13697 if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
13699 /* If we got some explicit template args, we need to plug them into
13700 the affected templates before we try to unify, in case the
13701 explicit args will completely resolve the templates in question. */
13703 tree expl_subargs = TREE_OPERAND (arg, 1);
13704 arg = TREE_OPERAND (arg, 0);
13706 for (; arg; arg = OVL_NEXT (arg))
13708 tree fn = OVL_CURRENT (arg);
13709 tree subargs, elem;
13711 if (TREE_CODE (fn) != TEMPLATE_DECL)
13714 ++processing_template_decl;
13715 subargs = get_bindings (fn, DECL_TEMPLATE_RESULT (fn),
13716 expl_subargs, /*check_ret=*/false);
13719 elem = tsubst (TREE_TYPE (fn), subargs, tf_none, NULL_TREE);
13720 if (try_one_overload (tparms, targs, tempargs, parm,
13721 elem, strict, sub_strict, addr_p)
13722 && (!goodfn || !decls_match (goodfn, elem)))
13728 --processing_template_decl;
13731 else if (TREE_CODE (arg) != OVERLOAD
13732 && TREE_CODE (arg) != FUNCTION_DECL)
13733 /* If ARG is, for example, "(0, &f)" then its type will be unknown
13734 -- but the deduction does not succeed because the expression is
13735 not just the function on its own. */
13738 for (; arg; arg = OVL_NEXT (arg))
13739 if (try_one_overload (tparms, targs, tempargs, parm,
13740 TREE_TYPE (OVL_CURRENT (arg)),
13741 strict, sub_strict, addr_p)
13742 && (!goodfn || !decls_match (goodfn, OVL_CURRENT (arg))))
13744 goodfn = OVL_CURRENT (arg);
13748 /* [temp.deduct.type] A template-argument can be deduced from a pointer
13749 to function or pointer to member function argument if the set of
13750 overloaded functions does not contain function templates and at most
13751 one of a set of overloaded functions provides a unique match.
13753 So if we found multiple possibilities, we return success but don't
13754 deduce anything. */
13758 int i = TREE_VEC_LENGTH (targs);
13760 if (TREE_VEC_ELT (tempargs, i))
13761 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i);
13769 /* Core DR 115: In contexts where deduction is done and fails, or in
13770 contexts where deduction is not done, if a template argument list is
13771 specified and it, along with any default template arguments, identifies
13772 a single function template specialization, then the template-id is an
13773 lvalue for the function template specialization. */
13776 resolve_nondeduced_context (tree orig_expr)
13778 tree expr, offset, baselink;
13781 if (!type_unknown_p (orig_expr))
13786 offset = NULL_TREE;
13787 baselink = NULL_TREE;
13789 if (TREE_CODE (expr) == ADDR_EXPR)
13791 expr = TREE_OPERAND (expr, 0);
13794 if (TREE_CODE (expr) == OFFSET_REF)
13797 expr = TREE_OPERAND (expr, 1);
13799 if (TREE_CODE (expr) == BASELINK)
13802 expr = BASELINK_FUNCTIONS (expr);
13805 if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
13808 tree goodfn = NULL_TREE;
13810 /* If we got some explicit template args, we need to plug them into
13811 the affected templates before we try to unify, in case the
13812 explicit args will completely resolve the templates in question. */
13814 tree expl_subargs = TREE_OPERAND (expr, 1);
13815 tree arg = TREE_OPERAND (expr, 0);
13816 tree badfn = NULL_TREE;
13817 tree badargs = NULL_TREE;
13819 for (; arg; arg = OVL_NEXT (arg))
13821 tree fn = OVL_CURRENT (arg);
13822 tree subargs, elem;
13824 if (TREE_CODE (fn) != TEMPLATE_DECL)
13827 ++processing_template_decl;
13828 subargs = get_bindings (fn, DECL_TEMPLATE_RESULT (fn),
13829 expl_subargs, /*check_ret=*/false);
13830 if (subargs && !any_dependent_template_arguments_p (subargs))
13832 elem = instantiate_template (fn, subargs, tf_none);
13833 if (elem == error_mark_node)
13838 else if (elem && (!goodfn || !decls_match (goodfn, elem)))
13844 --processing_template_decl;
13850 expr = build_baselink (BASELINK_BINFO (baselink),
13851 BASELINK_ACCESS_BINFO (baselink),
13852 expr, BASELINK_OPTYPE (baselink));
13854 expr = build2 (OFFSET_REF, TREE_TYPE (expr),
13855 TREE_OPERAND (offset, 0), expr);
13857 expr = build_address (expr);
13860 else if (good == 0 && badargs)
13861 /* There were no good options and at least one bad one, so let the
13862 user know what the problem is. */
13863 instantiate_template (badfn, badargs, tf_warning_or_error);
13868 /* Subroutine of resolve_overloaded_unification; does deduction for a single
13869 overload. Fills TARGS with any deduced arguments, or error_mark_node if
13870 different overloads deduce different arguments for a given parm.
13871 ADDR_P is true if the expression for which deduction is being
13872 performed was of the form "& fn" rather than simply "fn".
13874 Returns 1 on success. */
13877 try_one_overload (tree tparms,
13882 unification_kind_t strict,
13890 /* [temp.deduct.type] A template-argument can be deduced from a pointer
13891 to function or pointer to member function argument if the set of
13892 overloaded functions does not contain function templates and at most
13893 one of a set of overloaded functions provides a unique match.
13895 So if this is a template, just return success. */
13897 if (uses_template_parms (arg))
13900 if (TREE_CODE (arg) == METHOD_TYPE)
13901 arg = build_ptrmemfunc_type (build_pointer_type (arg));
13903 arg = build_pointer_type (arg);
13905 sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg, NULL);
13907 /* We don't copy orig_targs for this because if we have already deduced
13908 some template args from previous args, unify would complain when we
13909 try to deduce a template parameter for the same argument, even though
13910 there isn't really a conflict. */
13911 nargs = TREE_VEC_LENGTH (targs);
13912 tempargs = make_tree_vec (nargs);
13914 if (unify (tparms, tempargs, parm, arg, sub_strict) != 0)
13917 /* First make sure we didn't deduce anything that conflicts with
13918 explicitly specified args. */
13919 for (i = nargs; i--; )
13921 tree elt = TREE_VEC_ELT (tempargs, i);
13922 tree oldelt = TREE_VEC_ELT (orig_targs, i);
13926 else if (uses_template_parms (elt))
13927 /* Since we're unifying against ourselves, we will fill in
13928 template args used in the function parm list with our own
13929 template parms. Discard them. */
13930 TREE_VEC_ELT (tempargs, i) = NULL_TREE;
13931 else if (oldelt && !template_args_equal (oldelt, elt))
13935 for (i = nargs; i--; )
13937 tree elt = TREE_VEC_ELT (tempargs, i);
13940 TREE_VEC_ELT (targs, i) = elt;
13946 /* PARM is a template class (perhaps with unbound template
13947 parameters). ARG is a fully instantiated type. If ARG can be
13948 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
13949 TARGS are as for unify. */
13952 try_class_unification (tree tparms, tree targs, tree parm, tree arg)
13954 tree copy_of_targs;
13956 if (!CLASSTYPE_TEMPLATE_INFO (arg)
13957 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg))
13958 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm))))
13961 /* We need to make a new template argument vector for the call to
13962 unify. If we used TARGS, we'd clutter it up with the result of
13963 the attempted unification, even if this class didn't work out.
13964 We also don't want to commit ourselves to all the unifications
13965 we've already done, since unification is supposed to be done on
13966 an argument-by-argument basis. In other words, consider the
13967 following pathological case:
13969 template <int I, int J, int K>
13972 template <int I, int J>
13973 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
13975 template <int I, int J, int K>
13976 void f(S<I, J, K>, S<I, I, I>);
13985 Now, by the time we consider the unification involving `s2', we
13986 already know that we must have `f<0, 0, 0>'. But, even though
13987 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
13988 because there are two ways to unify base classes of S<0, 1, 2>
13989 with S<I, I, I>. If we kept the already deduced knowledge, we
13990 would reject the possibility I=1. */
13991 copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs));
13993 /* If unification failed, we're done. */
13994 if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm),
13995 CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE))
14001 /* Given a template type PARM and a class type ARG, find the unique
14002 base type in ARG that is an instance of PARM. We do not examine
14003 ARG itself; only its base-classes. If there is not exactly one
14004 appropriate base class, return NULL_TREE. PARM may be the type of
14005 a partial specialization, as well as a plain template type. Used
14009 get_template_base (tree tparms, tree targs, tree parm, tree arg)
14011 tree rval = NULL_TREE;
14014 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg)));
14016 binfo = TYPE_BINFO (complete_type (arg));
14018 /* The type could not be completed. */
14021 /* Walk in inheritance graph order. The search order is not
14022 important, and this avoids multiple walks of virtual bases. */
14023 for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo))
14025 tree r = try_class_unification (tparms, targs, parm, BINFO_TYPE (binfo));
14029 /* If there is more than one satisfactory baseclass, then:
14033 If they yield more than one possible deduced A, the type
14037 if (rval && !same_type_p (r, rval))
14047 /* Returns the level of DECL, which declares a template parameter. */
14050 template_decl_level (tree decl)
14052 switch (TREE_CODE (decl))
14055 case TEMPLATE_DECL:
14056 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl));
14059 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
14062 gcc_unreachable ();
14067 /* Decide whether ARG can be unified with PARM, considering only the
14068 cv-qualifiers of each type, given STRICT as documented for unify.
14069 Returns nonzero iff the unification is OK on that basis. */
14072 check_cv_quals_for_unify (int strict, tree arg, tree parm)
14074 int arg_quals = cp_type_quals (arg);
14075 int parm_quals = cp_type_quals (parm);
14077 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
14078 && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
14080 /* Although a CVR qualifier is ignored when being applied to a
14081 substituted template parameter ([8.3.2]/1 for example), that
14082 does not apply during deduction [14.8.2.4]/1, (even though
14083 that is not explicitly mentioned, [14.8.2.4]/9 indicates
14084 this). Except when we're allowing additional CV qualifiers
14085 at the outer level [14.8.2.1]/3,1st bullet. */
14086 if ((TREE_CODE (arg) == REFERENCE_TYPE
14087 || TREE_CODE (arg) == FUNCTION_TYPE
14088 || TREE_CODE (arg) == METHOD_TYPE)
14089 && (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)))
14092 if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
14093 && (parm_quals & TYPE_QUAL_RESTRICT))
14097 if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
14098 && (arg_quals & parm_quals) != parm_quals)
14101 if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL))
14102 && (parm_quals & arg_quals) != arg_quals)
14108 /* Determines the LEVEL and INDEX for the template parameter PARM. */
14110 template_parm_level_and_index (tree parm, int* level, int* index)
14112 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
14113 || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
14114 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
14116 *index = TEMPLATE_TYPE_IDX (parm);
14117 *level = TEMPLATE_TYPE_LEVEL (parm);
14121 *index = TEMPLATE_PARM_IDX (parm);
14122 *level = TEMPLATE_PARM_LEVEL (parm);
14126 /* Unifies the remaining arguments in PACKED_ARGS with the pack
14127 expansion at the end of PACKED_PARMS. Returns 0 if the type
14128 deduction succeeds, 1 otherwise. STRICT is the same as in
14129 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
14130 call argument list. We'll need to adjust the arguments to make them
14131 types. SUBR tells us if this is from a recursive call to
14132 type_unification_real. */
14134 unify_pack_expansion (tree tparms, tree targs, tree packed_parms,
14135 tree packed_args, int strict, bool call_args_p,
14139 = TREE_VEC_ELT (packed_parms, TREE_VEC_LENGTH (packed_parms) - 1);
14140 tree pattern = PACK_EXPANSION_PATTERN (parm);
14141 tree pack, packs = NULL_TREE;
14142 int i, start = TREE_VEC_LENGTH (packed_parms) - 1;
14143 int len = TREE_VEC_LENGTH (packed_args);
14145 /* Determine the parameter packs we will be deducing from the
14146 pattern, and record their current deductions. */
14147 for (pack = PACK_EXPANSION_PARAMETER_PACKS (parm);
14148 pack; pack = TREE_CHAIN (pack))
14150 tree parm_pack = TREE_VALUE (pack);
14153 /* Determine the index and level of this parameter pack. */
14154 template_parm_level_and_index (parm_pack, &level, &idx);
14156 /* Keep track of the parameter packs and their corresponding
14158 packs = tree_cons (parm_pack, TMPL_ARG (targs, level, idx), packs);
14159 TREE_TYPE (packs) = make_tree_vec (len - start);
14162 /* Loop through all of the arguments that have not yet been
14163 unified and unify each with the pattern. */
14164 for (i = start; i < len; i++)
14166 tree parm = pattern;
14168 /* For each parameter pack, clear out the deduced value so that
14169 we can deduce it again. */
14170 for (pack = packs; pack; pack = TREE_CHAIN (pack))
14173 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
14175 TMPL_ARG (targs, level, idx) = NULL_TREE;
14178 /* Unify the pattern with the current argument. */
14180 tree arg = TREE_VEC_ELT (packed_args, i);
14181 tree arg_expr = NULL_TREE;
14182 int arg_strict = strict;
14183 bool skip_arg_p = false;
14189 /* This mirrors what we do in type_unification_real. */
14193 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL
14194 | UNIFY_ALLOW_MORE_CV_QUAL
14195 | UNIFY_ALLOW_DERIVED);
14199 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
14203 sub_strict = UNIFY_ALLOW_NONE;
14207 gcc_unreachable ();
14212 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
14213 if (type_unknown_p (arg))
14215 /* [temp.deduct.type] A template-argument can be
14216 deduced from a pointer to function or pointer
14217 to member function argument if the set of
14218 overloaded functions does not contain function
14219 templates and at most one of a set of
14220 overloaded functions provides a unique
14223 if (resolve_overloaded_unification
14224 (tparms, targs, parm, arg,
14225 (unification_kind_t) strict,
14235 arg = unlowered_expr_type (arg);
14236 if (arg == error_mark_node)
14241 arg_strict = sub_strict;
14245 maybe_adjust_types_for_deduction ((unification_kind_t) strict,
14246 &parm, &arg, arg_expr);
14251 /* For deduction from an init-list we need the actual list. */
14252 if (arg_expr && BRACE_ENCLOSED_INITIALIZER_P (arg_expr))
14254 if (unify (tparms, targs, parm, arg, arg_strict))
14259 /* For each parameter pack, collect the deduced value. */
14260 for (pack = packs; pack; pack = TREE_CHAIN (pack))
14263 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
14265 TREE_VEC_ELT (TREE_TYPE (pack), i - start) =
14266 TMPL_ARG (targs, level, idx);
14270 /* Verify that the results of unification with the parameter packs
14271 produce results consistent with what we've seen before, and make
14272 the deduced argument packs available. */
14273 for (pack = packs; pack; pack = TREE_CHAIN (pack))
14275 tree old_pack = TREE_VALUE (pack);
14276 tree new_args = TREE_TYPE (pack);
14277 int i, len = TREE_VEC_LENGTH (new_args);
14279 bool nondeduced_p = false;
14281 /* By default keep the original deduced argument pack.
14282 If necessary, more specific code is going to update the
14283 resulting deduced argument later down in this function. */
14284 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
14285 TMPL_ARG (targs, level, idx) = old_pack;
14287 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
14288 actually deduce anything. */
14289 for (i = 0; i < len && !nondeduced_p; ++i)
14290 if (TREE_VEC_ELT (new_args, i) == NULL_TREE)
14291 nondeduced_p = true;
14295 if (old_pack && ARGUMENT_PACK_INCOMPLETE_P (old_pack))
14297 /* Prepend the explicit arguments onto NEW_ARGS. */
14298 tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
14299 tree old_args = new_args;
14300 int i, explicit_len = TREE_VEC_LENGTH (explicit_args);
14301 int len = explicit_len + TREE_VEC_LENGTH (old_args);
14303 /* Copy the explicit arguments. */
14304 new_args = make_tree_vec (len);
14305 for (i = 0; i < explicit_len; i++)
14306 TREE_VEC_ELT (new_args, i) = TREE_VEC_ELT (explicit_args, i);
14308 /* Copy the deduced arguments. */
14309 for (; i < len; i++)
14310 TREE_VEC_ELT (new_args, i) =
14311 TREE_VEC_ELT (old_args, i - explicit_len);
14317 /* Build the deduced *_ARGUMENT_PACK. */
14318 if (TREE_CODE (TREE_PURPOSE (pack)) == TEMPLATE_PARM_INDEX)
14320 result = make_node (NONTYPE_ARGUMENT_PACK);
14321 TREE_TYPE (result) =
14322 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack)));
14323 TREE_CONSTANT (result) = 1;
14326 result = cxx_make_type (TYPE_ARGUMENT_PACK);
14328 SET_ARGUMENT_PACK_ARGS (result, new_args);
14330 /* Note the deduced argument packs for this parameter
14332 TMPL_ARG (targs, level, idx) = result;
14334 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack)
14335 && (ARGUMENT_PACK_ARGS (old_pack)
14336 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack)))
14338 /* We only had the explicitly-provided arguments before, but
14339 now we have a complete set of arguments. */
14340 tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
14342 SET_ARGUMENT_PACK_ARGS (old_pack, new_args);
14343 ARGUMENT_PACK_INCOMPLETE_P (old_pack) = 1;
14344 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack) = explicit_args;
14346 else if (!comp_template_args (ARGUMENT_PACK_ARGS (old_pack),
14348 /* Inconsistent unification of this parameter pack. */
14355 /* Deduce the value of template parameters. TPARMS is the (innermost)
14356 set of template parameters to a template. TARGS is the bindings
14357 for those template parameters, as determined thus far; TARGS may
14358 include template arguments for outer levels of template parameters
14359 as well. PARM is a parameter to a template function, or a
14360 subcomponent of that parameter; ARG is the corresponding argument.
14361 This function attempts to match PARM with ARG in a manner
14362 consistent with the existing assignments in TARGS. If more values
14363 are deduced, then TARGS is updated.
14365 Returns 0 if the type deduction succeeds, 1 otherwise. The
14366 parameter STRICT is a bitwise or of the following flags:
14369 Require an exact match between PARM and ARG.
14370 UNIFY_ALLOW_MORE_CV_QUAL:
14371 Allow the deduced ARG to be more cv-qualified (by qualification
14372 conversion) than ARG.
14373 UNIFY_ALLOW_LESS_CV_QUAL:
14374 Allow the deduced ARG to be less cv-qualified than ARG.
14375 UNIFY_ALLOW_DERIVED:
14376 Allow the deduced ARG to be a template base class of ARG,
14377 or a pointer to a template base class of the type pointed to by
14379 UNIFY_ALLOW_INTEGER:
14380 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
14381 case for more information.
14382 UNIFY_ALLOW_OUTER_LEVEL:
14383 This is the outermost level of a deduction. Used to determine validity
14384 of qualification conversions. A valid qualification conversion must
14385 have const qualified pointers leading up to the inner type which
14386 requires additional CV quals, except at the outer level, where const
14387 is not required [conv.qual]. It would be normal to set this flag in
14388 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
14389 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
14390 This is the outermost level of a deduction, and PARM can be more CV
14391 qualified at this point.
14392 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
14393 This is the outermost level of a deduction, and PARM can be less CV
14394 qualified at this point. */
14397 unify (tree tparms, tree targs, tree parm, tree arg, int strict)
14402 int strict_in = strict;
14404 /* I don't think this will do the right thing with respect to types.
14405 But the only case I've seen it in so far has been array bounds, where
14406 signedness is the only information lost, and I think that will be
14408 while (TREE_CODE (parm) == NOP_EXPR)
14409 parm = TREE_OPERAND (parm, 0);
14411 if (arg == error_mark_node)
14413 if (arg == unknown_type_node
14414 || arg == init_list_type_node)
14415 /* We can't deduce anything from this, but we might get all the
14416 template args from other function args. */
14419 /* If PARM uses template parameters, then we can't bail out here,
14420 even if ARG == PARM, since we won't record unifications for the
14421 template parameters. We might need them if we're trying to
14422 figure out which of two things is more specialized. */
14423 if (arg == parm && !uses_template_parms (parm))
14426 /* Handle init lists early, so the rest of the function can assume
14427 we're dealing with a type. */
14428 if (BRACE_ENCLOSED_INITIALIZER_P (arg))
14432 tree orig_parm = parm;
14434 /* Replace T with std::initializer_list<T> for deduction. */
14435 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
14436 && flag_deduce_init_list)
14437 parm = listify (parm);
14439 if (!is_std_init_list (parm))
14440 /* We can only deduce from an initializer list argument if the
14441 parameter is std::initializer_list; otherwise this is a
14442 non-deduced context. */
14445 elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm), 0);
14447 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg), i, elt)
14449 int elt_strict = strict;
14450 if (!BRACE_ENCLOSED_INITIALIZER_P (elt))
14452 tree type = TREE_TYPE (elt);
14453 /* It should only be possible to get here for a call. */
14454 gcc_assert (elt_strict & UNIFY_ALLOW_OUTER_LEVEL);
14455 elt_strict |= maybe_adjust_types_for_deduction
14456 (DEDUCE_CALL, &elttype, &type, elt);
14460 if (unify (tparms, targs, elttype, elt, elt_strict))
14464 /* If the std::initializer_list<T> deduction worked, replace the
14465 deduced A with std::initializer_list<A>. */
14466 if (orig_parm != parm)
14468 idx = TEMPLATE_TYPE_IDX (orig_parm);
14469 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
14470 targ = listify (targ);
14471 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = targ;
14476 /* Immediately reject some pairs that won't unify because of
14477 cv-qualification mismatches. */
14478 if (TREE_CODE (arg) == TREE_CODE (parm)
14480 /* It is the elements of the array which hold the cv quals of an array
14481 type, and the elements might be template type parms. We'll check
14482 when we recurse. */
14483 && TREE_CODE (arg) != ARRAY_TYPE
14484 /* We check the cv-qualifiers when unifying with template type
14485 parameters below. We want to allow ARG `const T' to unify with
14486 PARM `T' for example, when computing which of two templates
14487 is more specialized, for example. */
14488 && TREE_CODE (arg) != TEMPLATE_TYPE_PARM
14489 && !check_cv_quals_for_unify (strict_in, arg, parm))
14492 if (!(strict & UNIFY_ALLOW_OUTER_LEVEL)
14493 && TYPE_P (parm) && !CP_TYPE_CONST_P (parm))
14494 strict &= ~UNIFY_ALLOW_MORE_CV_QUAL;
14495 strict &= ~UNIFY_ALLOW_OUTER_LEVEL;
14496 strict &= ~UNIFY_ALLOW_DERIVED;
14497 strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
14498 strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL;
14500 switch (TREE_CODE (parm))
14502 case TYPENAME_TYPE:
14504 case UNBOUND_CLASS_TEMPLATE:
14505 /* In a type which contains a nested-name-specifier, template
14506 argument values cannot be deduced for template parameters used
14507 within the nested-name-specifier. */
14510 case TEMPLATE_TYPE_PARM:
14511 case TEMPLATE_TEMPLATE_PARM:
14512 case BOUND_TEMPLATE_TEMPLATE_PARM:
14513 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
14514 if (tparm == error_mark_node)
14517 if (TEMPLATE_TYPE_LEVEL (parm)
14518 != template_decl_level (tparm))
14519 /* The PARM is not one we're trying to unify. Just check
14520 to see if it matches ARG. */
14521 return (TREE_CODE (arg) == TREE_CODE (parm)
14522 && same_type_p (parm, arg)) ? 0 : 1;
14523 idx = TEMPLATE_TYPE_IDX (parm);
14524 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
14525 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx));
14527 /* Check for mixed types and values. */
14528 if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
14529 && TREE_CODE (tparm) != TYPE_DECL)
14530 || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
14531 && TREE_CODE (tparm) != TEMPLATE_DECL))
14534 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
14536 /* ARG must be constructed from a template class or a template
14537 template parameter. */
14538 if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM
14539 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg))
14543 tree parmvec = TYPE_TI_ARGS (parm);
14544 tree argvec = INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg));
14546 = DECL_INNERMOST_TEMPLATE_PARMS
14547 (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm));
14549 int parm_variadic_p = 0;
14551 /* The resolution to DR150 makes clear that default
14552 arguments for an N-argument may not be used to bind T
14553 to a template template parameter with fewer than N
14554 parameters. It is not safe to permit the binding of
14555 default arguments as an extension, as that may change
14556 the meaning of a conforming program. Consider:
14558 struct Dense { static const unsigned int dim = 1; };
14560 template <template <typename> class View,
14562 void operator+(float, View<Block> const&);
14564 template <typename Block,
14565 unsigned int Dim = Block::dim>
14566 struct Lvalue_proxy { operator float() const; };
14570 Lvalue_proxy<Dense> p;
14575 Here, if Lvalue_proxy is permitted to bind to View, then
14576 the global operator+ will be used; if they are not, the
14577 Lvalue_proxy will be converted to float. */
14578 if (coerce_template_parms (parm_parms,
14580 TYPE_TI_TEMPLATE (parm),
14582 /*require_all_args=*/true,
14583 /*use_default_args=*/false)
14584 == error_mark_node)
14587 /* Deduce arguments T, i from TT<T> or TT<i>.
14588 We check each element of PARMVEC and ARGVEC individually
14589 rather than the whole TREE_VEC since they can have
14590 different number of elements. */
14592 parmvec = expand_template_argument_pack (parmvec);
14593 argvec = expand_template_argument_pack (argvec);
14595 len = TREE_VEC_LENGTH (parmvec);
14597 /* Check if the parameters end in a pack, making them
14600 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec, len - 1)))
14601 parm_variadic_p = 1;
14603 if (TREE_VEC_LENGTH (argvec) < len - parm_variadic_p)
14606 for (i = 0; i < len - parm_variadic_p; ++i)
14608 if (unify (tparms, targs,
14609 TREE_VEC_ELT (parmvec, i),
14610 TREE_VEC_ELT (argvec, i),
14615 if (parm_variadic_p
14616 && unify_pack_expansion (tparms, targs,
14619 /*call_args_p=*/false,
14623 arg = TYPE_TI_TEMPLATE (arg);
14625 /* Fall through to deduce template name. */
14628 if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
14629 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
14631 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
14633 /* Simple cases: Value already set, does match or doesn't. */
14634 if (targ != NULL_TREE && template_args_equal (targ, arg))
14641 /* If PARM is `const T' and ARG is only `int', we don't have
14642 a match unless we are allowing additional qualification.
14643 If ARG is `const int' and PARM is just `T' that's OK;
14644 that binds `const int' to `T'. */
14645 if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL,
14649 /* Consider the case where ARG is `const volatile int' and
14650 PARM is `const T'. Then, T should be `volatile int'. */
14651 arg = cp_build_qualified_type_real
14652 (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
14653 if (arg == error_mark_node)
14656 /* Simple cases: Value already set, does match or doesn't. */
14657 if (targ != NULL_TREE && same_type_p (targ, arg))
14662 /* Make sure that ARG is not a variable-sized array. (Note
14663 that were talking about variable-sized arrays (like
14664 `int[n]'), rather than arrays of unknown size (like
14665 `int[]').) We'll get very confused by such a type since
14666 the bound of the array will not be computable in an
14667 instantiation. Besides, such types are not allowed in
14668 ISO C++, so we can do as we please here. */
14669 if (variably_modified_type_p (arg, NULL_TREE))
14672 /* Strip typedefs as in convert_template_argument. */
14673 arg = strip_typedefs (arg);
14676 /* If ARG is a parameter pack or an expansion, we cannot unify
14677 against it unless PARM is also a parameter pack. */
14678 if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
14679 && !template_parameter_pack_p (parm))
14682 /* If the argument deduction results is a METHOD_TYPE,
14683 then there is a problem.
14684 METHOD_TYPE doesn't map to any real C++ type the result of
14685 the deduction can not be of that type. */
14686 if (TREE_CODE (arg) == METHOD_TYPE)
14689 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
14692 case TEMPLATE_PARM_INDEX:
14693 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
14694 if (tparm == error_mark_node)
14697 if (TEMPLATE_PARM_LEVEL (parm)
14698 != template_decl_level (tparm))
14699 /* The PARM is not one we're trying to unify. Just check
14700 to see if it matches ARG. */
14701 return !(TREE_CODE (arg) == TREE_CODE (parm)
14702 && cp_tree_equal (parm, arg));
14704 idx = TEMPLATE_PARM_IDX (parm);
14705 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
14708 return !cp_tree_equal (targ, arg);
14710 /* [temp.deduct.type] If, in the declaration of a function template
14711 with a non-type template-parameter, the non-type
14712 template-parameter is used in an expression in the function
14713 parameter-list and, if the corresponding template-argument is
14714 deduced, the template-argument type shall match the type of the
14715 template-parameter exactly, except that a template-argument
14716 deduced from an array bound may be of any integral type.
14717 The non-type parameter might use already deduced type parameters. */
14718 tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE);
14719 if (!TREE_TYPE (arg))
14720 /* Template-parameter dependent expression. Just accept it for now.
14721 It will later be processed in convert_template_argument. */
14723 else if (same_type_p (TREE_TYPE (arg), tparm))
14725 else if ((strict & UNIFY_ALLOW_INTEGER)
14726 && (TREE_CODE (tparm) == INTEGER_TYPE
14727 || TREE_CODE (tparm) == BOOLEAN_TYPE))
14728 /* Convert the ARG to the type of PARM; the deduced non-type
14729 template argument must exactly match the types of the
14730 corresponding parameter. */
14731 arg = fold (build_nop (tparm, arg));
14732 else if (uses_template_parms (tparm))
14733 /* We haven't deduced the type of this parameter yet. Try again
14739 /* If ARG is a parameter pack or an expansion, we cannot unify
14740 against it unless PARM is also a parameter pack. */
14741 if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
14742 && !TEMPLATE_PARM_PARAMETER_PACK (parm))
14745 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
14750 /* A pointer-to-member constant can be unified only with
14751 another constant. */
14752 if (TREE_CODE (arg) != PTRMEM_CST)
14755 /* Just unify the class member. It would be useless (and possibly
14756 wrong, depending on the strict flags) to unify also
14757 PTRMEM_CST_CLASS, because we want to be sure that both parm and
14758 arg refer to the same variable, even if through different
14759 classes. For instance:
14761 struct A { int x; };
14764 Unification of &A::x and &B::x must succeed. */
14765 return unify (tparms, targs, PTRMEM_CST_MEMBER (parm),
14766 PTRMEM_CST_MEMBER (arg), strict);
14771 if (TREE_CODE (arg) != POINTER_TYPE)
14774 /* [temp.deduct.call]
14776 A can be another pointer or pointer to member type that can
14777 be converted to the deduced A via a qualification
14778 conversion (_conv.qual_).
14780 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
14781 This will allow for additional cv-qualification of the
14782 pointed-to types if appropriate. */
14784 if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
14785 /* The derived-to-base conversion only persists through one
14786 level of pointers. */
14787 strict |= (strict_in & UNIFY_ALLOW_DERIVED);
14789 return unify (tparms, targs, TREE_TYPE (parm),
14790 TREE_TYPE (arg), strict);
14793 case REFERENCE_TYPE:
14794 if (TREE_CODE (arg) != REFERENCE_TYPE)
14796 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
14797 strict & UNIFY_ALLOW_MORE_CV_QUAL);
14800 if (TREE_CODE (arg) != ARRAY_TYPE)
14802 if ((TYPE_DOMAIN (parm) == NULL_TREE)
14803 != (TYPE_DOMAIN (arg) == NULL_TREE))
14805 if (TYPE_DOMAIN (parm) != NULL_TREE)
14812 /* Our representation of array types uses "N - 1" as the
14813 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
14814 not an integer constant. We cannot unify arbitrarily
14815 complex expressions, so we eliminate the MINUS_EXPRs
14817 parm_max = TYPE_MAX_VALUE (TYPE_DOMAIN (parm));
14818 parm_cst = TREE_CODE (parm_max) == INTEGER_CST;
14821 gcc_assert (TREE_CODE (parm_max) == MINUS_EXPR);
14822 parm_max = TREE_OPERAND (parm_max, 0);
14824 arg_max = TYPE_MAX_VALUE (TYPE_DOMAIN (arg));
14825 arg_cst = TREE_CODE (arg_max) == INTEGER_CST;
14828 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
14829 trying to unify the type of a variable with the type
14830 of a template parameter. For example:
14832 template <unsigned int N>
14833 void f (char (&) [N]);
14840 Here, the type of the ARG will be "int [g(i)]", and
14841 may be a SAVE_EXPR, etc. */
14842 if (TREE_CODE (arg_max) != MINUS_EXPR)
14844 arg_max = TREE_OPERAND (arg_max, 0);
14847 /* If only one of the bounds used a MINUS_EXPR, compensate
14848 by adding one to the other bound. */
14849 if (parm_cst && !arg_cst)
14850 parm_max = fold_build2_loc (input_location, PLUS_EXPR,
14854 else if (arg_cst && !parm_cst)
14855 arg_max = fold_build2_loc (input_location, PLUS_EXPR,
14860 if (unify (tparms, targs, parm_max, arg_max, UNIFY_ALLOW_INTEGER))
14863 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
14864 strict & UNIFY_ALLOW_MORE_CV_QUAL);
14871 case ENUMERAL_TYPE:
14873 if (TREE_CODE (arg) != TREE_CODE (parm))
14876 /* We have already checked cv-qualification at the top of the
14878 if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
14881 /* As far as unification is concerned, this wins. Later checks
14882 will invalidate it if necessary. */
14885 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
14886 /* Type INTEGER_CST can come from ordinary constant template args. */
14888 while (TREE_CODE (arg) == NOP_EXPR)
14889 arg = TREE_OPERAND (arg, 0);
14891 if (TREE_CODE (arg) != INTEGER_CST)
14893 return !tree_int_cst_equal (parm, arg);
14898 if (TREE_CODE (arg) != TREE_VEC)
14900 if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
14902 for (i = 0; i < TREE_VEC_LENGTH (parm); ++i)
14903 if (unify (tparms, targs,
14904 TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
14912 if (TREE_CODE (arg) != TREE_CODE (parm))
14915 if (TYPE_PTRMEMFUNC_P (parm))
14917 if (!TYPE_PTRMEMFUNC_P (arg))
14920 return unify (tparms, targs,
14921 TYPE_PTRMEMFUNC_FN_TYPE (parm),
14922 TYPE_PTRMEMFUNC_FN_TYPE (arg),
14926 if (CLASSTYPE_TEMPLATE_INFO (parm))
14928 tree t = NULL_TREE;
14930 if (strict_in & UNIFY_ALLOW_DERIVED)
14932 /* First, we try to unify the PARM and ARG directly. */
14933 t = try_class_unification (tparms, targs,
14938 /* Fallback to the special case allowed in
14939 [temp.deduct.call]:
14941 If P is a class, and P has the form
14942 template-id, then A can be a derived class of
14943 the deduced A. Likewise, if P is a pointer to
14944 a class of the form template-id, A can be a
14945 pointer to a derived class pointed to by the
14947 t = get_template_base (tparms, targs, parm, arg);
14953 else if (CLASSTYPE_TEMPLATE_INFO (arg)
14954 && (CLASSTYPE_TI_TEMPLATE (parm)
14955 == CLASSTYPE_TI_TEMPLATE (arg)))
14956 /* Perhaps PARM is something like S<U> and ARG is S<int>.
14957 Then, we should unify `int' and `U'. */
14960 /* There's no chance of unification succeeding. */
14963 return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
14964 CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE);
14966 else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
14971 case FUNCTION_TYPE:
14973 unsigned int nargs;
14978 if (TREE_CODE (arg) != TREE_CODE (parm))
14981 /* CV qualifications for methods can never be deduced, they must
14982 match exactly. We need to check them explicitly here,
14983 because type_unification_real treats them as any other
14984 cv-qualified parameter. */
14985 if (TREE_CODE (parm) == METHOD_TYPE
14986 && (!check_cv_quals_for_unify
14988 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (arg))),
14989 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (parm))))))
14992 if (unify (tparms, targs, TREE_TYPE (parm),
14993 TREE_TYPE (arg), UNIFY_ALLOW_NONE))
14996 nargs = list_length (TYPE_ARG_TYPES (arg));
14997 args = XALLOCAVEC (tree, nargs);
14998 for (a = TYPE_ARG_TYPES (arg), i = 0;
14999 a != NULL_TREE && a != void_list_node;
15000 a = TREE_CHAIN (a), ++i)
15001 args[i] = TREE_VALUE (a);
15004 return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
15005 args, nargs, 1, DEDUCE_EXACT,
15010 /* Unify a pointer to member with a pointer to member function, which
15011 deduces the type of the member as a function type. */
15012 if (TYPE_PTRMEMFUNC_P (arg))
15016 cp_cv_quals cv_quals;
15018 /* Check top-level cv qualifiers */
15019 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE, arg, parm))
15022 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
15023 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg), UNIFY_ALLOW_NONE))
15026 /* Determine the type of the function we are unifying against. */
15027 method_type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (arg));
15029 build_function_type (TREE_TYPE (method_type),
15030 TREE_CHAIN (TYPE_ARG_TYPES (method_type)));
15032 /* Extract the cv-qualifiers of the member function from the
15033 implicit object parameter and place them on the function
15034 type to be restored later. */
15036 cp_type_quals(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (method_type))));
15037 fntype = build_qualified_type (fntype, cv_quals);
15038 return unify (tparms, targs, TREE_TYPE (parm), fntype, strict);
15041 if (TREE_CODE (arg) != OFFSET_TYPE)
15043 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
15044 TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE))
15046 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
15050 if (DECL_TEMPLATE_PARM_P (parm))
15051 return unify (tparms, targs, DECL_INITIAL (parm), arg, strict);
15052 if (arg != integral_constant_value (parm))
15057 case TEMPLATE_DECL:
15058 /* Matched cases are handled by the ARG == PARM test above. */
15062 /* A non-type template parameter that is a variable should be a
15063 an integral constant, in which case, it whould have been
15064 folded into its (constant) value. So we should not be getting
15065 a variable here. */
15066 gcc_unreachable ();
15068 case TYPE_ARGUMENT_PACK:
15069 case NONTYPE_ARGUMENT_PACK:
15071 tree packed_parms = ARGUMENT_PACK_ARGS (parm);
15072 tree packed_args = ARGUMENT_PACK_ARGS (arg);
15073 int i, len = TREE_VEC_LENGTH (packed_parms);
15074 int argslen = TREE_VEC_LENGTH (packed_args);
15075 int parm_variadic_p = 0;
15077 for (i = 0; i < len; ++i)
15079 if (PACK_EXPANSION_P (TREE_VEC_ELT (packed_parms, i)))
15082 /* We can unify against something with a trailing
15084 parm_variadic_p = 1;
15086 /* Since there is something following the pack
15087 expansion, we cannot unify this template argument
15094 /* If we don't have enough arguments to satisfy the parameters
15095 (not counting the pack expression at the end), or we have
15096 too many arguments for a parameter list that doesn't end in
15097 a pack expression, we can't unify. */
15098 if (argslen < (len - parm_variadic_p)
15099 || (argslen > len && !parm_variadic_p))
15102 /* Unify all of the parameters that precede the (optional)
15103 pack expression. */
15104 for (i = 0; i < len - parm_variadic_p; ++i)
15106 if (unify (tparms, targs, TREE_VEC_ELT (packed_parms, i),
15107 TREE_VEC_ELT (packed_args, i), strict))
15111 if (parm_variadic_p)
15112 return unify_pack_expansion (tparms, targs,
15113 packed_parms, packed_args,
15114 strict, /*call_args_p=*/false,
15122 case DECLTYPE_TYPE:
15123 /* Cannot deduce anything from TYPEOF_TYPE or DECLTYPE_TYPE
15128 /* Unification fails if we hit an error node. */
15132 gcc_assert (EXPR_P (parm));
15134 /* We must be looking at an expression. This can happen with
15138 void foo(S<I>, S<I + 2>);
15140 This is a "nondeduced context":
15144 The nondeduced contexts are:
15146 --A type that is a template-id in which one or more of
15147 the template-arguments is an expression that references
15148 a template-parameter.
15150 In these cases, we assume deduction succeeded, but don't
15151 actually infer any unifications. */
15153 if (!uses_template_parms (parm)
15154 && !template_args_equal (parm, arg))
15161 /* Note that DECL can be defined in this translation unit, if
15165 mark_definable (tree decl)
15168 DECL_NOT_REALLY_EXTERN (decl) = 1;
15169 FOR_EACH_CLONE (clone, decl)
15170 DECL_NOT_REALLY_EXTERN (clone) = 1;
15173 /* Called if RESULT is explicitly instantiated, or is a member of an
15174 explicitly instantiated class. */
15177 mark_decl_instantiated (tree result, int extern_p)
15179 SET_DECL_EXPLICIT_INSTANTIATION (result);
15181 /* If this entity has already been written out, it's too late to
15182 make any modifications. */
15183 if (TREE_ASM_WRITTEN (result))
15186 if (TREE_CODE (result) != FUNCTION_DECL)
15187 /* The TREE_PUBLIC flag for function declarations will have been
15188 set correctly by tsubst. */
15189 TREE_PUBLIC (result) = 1;
15191 /* This might have been set by an earlier implicit instantiation. */
15192 DECL_COMDAT (result) = 0;
15195 DECL_NOT_REALLY_EXTERN (result) = 0;
15198 mark_definable (result);
15199 /* Always make artificials weak. */
15200 if (DECL_ARTIFICIAL (result) && flag_weak)
15201 comdat_linkage (result);
15202 /* For WIN32 we also want to put explicit instantiations in
15203 linkonce sections. */
15204 else if (TREE_PUBLIC (result))
15205 maybe_make_one_only (result);
15208 /* If EXTERN_P, then this function will not be emitted -- unless
15209 followed by an explicit instantiation, at which point its linkage
15210 will be adjusted. If !EXTERN_P, then this function will be
15211 emitted here. In neither circumstance do we want
15212 import_export_decl to adjust the linkage. */
15213 DECL_INTERFACE_KNOWN (result) = 1;
15216 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
15217 important template arguments. If any are missing, we check whether
15218 they're important by using error_mark_node for substituting into any
15219 args that were used for partial ordering (the ones between ARGS and END)
15220 and seeing if it bubbles up. */
15223 check_undeduced_parms (tree targs, tree args, tree end)
15225 bool found = false;
15227 for (i = TREE_VEC_LENGTH (targs) - 1; i >= 0; --i)
15228 if (TREE_VEC_ELT (targs, i) == NULL_TREE)
15231 TREE_VEC_ELT (targs, i) = error_mark_node;
15235 for (; args != end; args = TREE_CHAIN (args))
15237 tree substed = tsubst (TREE_VALUE (args), targs, tf_none, NULL_TREE);
15238 if (substed == error_mark_node)
15245 /* Given two function templates PAT1 and PAT2, return:
15247 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
15248 -1 if PAT2 is more specialized than PAT1.
15249 0 if neither is more specialized.
15251 LEN indicates the number of parameters we should consider
15252 (defaulted parameters should not be considered).
15254 The 1998 std underspecified function template partial ordering, and
15255 DR214 addresses the issue. We take pairs of arguments, one from
15256 each of the templates, and deduce them against each other. One of
15257 the templates will be more specialized if all the *other*
15258 template's arguments deduce against its arguments and at least one
15259 of its arguments *does* *not* deduce against the other template's
15260 corresponding argument. Deduction is done as for class templates.
15261 The arguments used in deduction have reference and top level cv
15262 qualifiers removed. Iff both arguments were originally reference
15263 types *and* deduction succeeds in both directions, the template
15264 with the more cv-qualified argument wins for that pairing (if
15265 neither is more cv-qualified, they both are equal). Unlike regular
15266 deduction, after all the arguments have been deduced in this way,
15267 we do *not* verify the deduced template argument values can be
15268 substituted into non-deduced contexts.
15270 The logic can be a bit confusing here, because we look at deduce1 and
15271 targs1 to see if pat2 is at least as specialized, and vice versa; if we
15272 can find template arguments for pat1 to make arg1 look like arg2, that
15273 means that arg2 is at least as specialized as arg1. */
15276 more_specialized_fn (tree pat1, tree pat2, int len)
15278 tree decl1 = DECL_TEMPLATE_RESULT (pat1);
15279 tree decl2 = DECL_TEMPLATE_RESULT (pat2);
15280 tree targs1 = make_tree_vec (DECL_NTPARMS (pat1));
15281 tree targs2 = make_tree_vec (DECL_NTPARMS (pat2));
15282 tree tparms1 = DECL_INNERMOST_TEMPLATE_PARMS (pat1);
15283 tree tparms2 = DECL_INNERMOST_TEMPLATE_PARMS (pat2);
15284 tree args1 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
15285 tree args2 = TYPE_ARG_TYPES (TREE_TYPE (decl2));
15286 tree origs1, origs2;
15287 bool lose1 = false;
15288 bool lose2 = false;
15290 /* Remove the this parameter from non-static member functions. If
15291 one is a non-static member function and the other is not a static
15292 member function, remove the first parameter from that function
15293 also. This situation occurs for operator functions where we
15294 locate both a member function (with this pointer) and non-member
15295 operator (with explicit first operand). */
15296 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1))
15298 len--; /* LEN is the number of significant arguments for DECL1 */
15299 args1 = TREE_CHAIN (args1);
15300 if (!DECL_STATIC_FUNCTION_P (decl2))
15301 args2 = TREE_CHAIN (args2);
15303 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2))
15305 args2 = TREE_CHAIN (args2);
15306 if (!DECL_STATIC_FUNCTION_P (decl1))
15309 args1 = TREE_CHAIN (args1);
15313 /* If only one is a conversion operator, they are unordered. */
15314 if (DECL_CONV_FN_P (decl1) != DECL_CONV_FN_P (decl2))
15317 /* Consider the return type for a conversion function */
15318 if (DECL_CONV_FN_P (decl1))
15320 args1 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl1)), args1);
15321 args2 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl2)), args2);
15325 processing_template_decl++;
15331 /* Stop when an ellipsis is seen. */
15332 && args1 != NULL_TREE && args2 != NULL_TREE)
15334 tree arg1 = TREE_VALUE (args1);
15335 tree arg2 = TREE_VALUE (args2);
15336 int deduce1, deduce2;
15340 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
15341 && TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
15343 /* When both arguments are pack expansions, we need only
15344 unify the patterns themselves. */
15345 arg1 = PACK_EXPANSION_PATTERN (arg1);
15346 arg2 = PACK_EXPANSION_PATTERN (arg2);
15348 /* This is the last comparison we need to do. */
15352 if (TREE_CODE (arg1) == REFERENCE_TYPE)
15354 arg1 = TREE_TYPE (arg1);
15355 quals1 = cp_type_quals (arg1);
15358 if (TREE_CODE (arg2) == REFERENCE_TYPE)
15360 arg2 = TREE_TYPE (arg2);
15361 quals2 = cp_type_quals (arg2);
15364 if ((quals1 < 0) != (quals2 < 0))
15366 /* Only of the args is a reference, see if we should apply
15367 array/function pointer decay to it. This is not part of
15368 DR214, but is, IMHO, consistent with the deduction rules
15369 for the function call itself, and with our earlier
15370 implementation of the underspecified partial ordering
15371 rules. (nathan). */
15374 switch (TREE_CODE (arg1))
15377 arg1 = TREE_TYPE (arg1);
15379 case FUNCTION_TYPE:
15380 arg1 = build_pointer_type (arg1);
15389 switch (TREE_CODE (arg2))
15392 arg2 = TREE_TYPE (arg2);
15394 case FUNCTION_TYPE:
15395 arg2 = build_pointer_type (arg2);
15404 arg1 = TYPE_MAIN_VARIANT (arg1);
15405 arg2 = TYPE_MAIN_VARIANT (arg2);
15407 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION)
15409 int i, len2 = list_length (args2);
15410 tree parmvec = make_tree_vec (1);
15411 tree argvec = make_tree_vec (len2);
15414 /* Setup the parameter vector, which contains only ARG1. */
15415 TREE_VEC_ELT (parmvec, 0) = arg1;
15417 /* Setup the argument vector, which contains the remaining
15419 for (i = 0; i < len2; i++, ta = TREE_CHAIN (ta))
15420 TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
15422 deduce1 = !unify_pack_expansion (tparms1, targs1, parmvec,
15423 argvec, UNIFY_ALLOW_NONE,
15424 /*call_args_p=*/false,
15427 /* We cannot deduce in the other direction, because ARG1 is
15428 a pack expansion but ARG2 is not. */
15431 else if (TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
15433 int i, len1 = list_length (args1);
15434 tree parmvec = make_tree_vec (1);
15435 tree argvec = make_tree_vec (len1);
15438 /* Setup the parameter vector, which contains only ARG1. */
15439 TREE_VEC_ELT (parmvec, 0) = arg2;
15441 /* Setup the argument vector, which contains the remaining
15443 for (i = 0; i < len1; i++, ta = TREE_CHAIN (ta))
15444 TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
15446 deduce2 = !unify_pack_expansion (tparms2, targs2, parmvec,
15447 argvec, UNIFY_ALLOW_NONE,
15448 /*call_args_p=*/false,
15451 /* We cannot deduce in the other direction, because ARG2 is
15452 a pack expansion but ARG1 is not.*/
15458 /* The normal case, where neither argument is a pack
15460 deduce1 = !unify (tparms1, targs1, arg1, arg2, UNIFY_ALLOW_NONE);
15461 deduce2 = !unify (tparms2, targs2, arg2, arg1, UNIFY_ALLOW_NONE);
15464 /* If we couldn't deduce arguments for tparms1 to make arg1 match
15465 arg2, then arg2 is not as specialized as arg1. */
15471 /* "If, for a given type, deduction succeeds in both directions
15472 (i.e., the types are identical after the transformations above)
15473 and if the type from the argument template is more cv-qualified
15474 than the type from the parameter template (as described above)
15475 that type is considered to be more specialized than the other. If
15476 neither type is more cv-qualified than the other then neither type
15477 is more specialized than the other." */
15479 if (deduce1 && deduce2
15480 && quals1 != quals2 && quals1 >= 0 && quals2 >= 0)
15482 if ((quals1 & quals2) == quals2)
15484 if ((quals1 & quals2) == quals1)
15488 if (lose1 && lose2)
15489 /* We've failed to deduce something in either direction.
15490 These must be unordered. */
15493 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
15494 || TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
15495 /* We have already processed all of the arguments in our
15496 handing of the pack expansion type. */
15499 args1 = TREE_CHAIN (args1);
15500 args2 = TREE_CHAIN (args2);
15503 /* "In most cases, all template parameters must have values in order for
15504 deduction to succeed, but for partial ordering purposes a template
15505 parameter may remain without a value provided it is not used in the
15506 types being used for partial ordering."
15508 Thus, if we are missing any of the targs1 we need to substitute into
15509 origs1, then pat2 is not as specialized as pat1. This can happen when
15510 there is a nondeduced context. */
15511 if (!lose2 && check_undeduced_parms (targs1, origs1, args1))
15513 if (!lose1 && check_undeduced_parms (targs2, origs2, args2))
15516 processing_template_decl--;
15518 /* All things being equal, if the next argument is a pack expansion
15519 for one function but not for the other, prefer the
15520 non-variadic function. FIXME this is bogus; see c++/41958. */
15522 && args1 && TREE_VALUE (args1)
15523 && args2 && TREE_VALUE (args2))
15525 lose1 = TREE_CODE (TREE_VALUE (args1)) == TYPE_PACK_EXPANSION;
15526 lose2 = TREE_CODE (TREE_VALUE (args2)) == TYPE_PACK_EXPANSION;
15529 if (lose1 == lose2)
15537 /* Determine which of two partial specializations is more specialized.
15539 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
15540 to the first partial specialization. The TREE_VALUE is the
15541 innermost set of template parameters for the partial
15542 specialization. PAT2 is similar, but for the second template.
15544 Return 1 if the first partial specialization is more specialized;
15545 -1 if the second is more specialized; 0 if neither is more
15548 See [temp.class.order] for information about determining which of
15549 two templates is more specialized. */
15552 more_specialized_class (tree pat1, tree pat2)
15557 bool any_deductions = false;
15559 tmpl1 = TREE_TYPE (pat1);
15560 tmpl2 = TREE_TYPE (pat2);
15562 /* Just like what happens for functions, if we are ordering between
15563 different class template specializations, we may encounter dependent
15564 types in the arguments, and we need our dependency check functions
15565 to behave correctly. */
15566 ++processing_template_decl;
15567 targs = get_class_bindings (TREE_VALUE (pat1),
15568 CLASSTYPE_TI_ARGS (tmpl1),
15569 CLASSTYPE_TI_ARGS (tmpl2));
15573 any_deductions = true;
15576 targs = get_class_bindings (TREE_VALUE (pat2),
15577 CLASSTYPE_TI_ARGS (tmpl2),
15578 CLASSTYPE_TI_ARGS (tmpl1));
15582 any_deductions = true;
15584 --processing_template_decl;
15586 /* In the case of a tie where at least one of the class templates
15587 has a parameter pack at the end, the template with the most
15588 non-packed parameters wins. */
15591 && (template_args_variadic_p (TREE_PURPOSE (pat1))
15592 || template_args_variadic_p (TREE_PURPOSE (pat2))))
15594 tree args1 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1));
15595 tree args2 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2));
15596 int len1 = TREE_VEC_LENGTH (args1);
15597 int len2 = TREE_VEC_LENGTH (args2);
15599 /* We don't count the pack expansion at the end. */
15600 if (template_args_variadic_p (TREE_PURPOSE (pat1)))
15602 if (template_args_variadic_p (TREE_PURPOSE (pat2)))
15607 else if (len1 < len2)
15614 /* Return the template arguments that will produce the function signature
15615 DECL from the function template FN, with the explicit template
15616 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
15617 also match. Return NULL_TREE if no satisfactory arguments could be
15621 get_bindings (tree fn, tree decl, tree explicit_args, bool check_rettype)
15623 int ntparms = DECL_NTPARMS (fn);
15624 tree targs = make_tree_vec (ntparms);
15626 tree decl_arg_types;
15628 unsigned int nargs, ix;
15631 /* Substitute the explicit template arguments into the type of DECL.
15632 The call to fn_type_unification will handle substitution into the
15634 decl_type = TREE_TYPE (decl);
15635 if (explicit_args && uses_template_parms (decl_type))
15638 tree converted_args;
15640 if (DECL_TEMPLATE_INFO (decl))
15641 tmpl = DECL_TI_TEMPLATE (decl);
15643 /* We can get here for some invalid specializations. */
15647 = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
15648 explicit_args, NULL_TREE,
15650 /*require_all_args=*/false,
15651 /*use_default_args=*/false);
15652 if (converted_args == error_mark_node)
15655 decl_type = tsubst (decl_type, converted_args, tf_none, NULL_TREE);
15656 if (decl_type == error_mark_node)
15660 /* Never do unification on the 'this' parameter. */
15661 decl_arg_types = skip_artificial_parms_for (decl,
15662 TYPE_ARG_TYPES (decl_type));
15664 nargs = list_length (decl_arg_types);
15665 args = XALLOCAVEC (tree, nargs);
15666 for (arg = decl_arg_types, ix = 0;
15667 arg != NULL_TREE && arg != void_list_node;
15668 arg = TREE_CHAIN (arg), ++ix)
15669 args[ix] = TREE_VALUE (arg);
15671 if (fn_type_unification (fn, explicit_args, targs,
15673 (check_rettype || DECL_CONV_FN_P (fn)
15674 ? TREE_TYPE (decl_type) : NULL_TREE),
15675 DEDUCE_EXACT, LOOKUP_NORMAL))
15681 /* Return the innermost template arguments that, when applied to a
15682 template specialization whose innermost template parameters are
15683 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
15686 For example, suppose we have:
15688 template <class T, class U> struct S {};
15689 template <class T> struct S<T*, int> {};
15691 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
15692 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
15693 int}. The resulting vector will be {double}, indicating that `T'
15694 is bound to `double'. */
15697 get_class_bindings (tree tparms, tree spec_args, tree args)
15699 int i, ntparms = TREE_VEC_LENGTH (tparms);
15701 tree innermost_deduced_args;
15703 innermost_deduced_args = make_tree_vec (ntparms);
15704 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
15706 deduced_args = copy_node (args);
15707 SET_TMPL_ARGS_LEVEL (deduced_args,
15708 TMPL_ARGS_DEPTH (deduced_args),
15709 innermost_deduced_args);
15712 deduced_args = innermost_deduced_args;
15714 if (unify (tparms, deduced_args,
15715 INNERMOST_TEMPLATE_ARGS (spec_args),
15716 INNERMOST_TEMPLATE_ARGS (args),
15720 for (i = 0; i < ntparms; ++i)
15721 if (! TREE_VEC_ELT (innermost_deduced_args, i))
15724 /* Verify that nondeduced template arguments agree with the type
15725 obtained from argument deduction.
15729 struct A { typedef int X; };
15730 template <class T, class U> struct C {};
15731 template <class T> struct C<T, typename T::X> {};
15733 Then with the instantiation `C<A, int>', we can deduce that
15734 `T' is `A' but unify () does not check whether `typename T::X'
15736 spec_args = tsubst (spec_args, deduced_args, tf_none, NULL_TREE);
15737 if (spec_args == error_mark_node
15738 /* We only need to check the innermost arguments; the other
15739 arguments will always agree. */
15740 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args),
15741 INNERMOST_TEMPLATE_ARGS (args)))
15744 /* Now that we have bindings for all of the template arguments,
15745 ensure that the arguments deduced for the template template
15746 parameters have compatible template parameter lists. See the use
15747 of template_template_parm_bindings_ok_p in fn_type_unification
15748 for more information. */
15749 if (!template_template_parm_bindings_ok_p (tparms, deduced_args))
15752 return deduced_args;
15755 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
15756 Return the TREE_LIST node with the most specialized template, if
15757 any. If there is no most specialized template, the error_mark_node
15760 Note that this function does not look at, or modify, the
15761 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
15762 returned is one of the elements of INSTANTIATIONS, callers may
15763 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
15764 and retrieve it from the value returned. */
15767 most_specialized_instantiation (tree templates)
15771 ++processing_template_decl;
15774 for (fn = TREE_CHAIN (templates); fn; fn = TREE_CHAIN (fn))
15778 if (get_bindings (TREE_VALUE (champ),
15779 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
15780 NULL_TREE, /*check_ret=*/false))
15783 if (get_bindings (TREE_VALUE (fn),
15784 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
15785 NULL_TREE, /*check_ret=*/false))
15792 /* Equally specialized, move to next function. If there
15793 is no next function, nothing's most specialized. */
15794 fn = TREE_CHAIN (fn);
15802 /* Now verify that champ is better than everything earlier in the
15803 instantiation list. */
15804 for (fn = templates; fn != champ; fn = TREE_CHAIN (fn))
15805 if (get_bindings (TREE_VALUE (champ),
15806 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
15807 NULL_TREE, /*check_ret=*/false)
15808 || !get_bindings (TREE_VALUE (fn),
15809 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
15810 NULL_TREE, /*check_ret=*/false))
15816 processing_template_decl--;
15819 return error_mark_node;
15824 /* If DECL is a specialization of some template, return the most
15825 general such template. Otherwise, returns NULL_TREE.
15827 For example, given:
15829 template <class T> struct S { template <class U> void f(U); };
15831 if TMPL is `template <class U> void S<int>::f(U)' this will return
15832 the full template. This function will not trace past partial
15833 specializations, however. For example, given in addition:
15835 template <class T> struct S<T*> { template <class U> void f(U); };
15837 if TMPL is `template <class U> void S<int*>::f(U)' this will return
15838 `template <class T> template <class U> S<T*>::f(U)'. */
15841 most_general_template (tree decl)
15843 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
15844 an immediate specialization. */
15845 if (TREE_CODE (decl) == FUNCTION_DECL)
15847 if (DECL_TEMPLATE_INFO (decl)) {
15848 decl = DECL_TI_TEMPLATE (decl);
15850 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
15851 template friend. */
15852 if (TREE_CODE (decl) != TEMPLATE_DECL)
15858 /* Look for more and more general templates. */
15859 while (DECL_TEMPLATE_INFO (decl))
15861 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
15862 (See cp-tree.h for details.) */
15863 if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
15866 if (CLASS_TYPE_P (TREE_TYPE (decl))
15867 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
15870 /* Stop if we run into an explicitly specialized class template. */
15871 if (!DECL_NAMESPACE_SCOPE_P (decl)
15872 && DECL_CONTEXT (decl)
15873 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl)))
15876 decl = DECL_TI_TEMPLATE (decl);
15882 /* Return the most specialized of the class template partial
15883 specializations of TMPL which can produce TYPE, a specialization of
15884 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
15885 a _TYPE node corresponding to the partial specialization, while the
15886 TREE_PURPOSE is the set of template arguments that must be
15887 substituted into the TREE_TYPE in order to generate TYPE.
15889 If the choice of partial specialization is ambiguous, a diagnostic
15890 is issued, and the error_mark_node is returned. If there are no
15891 partial specializations of TMPL matching TYPE, then NULL_TREE is
15895 most_specialized_class (tree type, tree tmpl)
15897 tree list = NULL_TREE;
15903 tree outer_args = NULL_TREE;
15905 tmpl = most_general_template (tmpl);
15906 args = CLASSTYPE_TI_ARGS (type);
15908 /* For determining which partial specialization to use, only the
15909 innermost args are interesting. */
15910 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
15912 outer_args = strip_innermost_template_args (args, 1);
15913 args = INNERMOST_TEMPLATE_ARGS (args);
15916 for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t))
15918 tree partial_spec_args;
15920 tree parms = TREE_VALUE (t);
15922 partial_spec_args = CLASSTYPE_TI_ARGS (TREE_TYPE (t));
15927 ++processing_template_decl;
15929 /* Discard the outer levels of args, and then substitute in the
15930 template args from the enclosing class. */
15931 partial_spec_args = INNERMOST_TEMPLATE_ARGS (partial_spec_args);
15932 partial_spec_args = tsubst_template_args
15933 (partial_spec_args, outer_args, tf_none, NULL_TREE);
15935 /* PARMS already refers to just the innermost parms, but the
15936 template parms in partial_spec_args had their levels lowered
15937 by tsubst, so we need to do the same for the parm list. We
15938 can't just tsubst the TREE_VEC itself, as tsubst wants to
15939 treat a TREE_VEC as an argument vector. */
15940 parms = copy_node (parms);
15941 for (i = TREE_VEC_LENGTH (parms) - 1; i >= 0; --i)
15942 TREE_VEC_ELT (parms, i) =
15943 tsubst (TREE_VEC_ELT (parms, i), outer_args, tf_none, NULL_TREE);
15945 --processing_template_decl;
15948 partial_spec_args =
15949 coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
15950 add_to_template_args (outer_args,
15951 partial_spec_args),
15953 /*require_all_args=*/true,
15954 /*use_default_args=*/true);
15956 if (partial_spec_args == error_mark_node)
15957 return error_mark_node;
15959 spec_args = get_class_bindings (parms,
15965 spec_args = add_to_template_args (outer_args, spec_args);
15966 list = tree_cons (spec_args, TREE_VALUE (t), list);
15967 TREE_TYPE (list) = TREE_TYPE (t);
15974 ambiguous_p = false;
15977 t = TREE_CHAIN (t);
15978 for (; t; t = TREE_CHAIN (t))
15980 fate = more_specialized_class (champ, t);
15987 t = TREE_CHAIN (t);
15990 ambiguous_p = true;
15999 for (t = list; t && t != champ; t = TREE_CHAIN (t))
16001 fate = more_specialized_class (champ, t);
16004 ambiguous_p = true;
16012 char *spaces = NULL;
16013 error ("ambiguous class template instantiation for %q#T", type);
16014 str = TREE_CHAIN (list) ? _("candidates are:") : _("candidate is:");
16015 for (t = list; t; t = TREE_CHAIN (t))
16017 error ("%s %+#T", spaces ? spaces : str, TREE_TYPE (t));
16018 spaces = spaces ? spaces : get_spaces (str);
16021 return error_mark_node;
16027 /* Explicitly instantiate DECL. */
16030 do_decl_instantiation (tree decl, tree storage)
16032 tree result = NULL_TREE;
16035 if (!decl || decl == error_mark_node)
16036 /* An error occurred, for which grokdeclarator has already issued
16037 an appropriate message. */
16039 else if (! DECL_LANG_SPECIFIC (decl))
16041 error ("explicit instantiation of non-template %q#D", decl);
16044 else if (TREE_CODE (decl) == VAR_DECL)
16046 /* There is an asymmetry here in the way VAR_DECLs and
16047 FUNCTION_DECLs are handled by grokdeclarator. In the case of
16048 the latter, the DECL we get back will be marked as a
16049 template instantiation, and the appropriate
16050 DECL_TEMPLATE_INFO will be set up. This does not happen for
16051 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
16052 should handle VAR_DECLs as it currently handles
16054 if (!DECL_CLASS_SCOPE_P (decl))
16056 error ("%qD is not a static data member of a class template", decl);
16059 result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false);
16060 if (!result || TREE_CODE (result) != VAR_DECL)
16062 error ("no matching template for %qD found", decl);
16065 if (!same_type_p (TREE_TYPE (result), TREE_TYPE (decl)))
16067 error ("type %qT for explicit instantiation %qD does not match "
16068 "declared type %qT", TREE_TYPE (result), decl,
16073 else if (TREE_CODE (decl) != FUNCTION_DECL)
16075 error ("explicit instantiation of %q#D", decl);
16081 /* Check for various error cases. Note that if the explicit
16082 instantiation is valid the RESULT will currently be marked as an
16083 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
16084 until we get here. */
16086 if (DECL_TEMPLATE_SPECIALIZATION (result))
16088 /* DR 259 [temp.spec].
16090 Both an explicit instantiation and a declaration of an explicit
16091 specialization shall not appear in a program unless the explicit
16092 instantiation follows a declaration of the explicit specialization.
16094 For a given set of template parameters, if an explicit
16095 instantiation of a template appears after a declaration of an
16096 explicit specialization for that template, the explicit
16097 instantiation has no effect. */
16100 else if (DECL_EXPLICIT_INSTANTIATION (result))
16104 No program shall explicitly instantiate any template more
16107 We check DECL_NOT_REALLY_EXTERN so as not to complain when
16108 the first instantiation was `extern' and the second is not,
16109 and EXTERN_P for the opposite case. */
16110 if (DECL_NOT_REALLY_EXTERN (result) && !extern_p)
16111 permerror (input_location, "duplicate explicit instantiation of %q#D", result);
16112 /* If an "extern" explicit instantiation follows an ordinary
16113 explicit instantiation, the template is instantiated. */
16117 else if (!DECL_IMPLICIT_INSTANTIATION (result))
16119 error ("no matching template for %qD found", result);
16122 else if (!DECL_TEMPLATE_INFO (result))
16124 permerror (input_location, "explicit instantiation of non-template %q#D", result);
16128 if (storage == NULL_TREE)
16130 else if (storage == ridpointers[(int) RID_EXTERN])
16132 if (!in_system_header && (cxx_dialect == cxx98))
16133 pedwarn (input_location, OPT_pedantic,
16134 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
16139 error ("storage class %qD applied to template instantiation", storage);
16141 check_explicit_instantiation_namespace (result);
16142 mark_decl_instantiated (result, extern_p);
16144 instantiate_decl (result, /*defer_ok=*/1,
16145 /*expl_inst_class_mem_p=*/false);
16149 mark_class_instantiated (tree t, int extern_p)
16151 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
16152 SET_CLASSTYPE_INTERFACE_KNOWN (t);
16153 CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
16154 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
16157 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
16158 rest_of_type_compilation (t, 1);
16162 /* Called from do_type_instantiation through binding_table_foreach to
16163 do recursive instantiation for the type bound in ENTRY. */
16165 bt_instantiate_type_proc (binding_entry entry, void *data)
16167 tree storage = *(tree *) data;
16169 if (MAYBE_CLASS_TYPE_P (entry->type)
16170 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type)))
16171 do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0);
16174 /* Called from do_type_instantiation to instantiate a member
16175 (a member function or a static member variable) of an
16176 explicitly instantiated class template. */
16178 instantiate_class_member (tree decl, int extern_p)
16180 mark_decl_instantiated (decl, extern_p);
16182 instantiate_decl (decl, /*defer_ok=*/1,
16183 /*expl_inst_class_mem_p=*/true);
16186 /* Perform an explicit instantiation of template class T. STORAGE, if
16187 non-null, is the RID for extern, inline or static. COMPLAIN is
16188 nonzero if this is called from the parser, zero if called recursively,
16189 since the standard is unclear (as detailed below). */
16192 do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
16197 int previous_instantiation_extern_p = 0;
16199 if (TREE_CODE (t) == TYPE_DECL)
16202 if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t))
16204 error ("explicit instantiation of non-template type %qT", t);
16210 if (!COMPLETE_TYPE_P (t))
16212 if (complain & tf_error)
16213 error ("explicit instantiation of %q#T before definition of template",
16218 if (storage != NULL_TREE)
16220 if (!in_system_header)
16222 if (storage == ridpointers[(int) RID_EXTERN])
16224 if (cxx_dialect == cxx98)
16225 pedwarn (input_location, OPT_pedantic,
16226 "ISO C++ 1998 forbids the use of %<extern%> on "
16227 "explicit instantiations");
16230 pedwarn (input_location, OPT_pedantic,
16231 "ISO C++ forbids the use of %qE"
16232 " on explicit instantiations", storage);
16235 if (storage == ridpointers[(int) RID_INLINE])
16237 else if (storage == ridpointers[(int) RID_EXTERN])
16239 else if (storage == ridpointers[(int) RID_STATIC])
16243 error ("storage class %qD applied to template instantiation",
16249 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
16251 /* DR 259 [temp.spec].
16253 Both an explicit instantiation and a declaration of an explicit
16254 specialization shall not appear in a program unless the explicit
16255 instantiation follows a declaration of the explicit specialization.
16257 For a given set of template parameters, if an explicit
16258 instantiation of a template appears after a declaration of an
16259 explicit specialization for that template, the explicit
16260 instantiation has no effect. */
16263 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t))
16267 No program shall explicitly instantiate any template more
16270 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
16271 instantiation was `extern'. If EXTERN_P then the second is.
16272 These cases are OK. */
16273 previous_instantiation_extern_p = CLASSTYPE_INTERFACE_ONLY (t);
16275 if (!previous_instantiation_extern_p && !extern_p
16276 && (complain & tf_error))
16277 permerror (input_location, "duplicate explicit instantiation of %q#T", t);
16279 /* If we've already instantiated the template, just return now. */
16280 if (!CLASSTYPE_INTERFACE_ONLY (t))
16284 check_explicit_instantiation_namespace (TYPE_NAME (t));
16285 mark_class_instantiated (t, extern_p);
16293 /* In contrast to implicit instantiation, where only the
16294 declarations, and not the definitions, of members are
16295 instantiated, we have here:
16299 The explicit instantiation of a class template specialization
16300 implies the instantiation of all of its members not
16301 previously explicitly specialized in the translation unit
16302 containing the explicit instantiation.
16304 Of course, we can't instantiate member template classes, since
16305 we don't have any arguments for them. Note that the standard
16306 is unclear on whether the instantiation of the members are
16307 *explicit* instantiations or not. However, the most natural
16308 interpretation is that it should be an explicit instantiation. */
16311 for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp))
16312 if (TREE_CODE (tmp) == FUNCTION_DECL
16313 && DECL_TEMPLATE_INSTANTIATION (tmp))
16314 instantiate_class_member (tmp, extern_p);
16316 for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp))
16317 if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp))
16318 instantiate_class_member (tmp, extern_p);
16320 if (CLASSTYPE_NESTED_UTDS (t))
16321 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t),
16322 bt_instantiate_type_proc, &storage);
16326 /* Given a function DECL, which is a specialization of TMPL, modify
16327 DECL to be a re-instantiation of TMPL with the same template
16328 arguments. TMPL should be the template into which tsubst'ing
16329 should occur for DECL, not the most general template.
16331 One reason for doing this is a scenario like this:
16334 void f(const T&, int i);
16336 void g() { f(3, 7); }
16339 void f(const T& t, const int i) { }
16341 Note that when the template is first instantiated, with
16342 instantiate_template, the resulting DECL will have no name for the
16343 first parameter, and the wrong type for the second. So, when we go
16344 to instantiate the DECL, we regenerate it. */
16347 regenerate_decl_from_template (tree decl, tree tmpl)
16349 /* The arguments used to instantiate DECL, from the most general
16354 args = DECL_TI_ARGS (decl);
16355 code_pattern = DECL_TEMPLATE_RESULT (tmpl);
16357 /* Make sure that we can see identifiers, and compute access
16359 push_access_scope (decl);
16361 if (TREE_CODE (decl) == FUNCTION_DECL)
16369 args_depth = TMPL_ARGS_DEPTH (args);
16370 parms_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
16371 if (args_depth > parms_depth)
16372 args = get_innermost_template_args (args, parms_depth);
16374 specs = tsubst_exception_specification (TREE_TYPE (code_pattern),
16375 args, tf_error, NULL_TREE);
16377 TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl),
16380 /* Merge parameter declarations. */
16381 decl_parm = skip_artificial_parms_for (decl,
16382 DECL_ARGUMENTS (decl));
16384 = skip_artificial_parms_for (code_pattern,
16385 DECL_ARGUMENTS (code_pattern));
16386 while (decl_parm && !FUNCTION_PARAMETER_PACK_P (pattern_parm))
16391 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
16392 DECL_NAME (decl_parm) = DECL_NAME (pattern_parm);
16393 parm_type = tsubst (TREE_TYPE (pattern_parm), args, tf_error,
16395 parm_type = type_decays_to (parm_type);
16396 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
16397 TREE_TYPE (decl_parm) = parm_type;
16398 attributes = DECL_ATTRIBUTES (pattern_parm);
16399 if (DECL_ATTRIBUTES (decl_parm) != attributes)
16401 DECL_ATTRIBUTES (decl_parm) = attributes;
16402 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
16404 decl_parm = TREE_CHAIN (decl_parm);
16405 pattern_parm = TREE_CHAIN (pattern_parm);
16407 /* Merge any parameters that match with the function parameter
16409 if (pattern_parm && FUNCTION_PARAMETER_PACK_P (pattern_parm))
16412 tree expanded_types;
16413 /* Expand the TYPE_PACK_EXPANSION that provides the types for
16414 the parameters in this function parameter pack. */
16415 expanded_types = tsubst_pack_expansion (TREE_TYPE (pattern_parm),
16416 args, tf_error, NULL_TREE);
16417 len = TREE_VEC_LENGTH (expanded_types);
16418 for (i = 0; i < len; i++)
16423 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
16424 /* Rename the parameter to include the index. */
16425 DECL_NAME (decl_parm) =
16426 make_ith_pack_parameter_name (DECL_NAME (pattern_parm), i);
16427 parm_type = TREE_VEC_ELT (expanded_types, i);
16428 parm_type = type_decays_to (parm_type);
16429 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
16430 TREE_TYPE (decl_parm) = parm_type;
16431 attributes = DECL_ATTRIBUTES (pattern_parm);
16432 if (DECL_ATTRIBUTES (decl_parm) != attributes)
16434 DECL_ATTRIBUTES (decl_parm) = attributes;
16435 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
16437 decl_parm = TREE_CHAIN (decl_parm);
16440 /* Merge additional specifiers from the CODE_PATTERN. */
16441 if (DECL_DECLARED_INLINE_P (code_pattern)
16442 && !DECL_DECLARED_INLINE_P (decl))
16443 DECL_DECLARED_INLINE_P (decl) = 1;
16445 else if (TREE_CODE (decl) == VAR_DECL)
16446 DECL_INITIAL (decl) =
16447 tsubst_expr (DECL_INITIAL (code_pattern), args,
16448 tf_error, DECL_TI_TEMPLATE (decl),
16449 /*integral_constant_expression_p=*/false);
16451 gcc_unreachable ();
16453 pop_access_scope (decl);
16456 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
16457 substituted to get DECL. */
16460 template_for_substitution (tree decl)
16462 tree tmpl = DECL_TI_TEMPLATE (decl);
16464 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
16465 for the instantiation. This is not always the most general
16466 template. Consider, for example:
16469 struct S { template <class U> void f();
16470 template <> void f<int>(); };
16472 and an instantiation of S<double>::f<int>. We want TD to be the
16473 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
16474 while (/* An instantiation cannot have a definition, so we need a
16475 more general template. */
16476 DECL_TEMPLATE_INSTANTIATION (tmpl)
16477 /* We must also deal with friend templates. Given:
16479 template <class T> struct S {
16480 template <class U> friend void f() {};
16483 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
16484 so far as the language is concerned, but that's still
16485 where we get the pattern for the instantiation from. On
16486 other hand, if the definition comes outside the class, say:
16488 template <class T> struct S {
16489 template <class U> friend void f();
16491 template <class U> friend void f() {}
16493 we don't need to look any further. That's what the check for
16494 DECL_INITIAL is for. */
16495 || (TREE_CODE (decl) == FUNCTION_DECL
16496 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl)
16497 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl))))
16499 /* The present template, TD, should not be a definition. If it
16500 were a definition, we should be using it! Note that we
16501 cannot restructure the loop to just keep going until we find
16502 a template with a definition, since that might go too far if
16503 a specialization was declared, but not defined. */
16504 gcc_assert (TREE_CODE (decl) != VAR_DECL
16505 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl)));
16507 /* Fetch the more general template. */
16508 tmpl = DECL_TI_TEMPLATE (tmpl);
16514 /* Returns true if we need to instantiate this template instance even if we
16515 know we aren't going to emit it.. */
16518 always_instantiate_p (tree decl)
16520 /* We always instantiate inline functions so that we can inline them. An
16521 explicit instantiation declaration prohibits implicit instantiation of
16522 non-inline functions. With high levels of optimization, we would
16523 normally inline non-inline functions -- but we're not allowed to do
16524 that for "extern template" functions. Therefore, we check
16525 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
16526 return ((TREE_CODE (decl) == FUNCTION_DECL
16527 && DECL_DECLARED_INLINE_P (decl))
16528 /* And we need to instantiate static data members so that
16529 their initializers are available in integral constant
16531 || (TREE_CODE (decl) == VAR_DECL
16532 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl)));
16535 /* Produce the definition of D, a _DECL generated from a template. If
16536 DEFER_OK is nonzero, then we don't have to actually do the
16537 instantiation now; we just have to do it sometime. Normally it is
16538 an error if this is an explicit instantiation but D is undefined.
16539 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
16540 explicitly instantiated class template. */
16543 instantiate_decl (tree d, int defer_ok,
16544 bool expl_inst_class_mem_p)
16546 tree tmpl = DECL_TI_TEMPLATE (d);
16553 bool pattern_defined;
16555 location_t saved_loc = input_location;
16558 /* This function should only be used to instantiate templates for
16559 functions and static member variables. */
16560 gcc_assert (TREE_CODE (d) == FUNCTION_DECL
16561 || TREE_CODE (d) == VAR_DECL);
16563 /* Variables are never deferred; if instantiation is required, they
16564 are instantiated right away. That allows for better code in the
16565 case that an expression refers to the value of the variable --
16566 if the variable has a constant value the referring expression can
16567 take advantage of that fact. */
16568 if (TREE_CODE (d) == VAR_DECL)
16571 /* Don't instantiate cloned functions. Instead, instantiate the
16572 functions they cloned. */
16573 if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d))
16574 d = DECL_CLONED_FUNCTION (d);
16576 if (DECL_TEMPLATE_INSTANTIATED (d)
16577 || DECL_TEMPLATE_SPECIALIZATION (d))
16578 /* D has already been instantiated or explicitly specialized, so
16579 there's nothing for us to do here.
16581 It might seem reasonable to check whether or not D is an explicit
16582 instantiation, and, if so, stop here. But when an explicit
16583 instantiation is deferred until the end of the compilation,
16584 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
16585 the instantiation. */
16588 /* Check to see whether we know that this template will be
16589 instantiated in some other file, as with "extern template"
16591 external_p = (DECL_INTERFACE_KNOWN (d) && DECL_REALLY_EXTERN (d));
16593 /* In general, we do not instantiate such templates. */
16594 if (external_p && !always_instantiate_p (d))
16597 gen_tmpl = most_general_template (tmpl);
16598 gen_args = DECL_TI_ARGS (d);
16600 if (tmpl != gen_tmpl)
16601 /* We should already have the extra args. */
16602 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl))
16603 == TMPL_ARGS_DEPTH (gen_args));
16604 /* And what's in the hash table should match D. */
16605 gcc_assert ((spec = retrieve_specialization (gen_tmpl, gen_args, 0)) == d
16606 || spec == NULL_TREE);
16608 /* This needs to happen before any tsubsting. */
16609 if (! push_tinst_level (d))
16612 timevar_push (TV_PARSE);
16614 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
16615 for the instantiation. */
16616 td = template_for_substitution (d);
16617 code_pattern = DECL_TEMPLATE_RESULT (td);
16619 /* We should never be trying to instantiate a member of a class
16620 template or partial specialization. */
16621 gcc_assert (d != code_pattern);
16623 if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d))
16624 || DECL_TEMPLATE_SPECIALIZATION (td))
16625 /* In the case of a friend template whose definition is provided
16626 outside the class, we may have too many arguments. Drop the
16627 ones we don't need. The same is true for specializations. */
16628 args = get_innermost_template_args
16629 (gen_args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td)));
16633 if (TREE_CODE (d) == FUNCTION_DECL)
16634 pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE);
16636 pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
16638 /* We may be in the middle of deferred access check. Disable it now. */
16639 push_deferring_access_checks (dk_no_deferred);
16641 /* Unless an explicit instantiation directive has already determined
16642 the linkage of D, remember that a definition is available for
16644 if (pattern_defined
16645 && !DECL_INTERFACE_KNOWN (d)
16646 && !DECL_NOT_REALLY_EXTERN (d))
16647 mark_definable (d);
16649 input_location = DECL_SOURCE_LOCATION (d);
16651 /* If D is a member of an explicitly instantiated class template,
16652 and no definition is available, treat it like an implicit
16654 if (!pattern_defined && expl_inst_class_mem_p
16655 && DECL_EXPLICIT_INSTANTIATION (d))
16657 DECL_NOT_REALLY_EXTERN (d) = 0;
16658 DECL_INTERFACE_KNOWN (d) = 0;
16659 SET_DECL_IMPLICIT_INSTANTIATION (d);
16662 /* Recheck the substitutions to obtain any warning messages
16663 about ignoring cv qualifiers. Don't do this for artificial decls,
16664 as it breaks the context-sensitive substitution for lambda op(). */
16665 if (!defer_ok && !DECL_ARTIFICIAL (d))
16667 tree gen = DECL_TEMPLATE_RESULT (gen_tmpl);
16668 tree type = TREE_TYPE (gen);
16670 /* Make sure that we can see identifiers, and compute access
16671 correctly. D is already the target FUNCTION_DECL with the
16673 push_access_scope (d);
16675 if (TREE_CODE (gen) == FUNCTION_DECL)
16677 tsubst (DECL_ARGUMENTS (gen), gen_args, tf_warning_or_error, d);
16678 tsubst_exception_specification (type, gen_args, tf_warning_or_error,
16680 /* Don't simply tsubst the function type, as that will give
16681 duplicate warnings about poor parameter qualifications.
16682 The function arguments are the same as the decl_arguments
16683 without the top level cv qualifiers. */
16684 type = TREE_TYPE (type);
16686 tsubst (type, gen_args, tf_warning_or_error, d);
16688 pop_access_scope (d);
16691 /* Defer all other templates, unless we have been explicitly
16692 forbidden from doing so. */
16693 if (/* If there is no definition, we cannot instantiate the
16696 /* If it's OK to postpone instantiation, do so. */
16698 /* If this is a static data member that will be defined
16699 elsewhere, we don't want to instantiate the entire data
16700 member, but we do want to instantiate the initializer so that
16701 we can substitute that elsewhere. */
16702 || (external_p && TREE_CODE (d) == VAR_DECL))
16704 /* The definition of the static data member is now required so
16705 we must substitute the initializer. */
16706 if (TREE_CODE (d) == VAR_DECL
16707 && !DECL_INITIAL (d)
16708 && DECL_INITIAL (code_pattern))
16713 ns = decl_namespace_context (d);
16714 push_nested_namespace (ns);
16715 push_nested_class (DECL_CONTEXT (d));
16716 init = tsubst_expr (DECL_INITIAL (code_pattern),
16718 tf_warning_or_error, NULL_TREE,
16719 /*integral_constant_expression_p=*/false);
16720 cp_finish_decl (d, init, /*init_const_expr_p=*/false,
16721 /*asmspec_tree=*/NULL_TREE,
16722 LOOKUP_ONLYCONVERTING);
16723 pop_nested_class ();
16724 pop_nested_namespace (ns);
16727 /* We restore the source position here because it's used by
16728 add_pending_template. */
16729 input_location = saved_loc;
16731 if (at_eof && !pattern_defined
16732 && DECL_EXPLICIT_INSTANTIATION (d)
16733 && DECL_NOT_REALLY_EXTERN (d))
16736 The definition of a non-exported function template, a
16737 non-exported member function template, or a non-exported
16738 member function or static data member of a class template
16739 shall be present in every translation unit in which it is
16740 explicitly instantiated. */
16741 permerror (input_location, "explicit instantiation of %qD "
16742 "but no definition available", d);
16744 /* ??? Historically, we have instantiated inline functions, even
16745 when marked as "extern template". */
16746 if (!(external_p && TREE_CODE (d) == VAR_DECL))
16747 add_pending_template (d);
16750 /* Tell the repository that D is available in this translation unit
16751 -- and see if it is supposed to be instantiated here. */
16752 if (TREE_PUBLIC (d) && !DECL_REALLY_EXTERN (d) && !repo_emit_p (d))
16754 /* In a PCH file, despite the fact that the repository hasn't
16755 requested instantiation in the PCH it is still possible that
16756 an instantiation will be required in a file that includes the
16759 add_pending_template (d);
16760 /* Instantiate inline functions so that the inliner can do its
16761 job, even though we'll not be emitting a copy of this
16763 if (!(TREE_CODE (d) == FUNCTION_DECL && possibly_inlined_p (d)))
16767 need_push = !cfun || !global_bindings_p ();
16769 push_to_top_level ();
16771 /* Mark D as instantiated so that recursive calls to
16772 instantiate_decl do not try to instantiate it again. */
16773 DECL_TEMPLATE_INSTANTIATED (d) = 1;
16775 /* Regenerate the declaration in case the template has been modified
16776 by a subsequent redeclaration. */
16777 regenerate_decl_from_template (d, td);
16779 /* We already set the file and line above. Reset them now in case
16780 they changed as a result of calling regenerate_decl_from_template. */
16781 input_location = DECL_SOURCE_LOCATION (d);
16783 if (TREE_CODE (d) == VAR_DECL)
16787 /* Clear out DECL_RTL; whatever was there before may not be right
16788 since we've reset the type of the declaration. */
16789 SET_DECL_RTL (d, NULL_RTX);
16790 DECL_IN_AGGR_P (d) = 0;
16792 /* The initializer is placed in DECL_INITIAL by
16793 regenerate_decl_from_template. Pull it out so that
16794 cp_finish_decl can process it. */
16795 init = DECL_INITIAL (d);
16796 DECL_INITIAL (d) = NULL_TREE;
16797 DECL_INITIALIZED_P (d) = 0;
16799 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
16800 initializer. That function will defer actual emission until
16801 we have a chance to determine linkage. */
16802 DECL_EXTERNAL (d) = 0;
16804 /* Enter the scope of D so that access-checking works correctly. */
16805 push_nested_class (DECL_CONTEXT (d));
16806 cp_finish_decl (d, init, false, NULL_TREE, 0);
16807 pop_nested_class ();
16809 else if (TREE_CODE (d) == FUNCTION_DECL)
16811 htab_t saved_local_specializations;
16816 /* Save away the current list, in case we are instantiating one
16817 template from within the body of another. */
16818 saved_local_specializations = local_specializations;
16820 /* Set up the list of local specializations. */
16821 local_specializations = htab_create (37,
16822 hash_local_specialization,
16823 eq_local_specializations,
16826 /* Set up context. */
16827 start_preparsed_function (d, NULL_TREE, SF_PRE_PARSED);
16829 /* Create substitution entries for the parameters. */
16830 subst_decl = DECL_TEMPLATE_RESULT (template_for_substitution (d));
16831 tmpl_parm = DECL_ARGUMENTS (subst_decl);
16832 spec_parm = DECL_ARGUMENTS (d);
16833 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d))
16835 register_local_specialization (spec_parm, tmpl_parm);
16836 spec_parm = skip_artificial_parms_for (d, spec_parm);
16837 tmpl_parm = skip_artificial_parms_for (subst_decl, tmpl_parm);
16839 while (tmpl_parm && !FUNCTION_PARAMETER_PACK_P (tmpl_parm))
16841 register_local_specialization (spec_parm, tmpl_parm);
16842 tmpl_parm = TREE_CHAIN (tmpl_parm);
16843 spec_parm = TREE_CHAIN (spec_parm);
16845 if (tmpl_parm && FUNCTION_PARAMETER_PACK_P (tmpl_parm))
16847 /* Register the (value) argument pack as a specialization of
16848 TMPL_PARM, then move on. */
16849 tree argpack = make_fnparm_pack (spec_parm);
16850 register_local_specialization (argpack, tmpl_parm);
16851 tmpl_parm = TREE_CHAIN (tmpl_parm);
16852 spec_parm = NULL_TREE;
16854 gcc_assert (!spec_parm);
16856 /* Substitute into the body of the function. */
16857 tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
16858 tf_warning_or_error, tmpl,
16859 /*integral_constant_expression_p=*/false);
16861 /* Set the current input_location to the end of the function
16862 so that finish_function knows where we are. */
16863 input_location = DECL_STRUCT_FUNCTION (code_pattern)->function_end_locus;
16865 /* We don't need the local specializations any more. */
16866 htab_delete (local_specializations);
16867 local_specializations = saved_local_specializations;
16869 /* Finish the function. */
16870 d = finish_function (0);
16871 expand_or_defer_fn (d);
16874 /* We're not deferring instantiation any more. */
16875 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
16878 pop_from_top_level ();
16881 input_location = saved_loc;
16882 pop_deferring_access_checks ();
16883 pop_tinst_level ();
16885 timevar_pop (TV_PARSE);
16890 /* Run through the list of templates that we wish we could
16891 instantiate, and instantiate any we can. RETRIES is the
16892 number of times we retry pending template instantiation. */
16895 instantiate_pending_templates (int retries)
16898 location_t saved_loc = input_location;
16900 /* Instantiating templates may trigger vtable generation. This in turn
16901 may require further template instantiations. We place a limit here
16902 to avoid infinite loop. */
16903 if (pending_templates && retries >= max_tinst_depth)
16905 tree decl = pending_templates->tinst->decl;
16907 error ("template instantiation depth exceeds maximum of %d"
16908 " instantiating %q+D, possibly from virtual table generation"
16909 " (use -ftemplate-depth= to increase the maximum)",
16910 max_tinst_depth, decl);
16911 if (TREE_CODE (decl) == FUNCTION_DECL)
16912 /* Pretend that we defined it. */
16913 DECL_INITIAL (decl) = error_mark_node;
16919 struct pending_template **t = &pending_templates;
16920 struct pending_template *last = NULL;
16924 tree instantiation = reopen_tinst_level ((*t)->tinst);
16925 bool complete = false;
16927 if (TYPE_P (instantiation))
16931 if (!COMPLETE_TYPE_P (instantiation))
16933 instantiate_class_template (instantiation);
16934 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
16935 for (fn = TYPE_METHODS (instantiation);
16937 fn = TREE_CHAIN (fn))
16938 if (! DECL_ARTIFICIAL (fn))
16939 instantiate_decl (fn,
16941 /*expl_inst_class_mem_p=*/false);
16942 if (COMPLETE_TYPE_P (instantiation))
16946 complete = COMPLETE_TYPE_P (instantiation);
16950 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation)
16951 && !DECL_TEMPLATE_INSTANTIATED (instantiation))
16954 = instantiate_decl (instantiation,
16956 /*expl_inst_class_mem_p=*/false);
16957 if (DECL_TEMPLATE_INSTANTIATED (instantiation))
16961 complete = (DECL_TEMPLATE_SPECIALIZATION (instantiation)
16962 || DECL_TEMPLATE_INSTANTIATED (instantiation));
16966 /* If INSTANTIATION has been instantiated, then we don't
16967 need to consider it again in the future. */
16975 current_tinst_level = NULL;
16977 last_pending_template = last;
16979 while (reconsider);
16981 input_location = saved_loc;
16984 /* Substitute ARGVEC into T, which is a list of initializers for
16985 either base class or a non-static data member. The TREE_PURPOSEs
16986 are DECLs, and the TREE_VALUEs are the initializer values. Used by
16987 instantiate_decl. */
16990 tsubst_initializer_list (tree t, tree argvec)
16992 tree inits = NULL_TREE;
16994 for (; t; t = TREE_CHAIN (t))
16998 tree expanded_bases = NULL_TREE;
16999 tree expanded_arguments = NULL_TREE;
17002 if (TREE_CODE (TREE_PURPOSE (t)) == TYPE_PACK_EXPANSION)
17007 /* Expand the base class expansion type into separate base
17009 expanded_bases = tsubst_pack_expansion (TREE_PURPOSE (t), argvec,
17010 tf_warning_or_error,
17012 if (expanded_bases == error_mark_node)
17015 /* We'll be building separate TREE_LISTs of arguments for
17017 len = TREE_VEC_LENGTH (expanded_bases);
17018 expanded_arguments = make_tree_vec (len);
17019 for (i = 0; i < len; i++)
17020 TREE_VEC_ELT (expanded_arguments, i) = NULL_TREE;
17022 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
17023 expand each argument in the TREE_VALUE of t. */
17024 expr = make_node (EXPR_PACK_EXPANSION);
17025 PACK_EXPANSION_PARAMETER_PACKS (expr) =
17026 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t));
17028 if (TREE_VALUE (t) == void_type_node)
17029 /* VOID_TYPE_NODE is used to indicate
17030 value-initialization. */
17032 for (i = 0; i < len; i++)
17033 TREE_VEC_ELT (expanded_arguments, i) = void_type_node;
17037 /* Substitute parameter packs into each argument in the
17039 in_base_initializer = 1;
17040 for (arg = TREE_VALUE (t); arg; arg = TREE_CHAIN (arg))
17042 tree expanded_exprs;
17044 /* Expand the argument. */
17045 SET_PACK_EXPANSION_PATTERN (expr, TREE_VALUE (arg));
17047 = tsubst_pack_expansion (expr, argvec,
17048 tf_warning_or_error,
17050 if (expanded_exprs == error_mark_node)
17053 /* Prepend each of the expanded expressions to the
17054 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
17055 for (i = 0; i < len; i++)
17057 TREE_VEC_ELT (expanded_arguments, i) =
17058 tree_cons (NULL_TREE,
17059 TREE_VEC_ELT (expanded_exprs, i),
17060 TREE_VEC_ELT (expanded_arguments, i));
17063 in_base_initializer = 0;
17065 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
17066 since we built them backwards. */
17067 for (i = 0; i < len; i++)
17069 TREE_VEC_ELT (expanded_arguments, i) =
17070 nreverse (TREE_VEC_ELT (expanded_arguments, i));
17075 for (i = 0; i < len; ++i)
17077 if (expanded_bases)
17079 decl = TREE_VEC_ELT (expanded_bases, i);
17080 decl = expand_member_init (decl);
17081 init = TREE_VEC_ELT (expanded_arguments, i);
17085 decl = tsubst_copy (TREE_PURPOSE (t), argvec,
17086 tf_warning_or_error, NULL_TREE);
17088 decl = expand_member_init (decl);
17089 if (decl && !DECL_P (decl))
17090 in_base_initializer = 1;
17092 init = tsubst_expr (TREE_VALUE (t), argvec,
17093 tf_warning_or_error, NULL_TREE,
17094 /*integral_constant_expression_p=*/false);
17095 in_base_initializer = 0;
17100 init = build_tree_list (decl, init);
17101 TREE_CHAIN (init) = inits;
17109 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
17112 set_current_access_from_decl (tree decl)
17114 if (TREE_PRIVATE (decl))
17115 current_access_specifier = access_private_node;
17116 else if (TREE_PROTECTED (decl))
17117 current_access_specifier = access_protected_node;
17119 current_access_specifier = access_public_node;
17122 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
17123 is the instantiation (which should have been created with
17124 start_enum) and ARGS are the template arguments to use. */
17127 tsubst_enum (tree tag, tree newtag, tree args)
17131 for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
17136 decl = TREE_VALUE (e);
17137 /* Note that in a template enum, the TREE_VALUE is the
17138 CONST_DECL, not the corresponding INTEGER_CST. */
17139 value = tsubst_expr (DECL_INITIAL (decl),
17140 args, tf_warning_or_error, NULL_TREE,
17141 /*integral_constant_expression_p=*/true);
17143 /* Give this enumeration constant the correct access. */
17144 set_current_access_from_decl (decl);
17146 /* Actually build the enumerator itself. */
17147 build_enumerator (DECL_NAME (decl), value, newtag);
17150 finish_enum (newtag);
17151 DECL_SOURCE_LOCATION (TYPE_NAME (newtag))
17152 = DECL_SOURCE_LOCATION (TYPE_NAME (tag));
17155 /* DECL is a FUNCTION_DECL that is a template specialization. Return
17156 its type -- but without substituting the innermost set of template
17157 arguments. So, innermost set of template parameters will appear in
17161 get_mostly_instantiated_function_type (tree decl)
17169 tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
17170 targs = DECL_TI_ARGS (decl);
17171 tparms = DECL_TEMPLATE_PARMS (tmpl);
17172 parm_depth = TMPL_PARMS_DEPTH (tparms);
17174 /* There should be as many levels of arguments as there are levels
17176 gcc_assert (parm_depth == TMPL_ARGS_DEPTH (targs));
17178 fn_type = TREE_TYPE (tmpl);
17180 if (parm_depth == 1)
17181 /* No substitution is necessary. */
17185 int i, save_access_control;
17188 /* Replace the innermost level of the TARGS with NULL_TREEs to
17189 let tsubst know not to substitute for those parameters. */
17190 partial_args = make_tree_vec (TREE_VEC_LENGTH (targs));
17191 for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i)
17192 SET_TMPL_ARGS_LEVEL (partial_args, i,
17193 TMPL_ARGS_LEVEL (targs, i));
17194 SET_TMPL_ARGS_LEVEL (partial_args,
17195 TMPL_ARGS_DEPTH (targs),
17196 make_tree_vec (DECL_NTPARMS (tmpl)));
17198 /* Disable access control as this function is used only during
17200 save_access_control = flag_access_control;
17201 flag_access_control = 0;
17203 ++processing_template_decl;
17204 /* Now, do the (partial) substitution to figure out the
17205 appropriate function type. */
17206 fn_type = tsubst (fn_type, partial_args, tf_error, NULL_TREE);
17207 --processing_template_decl;
17209 /* Substitute into the template parameters to obtain the real
17210 innermost set of parameters. This step is important if the
17211 innermost set of template parameters contains value
17212 parameters whose types depend on outer template parameters. */
17213 TREE_VEC_LENGTH (partial_args)--;
17214 tparms = tsubst_template_parms (tparms, partial_args, tf_error);
17216 flag_access_control = save_access_control;
17222 /* Return truthvalue if we're processing a template different from
17223 the last one involved in diagnostics. */
17225 problematic_instantiation_changed (void)
17227 return last_template_error_tick != tinst_level_tick;
17230 /* Remember current template involved in diagnostics. */
17232 record_last_problematic_instantiation (void)
17234 last_template_error_tick = tinst_level_tick;
17237 struct tinst_level *
17238 current_instantiation (void)
17240 return current_tinst_level;
17243 /* [temp.param] Check that template non-type parm TYPE is of an allowable
17244 type. Return zero for ok, nonzero for disallowed. Issue error and
17245 warning messages under control of COMPLAIN. */
17248 invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain)
17250 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type))
17252 else if (POINTER_TYPE_P (type))
17254 else if (TYPE_PTR_TO_MEMBER_P (type))
17256 else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
17258 else if (TREE_CODE (type) == TYPENAME_TYPE)
17261 if (complain & tf_error)
17262 error ("%q#T is not a valid type for a template constant parameter", type);
17266 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
17267 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
17270 dependent_type_p_r (tree type)
17276 A type is dependent if it is:
17278 -- a template parameter. Template template parameters are types
17279 for us (since TYPE_P holds true for them) so we handle
17281 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
17282 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
17284 /* -- a qualified-id with a nested-name-specifier which contains a
17285 class-name that names a dependent type or whose unqualified-id
17286 names a dependent type. */
17287 if (TREE_CODE (type) == TYPENAME_TYPE)
17289 /* -- a cv-qualified type where the cv-unqualified type is
17291 type = TYPE_MAIN_VARIANT (type);
17292 /* -- a compound type constructed from any dependent type. */
17293 if (TYPE_PTR_TO_MEMBER_P (type))
17294 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type))
17295 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
17297 else if (TREE_CODE (type) == POINTER_TYPE
17298 || TREE_CODE (type) == REFERENCE_TYPE)
17299 return dependent_type_p (TREE_TYPE (type));
17300 else if (TREE_CODE (type) == FUNCTION_TYPE
17301 || TREE_CODE (type) == METHOD_TYPE)
17305 if (dependent_type_p (TREE_TYPE (type)))
17307 for (arg_type = TYPE_ARG_TYPES (type);
17309 arg_type = TREE_CHAIN (arg_type))
17310 if (dependent_type_p (TREE_VALUE (arg_type)))
17314 /* -- an array type constructed from any dependent type or whose
17315 size is specified by a constant expression that is
17316 value-dependent. */
17317 if (TREE_CODE (type) == ARRAY_TYPE)
17319 if (TYPE_DOMAIN (type)
17320 && dependent_type_p (TYPE_DOMAIN (type)))
17322 return dependent_type_p (TREE_TYPE (type));
17324 else if (TREE_CODE (type) == INTEGER_TYPE
17325 && !TREE_CONSTANT (TYPE_MAX_VALUE (type)))
17327 /* If this is the TYPE_DOMAIN of an array type, consider it
17328 dependent. We already checked for value-dependence in
17329 compute_array_index_type. */
17330 return type_dependent_expression_p (TYPE_MAX_VALUE (type));
17333 /* -- a template-id in which either the template name is a template
17335 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
17337 /* ... or any of the template arguments is a dependent type or
17338 an expression that is type-dependent or value-dependent. */
17339 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
17340 && (any_dependent_template_arguments_p
17341 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
17344 /* All TYPEOF_TYPEs and DECLTYPE_TYPEs are dependent; if the
17345 argument of the `typeof' expression is not type-dependent, then
17346 it should already been have resolved. */
17347 if (TREE_CODE (type) == TYPEOF_TYPE
17348 || TREE_CODE (type) == DECLTYPE_TYPE)
17351 /* A template argument pack is dependent if any of its packed
17353 if (TREE_CODE (type) == TYPE_ARGUMENT_PACK)
17355 tree args = ARGUMENT_PACK_ARGS (type);
17356 int i, len = TREE_VEC_LENGTH (args);
17357 for (i = 0; i < len; ++i)
17358 if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
17362 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
17363 be template parameters. */
17364 if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
17367 /* The standard does not specifically mention types that are local
17368 to template functions or local classes, but they should be
17369 considered dependent too. For example:
17371 template <int I> void f() {
17376 The size of `E' cannot be known until the value of `I' has been
17377 determined. Therefore, `E' must be considered dependent. */
17378 scope = TYPE_CONTEXT (type);
17379 if (scope && TYPE_P (scope))
17380 return dependent_type_p (scope);
17381 else if (scope && TREE_CODE (scope) == FUNCTION_DECL)
17382 return type_dependent_expression_p (scope);
17384 /* Other types are non-dependent. */
17388 /* Returns TRUE if TYPE is dependent, in the sense of
17389 [temp.dep.type]. */
17392 dependent_type_p (tree type)
17394 /* If there are no template parameters in scope, then there can't be
17395 any dependent types. */
17396 if (!processing_template_decl)
17398 /* If we are not processing a template, then nobody should be
17399 providing us with a dependent type. */
17401 gcc_assert (TREE_CODE (type) != TEMPLATE_TYPE_PARM || is_auto (type));
17405 /* If the type is NULL, we have not computed a type for the entity
17406 in question; in that case, the type is dependent. */
17410 /* Erroneous types can be considered non-dependent. */
17411 if (type == error_mark_node)
17414 /* If we have not already computed the appropriate value for TYPE,
17416 if (!TYPE_DEPENDENT_P_VALID (type))
17418 TYPE_DEPENDENT_P (type) = dependent_type_p_r (type);
17419 TYPE_DEPENDENT_P_VALID (type) = 1;
17422 return TYPE_DEPENDENT_P (type);
17425 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
17426 lookup. In other words, a dependent type that is not the current
17430 dependent_scope_p (tree scope)
17432 return (scope && TYPE_P (scope) && dependent_type_p (scope)
17433 && !currently_open_class (scope));
17436 /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
17439 dependent_scope_ref_p (tree expression, bool criterion (tree))
17444 gcc_assert (TREE_CODE (expression) == SCOPE_REF);
17446 if (!TYPE_P (TREE_OPERAND (expression, 0)))
17449 scope = TREE_OPERAND (expression, 0);
17450 name = TREE_OPERAND (expression, 1);
17454 An id-expression is type-dependent if it contains a
17455 nested-name-specifier that contains a class-name that names a
17457 /* The suggested resolution to Core Issue 224 implies that if the
17458 qualifying type is the current class, then we must peek
17461 && currently_open_class (scope)
17462 && !criterion (name))
17464 if (dependent_type_p (scope))
17470 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
17471 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
17475 value_dependent_expression_p (tree expression)
17477 if (!processing_template_decl)
17480 /* A name declared with a dependent type. */
17481 if (DECL_P (expression) && type_dependent_expression_p (expression))
17484 switch (TREE_CODE (expression))
17486 case IDENTIFIER_NODE:
17487 /* A name that has not been looked up -- must be dependent. */
17490 case TEMPLATE_PARM_INDEX:
17491 /* A non-type template parm. */
17495 /* A non-type template parm. */
17496 if (DECL_TEMPLATE_PARM_P (expression))
17498 return value_dependent_expression_p (DECL_INITIAL (expression));
17501 /* A constant with integral or enumeration type and is initialized
17502 with an expression that is value-dependent. */
17503 if (DECL_INITIAL (expression)
17504 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression))
17505 && value_dependent_expression_p (DECL_INITIAL (expression)))
17509 case DYNAMIC_CAST_EXPR:
17510 case STATIC_CAST_EXPR:
17511 case CONST_CAST_EXPR:
17512 case REINTERPRET_CAST_EXPR:
17514 /* These expressions are value-dependent if the type to which
17515 the cast occurs is dependent or the expression being casted
17516 is value-dependent. */
17518 tree type = TREE_TYPE (expression);
17520 if (dependent_type_p (type))
17523 /* A functional cast has a list of operands. */
17524 expression = TREE_OPERAND (expression, 0);
17527 /* If there are no operands, it must be an expression such
17528 as "int()". This should not happen for aggregate types
17529 because it would form non-constant expressions. */
17530 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
17535 if (TREE_CODE (expression) == TREE_LIST)
17536 return any_value_dependent_elements_p (expression);
17538 return value_dependent_expression_p (expression);
17543 /* A `sizeof' expression is value-dependent if the operand is
17544 type-dependent or is a pack expansion. */
17545 expression = TREE_OPERAND (expression, 0);
17546 if (PACK_EXPANSION_P (expression))
17548 else if (TYPE_P (expression))
17549 return dependent_type_p (expression);
17550 return type_dependent_expression_p (expression);
17553 return dependent_scope_ref_p (expression, value_dependent_expression_p);
17555 case COMPONENT_REF:
17556 return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
17557 || value_dependent_expression_p (TREE_OPERAND (expression, 1)));
17560 /* A CALL_EXPR may appear in a constant expression if it is a
17561 call to a builtin function, e.g., __builtin_constant_p. All
17562 such calls are value-dependent. */
17565 case NONTYPE_ARGUMENT_PACK:
17566 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
17567 is value-dependent. */
17569 tree values = ARGUMENT_PACK_ARGS (expression);
17570 int i, len = TREE_VEC_LENGTH (values);
17572 for (i = 0; i < len; ++i)
17573 if (value_dependent_expression_p (TREE_VEC_ELT (values, i)))
17581 tree type2 = TRAIT_EXPR_TYPE2 (expression);
17582 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression))
17583 || (type2 ? dependent_type_p (type2) : false));
17587 return ((value_dependent_expression_p (TREE_OPERAND (expression, 0)))
17588 || (value_dependent_expression_p (TREE_OPERAND (expression, 2))));
17591 /* A constant expression is value-dependent if any subexpression is
17592 value-dependent. */
17593 switch (TREE_CODE_CLASS (TREE_CODE (expression)))
17595 case tcc_reference:
17597 return (value_dependent_expression_p
17598 (TREE_OPERAND (expression, 0)));
17600 case tcc_comparison:
17602 return ((value_dependent_expression_p
17603 (TREE_OPERAND (expression, 0)))
17604 || (value_dependent_expression_p
17605 (TREE_OPERAND (expression, 1))));
17607 case tcc_expression:
17611 for (i = 0; i < TREE_OPERAND_LENGTH (expression); ++i)
17612 /* In some cases, some of the operands may be missing.
17613 (For example, in the case of PREDECREMENT_EXPR, the
17614 amount to increment by may be missing.) That doesn't
17615 make the expression dependent. */
17616 if (TREE_OPERAND (expression, i)
17617 && (value_dependent_expression_p
17618 (TREE_OPERAND (expression, i))))
17628 /* The expression is not value-dependent. */
17632 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
17633 [temp.dep.expr]. */
17636 type_dependent_expression_p (tree expression)
17638 if (!processing_template_decl)
17641 if (expression == error_mark_node)
17644 /* An unresolved name is always dependent. */
17645 if (TREE_CODE (expression) == IDENTIFIER_NODE
17646 || TREE_CODE (expression) == USING_DECL)
17649 /* Some expression forms are never type-dependent. */
17650 if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR
17651 || TREE_CODE (expression) == SIZEOF_EXPR
17652 || TREE_CODE (expression) == ALIGNOF_EXPR
17653 || TREE_CODE (expression) == TRAIT_EXPR
17654 || TREE_CODE (expression) == TYPEID_EXPR
17655 || TREE_CODE (expression) == DELETE_EXPR
17656 || TREE_CODE (expression) == VEC_DELETE_EXPR
17657 || TREE_CODE (expression) == THROW_EXPR)
17660 /* The types of these expressions depends only on the type to which
17661 the cast occurs. */
17662 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
17663 || TREE_CODE (expression) == STATIC_CAST_EXPR
17664 || TREE_CODE (expression) == CONST_CAST_EXPR
17665 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
17666 || TREE_CODE (expression) == CAST_EXPR)
17667 return dependent_type_p (TREE_TYPE (expression));
17669 /* The types of these expressions depends only on the type created
17670 by the expression. */
17671 if (TREE_CODE (expression) == NEW_EXPR
17672 || TREE_CODE (expression) == VEC_NEW_EXPR)
17674 /* For NEW_EXPR tree nodes created inside a template, either
17675 the object type itself or a TREE_LIST may appear as the
17677 tree type = TREE_OPERAND (expression, 1);
17678 if (TREE_CODE (type) == TREE_LIST)
17679 /* This is an array type. We need to check array dimensions
17681 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type)))
17682 || value_dependent_expression_p
17683 (TREE_OPERAND (TREE_VALUE (type), 1));
17685 return dependent_type_p (type);
17688 if (TREE_CODE (expression) == SCOPE_REF
17689 && dependent_scope_ref_p (expression,
17690 type_dependent_expression_p))
17693 if (TREE_CODE (expression) == FUNCTION_DECL
17694 && DECL_LANG_SPECIFIC (expression)
17695 && DECL_TEMPLATE_INFO (expression)
17696 && (any_dependent_template_arguments_p
17697 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
17700 if (TREE_CODE (expression) == TEMPLATE_DECL
17701 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression))
17704 if (TREE_CODE (expression) == STMT_EXPR)
17705 expression = stmt_expr_value_expr (expression);
17707 if (BRACE_ENCLOSED_INITIALIZER_P (expression))
17712 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression), i, elt)
17714 if (type_dependent_expression_p (elt))
17720 if (TREE_TYPE (expression) == unknown_type_node)
17722 if (TREE_CODE (expression) == ADDR_EXPR)
17723 return type_dependent_expression_p (TREE_OPERAND (expression, 0));
17724 if (TREE_CODE (expression) == COMPONENT_REF
17725 || TREE_CODE (expression) == OFFSET_REF)
17727 if (type_dependent_expression_p (TREE_OPERAND (expression, 0)))
17729 expression = TREE_OPERAND (expression, 1);
17730 if (TREE_CODE (expression) == IDENTIFIER_NODE)
17733 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
17734 if (TREE_CODE (expression) == SCOPE_REF)
17737 if (TREE_CODE (expression) == BASELINK)
17738 expression = BASELINK_FUNCTIONS (expression);
17740 if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
17742 if (any_dependent_template_arguments_p
17743 (TREE_OPERAND (expression, 1)))
17745 expression = TREE_OPERAND (expression, 0);
17747 gcc_assert (TREE_CODE (expression) == OVERLOAD
17748 || TREE_CODE (expression) == FUNCTION_DECL);
17752 if (type_dependent_expression_p (OVL_CURRENT (expression)))
17754 expression = OVL_NEXT (expression);
17759 gcc_assert (TREE_CODE (expression) != TYPE_DECL);
17761 return (dependent_type_p (TREE_TYPE (expression)));
17764 /* Like type_dependent_expression_p, but it also works while not processing
17765 a template definition, i.e. during substitution or mangling. */
17768 type_dependent_expression_p_push (tree expr)
17771 ++processing_template_decl;
17772 b = type_dependent_expression_p (expr);
17773 --processing_template_decl;
17777 /* Returns TRUE if ARGS contains a type-dependent expression. */
17780 any_type_dependent_arguments_p (const VEC(tree,gc) *args)
17785 for (i = 0; VEC_iterate (tree, args, i, arg); ++i)
17787 if (type_dependent_expression_p (arg))
17793 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
17794 expressions) contains any value-dependent expressions. */
17797 any_value_dependent_elements_p (const_tree list)
17799 for (; list; list = TREE_CHAIN (list))
17800 if (value_dependent_expression_p (TREE_VALUE (list)))
17806 /* Returns TRUE if the ARG (a template argument) is dependent. */
17809 dependent_template_arg_p (tree arg)
17811 if (!processing_template_decl)
17814 if (TREE_CODE (arg) == TEMPLATE_DECL
17815 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
17816 return dependent_template_p (arg);
17817 else if (ARGUMENT_PACK_P (arg))
17819 tree args = ARGUMENT_PACK_ARGS (arg);
17820 int i, len = TREE_VEC_LENGTH (args);
17821 for (i = 0; i < len; ++i)
17823 if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
17829 else if (TYPE_P (arg))
17830 return dependent_type_p (arg);
17832 return (type_dependent_expression_p (arg)
17833 || value_dependent_expression_p (arg));
17836 /* Returns true if ARGS (a collection of template arguments) contains
17837 any types that require structural equality testing. */
17840 any_template_arguments_need_structural_equality_p (tree args)
17847 if (args == error_mark_node)
17850 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
17852 tree level = TMPL_ARGS_LEVEL (args, i + 1);
17853 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
17855 tree arg = TREE_VEC_ELT (level, j);
17856 tree packed_args = NULL_TREE;
17859 if (ARGUMENT_PACK_P (arg))
17861 /* Look inside the argument pack. */
17862 packed_args = ARGUMENT_PACK_ARGS (arg);
17863 len = TREE_VEC_LENGTH (packed_args);
17866 for (k = 0; k < len; ++k)
17869 arg = TREE_VEC_ELT (packed_args, k);
17871 if (error_operand_p (arg))
17873 else if (TREE_CODE (arg) == TEMPLATE_DECL
17874 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
17876 else if (TYPE_P (arg) && TYPE_STRUCTURAL_EQUALITY_P (arg))
17878 else if (!TYPE_P (arg) && TREE_TYPE (arg)
17879 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg)))
17888 /* Returns true if ARGS (a collection of template arguments) contains
17889 any dependent arguments. */
17892 any_dependent_template_arguments_p (const_tree args)
17899 if (args == error_mark_node)
17902 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
17904 const_tree level = TMPL_ARGS_LEVEL (args, i + 1);
17905 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
17906 if (dependent_template_arg_p (TREE_VEC_ELT (level, j)))
17913 /* Returns TRUE if the template TMPL is dependent. */
17916 dependent_template_p (tree tmpl)
17918 if (TREE_CODE (tmpl) == OVERLOAD)
17922 if (dependent_template_p (OVL_FUNCTION (tmpl)))
17924 tmpl = OVL_CHAIN (tmpl);
17929 /* Template template parameters are dependent. */
17930 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
17931 || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
17933 /* So are names that have not been looked up. */
17934 if (TREE_CODE (tmpl) == SCOPE_REF
17935 || TREE_CODE (tmpl) == IDENTIFIER_NODE)
17937 /* So are member templates of dependent classes. */
17938 if (TYPE_P (CP_DECL_CONTEXT (tmpl)))
17939 return dependent_type_p (DECL_CONTEXT (tmpl));
17943 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
17946 dependent_template_id_p (tree tmpl, tree args)
17948 return (dependent_template_p (tmpl)
17949 || any_dependent_template_arguments_p (args));
17952 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
17956 dependent_omp_for_p (tree declv, tree initv, tree condv, tree incrv)
17960 if (!processing_template_decl)
17963 for (i = 0; i < TREE_VEC_LENGTH (declv); i++)
17965 tree decl = TREE_VEC_ELT (declv, i);
17966 tree init = TREE_VEC_ELT (initv, i);
17967 tree cond = TREE_VEC_ELT (condv, i);
17968 tree incr = TREE_VEC_ELT (incrv, i);
17970 if (type_dependent_expression_p (decl))
17973 if (init && type_dependent_expression_p (init))
17976 if (type_dependent_expression_p (cond))
17979 if (COMPARISON_CLASS_P (cond)
17980 && (type_dependent_expression_p (TREE_OPERAND (cond, 0))
17981 || type_dependent_expression_p (TREE_OPERAND (cond, 1))))
17984 if (TREE_CODE (incr) == MODOP_EXPR)
17986 if (type_dependent_expression_p (TREE_OPERAND (incr, 0))
17987 || type_dependent_expression_p (TREE_OPERAND (incr, 2)))
17990 else if (type_dependent_expression_p (incr))
17992 else if (TREE_CODE (incr) == MODIFY_EXPR)
17994 if (type_dependent_expression_p (TREE_OPERAND (incr, 0)))
17996 else if (BINARY_CLASS_P (TREE_OPERAND (incr, 1)))
17998 tree t = TREE_OPERAND (incr, 1);
17999 if (type_dependent_expression_p (TREE_OPERAND (t, 0))
18000 || type_dependent_expression_p (TREE_OPERAND (t, 1)))
18009 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
18010 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
18011 no such TYPE can be found. Note that this function peers inside
18012 uninstantiated templates and therefore should be used only in
18013 extremely limited situations. ONLY_CURRENT_P restricts this
18014 peering to the currently open classes hierarchy (which is required
18015 when comparing types). */
18018 resolve_typename_type (tree type, bool only_current_p)
18027 gcc_assert (TREE_CODE (type) == TYPENAME_TYPE);
18029 scope = TYPE_CONTEXT (type);
18030 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
18031 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
18032 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
18033 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
18034 identifier of the TYPENAME_TYPE anymore.
18035 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
18036 TYPENAME_TYPE instead, we avoid messing up with a possible
18037 typedef variant case. */
18038 name = TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
18040 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
18041 it first before we can figure out what NAME refers to. */
18042 if (TREE_CODE (scope) == TYPENAME_TYPE)
18043 scope = resolve_typename_type (scope, only_current_p);
18044 /* If we don't know what SCOPE refers to, then we cannot resolve the
18046 if (TREE_CODE (scope) == TYPENAME_TYPE)
18048 /* If the SCOPE is a template type parameter, we have no way of
18049 resolving the name. */
18050 if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
18052 /* If the SCOPE is not the current instantiation, there's no reason
18053 to look inside it. */
18054 if (only_current_p && !currently_open_class (scope))
18056 /* If this is a typedef, we don't want to look inside (c++/11987). */
18057 if (typedef_variant_p (type))
18059 /* If SCOPE isn't the template itself, it will not have a valid
18060 TYPE_FIELDS list. */
18061 if (same_type_p (scope, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope)))
18062 /* scope is either the template itself or a compatible instantiation
18063 like X<T>, so look up the name in the original template. */
18064 scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope);
18066 /* scope is a partial instantiation, so we can't do the lookup or we
18067 will lose the template arguments. */
18069 /* Enter the SCOPE so that name lookup will be resolved as if we
18070 were in the class definition. In particular, SCOPE will no
18071 longer be considered a dependent type. */
18072 pushed_scope = push_scope (scope);
18073 /* Look up the declaration. */
18074 decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true);
18076 result = NULL_TREE;
18078 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
18079 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
18082 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE
18083 && TREE_CODE (decl) == TYPE_DECL)
18085 result = TREE_TYPE (decl);
18086 if (result == error_mark_node)
18087 result = NULL_TREE;
18089 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR
18090 && DECL_CLASS_TEMPLATE_P (decl))
18094 /* Obtain the template and the arguments. */
18095 tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0);
18096 args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1);
18097 /* Instantiate the template. */
18098 result = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE,
18099 /*entering_scope=*/0,
18100 tf_error | tf_user);
18101 if (result == error_mark_node)
18102 result = NULL_TREE;
18105 /* Leave the SCOPE. */
18107 pop_scope (pushed_scope);
18109 /* If we failed to resolve it, return the original typename. */
18113 /* If lookup found a typename type, resolve that too. */
18114 if (TREE_CODE (result) == TYPENAME_TYPE && !TYPENAME_IS_RESOLVING_P (result))
18116 /* Ill-formed programs can cause infinite recursion here, so we
18117 must catch that. */
18118 TYPENAME_IS_RESOLVING_P (type) = 1;
18119 result = resolve_typename_type (result, only_current_p);
18120 TYPENAME_IS_RESOLVING_P (type) = 0;
18123 /* Qualify the resulting type. */
18124 quals = cp_type_quals (type);
18126 result = cp_build_qualified_type (result, cp_type_quals (result) | quals);
18131 /* EXPR is an expression which is not type-dependent. Return a proxy
18132 for EXPR that can be used to compute the types of larger
18133 expressions containing EXPR. */
18136 build_non_dependent_expr (tree expr)
18140 /* Preserve null pointer constants so that the type of things like
18141 "p == 0" where "p" is a pointer can be determined. */
18142 if (null_ptr_cst_p (expr))
18144 /* Preserve OVERLOADs; the functions must be available to resolve
18147 if (TREE_CODE (inner_expr) == STMT_EXPR)
18148 inner_expr = stmt_expr_value_expr (inner_expr);
18149 if (TREE_CODE (inner_expr) == ADDR_EXPR)
18150 inner_expr = TREE_OPERAND (inner_expr, 0);
18151 if (TREE_CODE (inner_expr) == COMPONENT_REF)
18152 inner_expr = TREE_OPERAND (inner_expr, 1);
18153 if (is_overloaded_fn (inner_expr)
18154 || TREE_CODE (inner_expr) == OFFSET_REF)
18156 /* There is no need to return a proxy for a variable. */
18157 if (TREE_CODE (expr) == VAR_DECL)
18159 /* Preserve string constants; conversions from string constants to
18160 "char *" are allowed, even though normally a "const char *"
18161 cannot be used to initialize a "char *". */
18162 if (TREE_CODE (expr) == STRING_CST)
18164 /* Preserve arithmetic constants, as an optimization -- there is no
18165 reason to create a new node. */
18166 if (TREE_CODE (expr) == INTEGER_CST || TREE_CODE (expr) == REAL_CST)
18168 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
18169 There is at least one place where we want to know that a
18170 particular expression is a throw-expression: when checking a ?:
18171 expression, there are special rules if the second or third
18172 argument is a throw-expression. */
18173 if (TREE_CODE (expr) == THROW_EXPR)
18176 if (TREE_CODE (expr) == COND_EXPR)
18177 return build3 (COND_EXPR,
18179 TREE_OPERAND (expr, 0),
18180 (TREE_OPERAND (expr, 1)
18181 ? build_non_dependent_expr (TREE_OPERAND (expr, 1))
18182 : build_non_dependent_expr (TREE_OPERAND (expr, 0))),
18183 build_non_dependent_expr (TREE_OPERAND (expr, 2)));
18184 if (TREE_CODE (expr) == COMPOUND_EXPR
18185 && !COMPOUND_EXPR_OVERLOADED (expr))
18186 return build2 (COMPOUND_EXPR,
18188 TREE_OPERAND (expr, 0),
18189 build_non_dependent_expr (TREE_OPERAND (expr, 1)));
18191 /* If the type is unknown, it can't really be non-dependent */
18192 gcc_assert (TREE_TYPE (expr) != unknown_type_node);
18194 /* Otherwise, build a NON_DEPENDENT_EXPR.
18196 REFERENCE_TYPEs are not stripped for expressions in templates
18197 because doing so would play havoc with mangling. Consider, for
18200 template <typename T> void f<T& g>() { g(); }
18202 In the body of "f", the expression for "g" will have
18203 REFERENCE_TYPE, even though the standard says that it should
18204 not. The reason is that we must preserve the syntactic form of
18205 the expression so that mangling (say) "f<g>" inside the body of
18206 "f" works out correctly. Therefore, the REFERENCE_TYPE is
18208 return build1 (NON_DEPENDENT_EXPR, non_reference (TREE_TYPE (expr)), expr);
18211 /* ARGS is a vector of expressions as arguments to a function call.
18212 Replace the arguments with equivalent non-dependent expressions.
18213 This modifies ARGS in place. */
18216 make_args_non_dependent (VEC(tree,gc) *args)
18221 for (ix = 0; VEC_iterate (tree, args, ix, arg); ++ix)
18223 tree newarg = build_non_dependent_expr (arg);
18225 VEC_replace (tree, args, ix, newarg);
18229 /* Returns a type which represents 'auto'. We use a TEMPLATE_TYPE_PARM
18230 with a level one deeper than the actual template parms. */
18235 tree au = cxx_make_type (TEMPLATE_TYPE_PARM);
18236 TYPE_NAME (au) = build_decl (BUILTINS_LOCATION,
18237 TYPE_DECL, get_identifier ("auto"), au);
18238 TYPE_STUB_DECL (au) = TYPE_NAME (au);
18239 TEMPLATE_TYPE_PARM_INDEX (au) = build_template_parm_index
18240 (0, processing_template_decl + 1, processing_template_decl + 1,
18241 TYPE_NAME (au), NULL_TREE);
18242 TYPE_CANONICAL (au) = canonical_type_parameter (au);
18243 DECL_ARTIFICIAL (TYPE_NAME (au)) = 1;
18244 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au));
18249 /* Given type ARG, return std::initializer_list<ARG>. */
18254 tree std_init_list = namespace_binding
18255 (get_identifier ("initializer_list"), std_node);
18257 if (!std_init_list || !DECL_CLASS_TEMPLATE_P (std_init_list))
18259 error ("deducing from brace-enclosed initializer list requires "
18260 "#include <initializer_list>");
18261 return error_mark_node;
18263 argvec = make_tree_vec (1);
18264 TREE_VEC_ELT (argvec, 0) = arg;
18265 return lookup_template_class (std_init_list, argvec, NULL_TREE,
18266 NULL_TREE, 0, tf_warning_or_error);
18269 /* Replace auto in TYPE with std::initializer_list<auto>. */
18272 listify_autos (tree type, tree auto_node)
18274 tree init_auto = listify (auto_node);
18275 tree argvec = make_tree_vec (1);
18276 TREE_VEC_ELT (argvec, 0) = init_auto;
18277 if (processing_template_decl)
18278 argvec = add_to_template_args (current_template_args (), argvec);
18279 return tsubst (type, argvec, tf_warning_or_error, NULL_TREE);
18282 /* walk_tree helper for do_auto_deduction. */
18285 contains_auto_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
18288 /* Is this a variable with the type we're looking for? */
18290 && TREE_TYPE (*tp) == type)
18296 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
18297 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
18300 do_auto_deduction (tree type, tree init, tree auto_node)
18302 tree parms, tparms, targs;
18307 /* The name of the object being declared shall not appear in the
18308 initializer expression. */
18309 decl = cp_walk_tree_without_duplicates (&init, contains_auto_r, type);
18312 error ("variable %q#D with %<auto%> type used in its own "
18313 "initializer", decl);
18314 return error_mark_node;
18317 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
18318 with either a new invented type template parameter U or, if the
18319 initializer is a braced-init-list (8.5.4), with
18320 std::initializer_list<U>. */
18321 if (BRACE_ENCLOSED_INITIALIZER_P (init))
18322 type = listify_autos (type, auto_node);
18324 parms = build_tree_list (NULL_TREE, type);
18326 tparms = make_tree_vec (1);
18327 targs = make_tree_vec (1);
18328 TREE_VEC_ELT (tparms, 0)
18329 = build_tree_list (NULL_TREE, TYPE_NAME (auto_node));
18330 val = type_unification_real (tparms, targs, parms, args, 1, 0,
18331 DEDUCE_CALL, LOOKUP_NORMAL);
18334 error ("unable to deduce %qT from %qE", type, init);
18335 return error_mark_node;
18338 /* If the list of declarators contains more than one declarator, the type
18339 of each declared variable is determined as described above. If the
18340 type deduced for the template parameter U is not the same in each
18341 deduction, the program is ill-formed. */
18342 if (TREE_TYPE (auto_node)
18343 && !same_type_p (TREE_TYPE (auto_node), TREE_VEC_ELT (targs, 0)))
18345 error ("inconsistent deduction for %qT: %qT and then %qT",
18346 auto_node, TREE_TYPE (auto_node), TREE_VEC_ELT (targs, 0));
18347 return error_mark_node;
18349 TREE_TYPE (auto_node) = TREE_VEC_ELT (targs, 0);
18351 if (processing_template_decl)
18352 targs = add_to_template_args (current_template_args (), targs);
18353 return tsubst (type, targs, tf_warning_or_error, NULL_TREE);
18356 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
18360 splice_late_return_type (tree type, tree late_return_type)
18364 if (late_return_type == NULL_TREE)
18366 argvec = make_tree_vec (1);
18367 TREE_VEC_ELT (argvec, 0) = late_return_type;
18368 if (processing_template_decl)
18369 argvec = add_to_template_args (current_template_args (), argvec);
18370 return tsubst (type, argvec, tf_warning_or_error, NULL_TREE);
18373 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto'. */
18376 is_auto (const_tree type)
18378 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
18379 && TYPE_IDENTIFIER (type) == get_identifier ("auto"))
18385 /* Returns true iff TYPE contains a use of 'auto'. Since auto can only
18386 appear as a type-specifier for the declaration in question, we don't
18387 have to look through the whole type. */
18390 type_uses_auto (tree type)
18392 enum tree_code code;
18393 if (is_auto (type))
18396 code = TREE_CODE (type);
18398 if (code == POINTER_TYPE || code == REFERENCE_TYPE
18399 || code == OFFSET_TYPE || code == FUNCTION_TYPE
18400 || code == METHOD_TYPE || code == ARRAY_TYPE)
18401 return type_uses_auto (TREE_TYPE (type));
18403 if (TYPE_PTRMEMFUNC_P (type))
18404 return type_uses_auto (TREE_TYPE (TREE_TYPE
18405 (TYPE_PTRMEMFUNC_FN_TYPE (type))));
18410 /* For a given template T, return the vector of typedefs referenced
18411 in T for which access check is needed at T instantiation time.
18412 T is either a FUNCTION_DECL or a RECORD_TYPE.
18413 Those typedefs were added to T by the function
18414 append_type_to_template_for_access_check. */
18416 VEC(qualified_typedef_usage_t,gc)*
18417 get_types_needing_access_check (tree t)
18420 VEC(qualified_typedef_usage_t,gc) *result = NULL;
18422 if (!t || t == error_mark_node)
18425 if (!(ti = get_template_info (t)))
18428 if (CLASS_TYPE_P (t)
18429 || TREE_CODE (t) == FUNCTION_DECL)
18431 if (!TI_TEMPLATE (ti))
18434 result = TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti);
18440 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
18441 tied to T. That list of typedefs will be access checked at
18442 T instantiation time.
18443 T is either a FUNCTION_DECL or a RECORD_TYPE.
18444 TYPE_DECL is a TYPE_DECL node representing a typedef.
18445 SCOPE is the scope through which TYPE_DECL is accessed.
18446 LOCATION is the location of the usage point of TYPE_DECL.
18448 This function is a subroutine of
18449 append_type_to_template_for_access_check. */
18452 append_type_to_template_for_access_check_1 (tree t,
18455 location_t location)
18457 qualified_typedef_usage_t typedef_usage;
18460 if (!t || t == error_mark_node)
18463 gcc_assert ((TREE_CODE (t) == FUNCTION_DECL
18464 || CLASS_TYPE_P (t))
18466 && TREE_CODE (type_decl) == TYPE_DECL
18469 if (!(ti = get_template_info (t)))
18472 gcc_assert (TI_TEMPLATE (ti));
18474 typedef_usage.typedef_decl = type_decl;
18475 typedef_usage.context = scope;
18476 typedef_usage.locus = location;
18478 VEC_safe_push (qualified_typedef_usage_t, gc,
18479 TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti),
18483 /* Append TYPE_DECL to the template TEMPL.
18484 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
18485 At TEMPL instanciation time, TYPE_DECL will be checked to see
18486 if it can be accessed through SCOPE.
18487 LOCATION is the location of the usage point of TYPE_DECL.
18489 e.g. consider the following code snippet:
18496 template<class U> struct S
18498 C::myint mi; // <-- usage point of the typedef C::myint
18503 At S<char> instantiation time, we need to check the access of C::myint
18504 In other words, we need to check the access of the myint typedef through
18505 the C scope. For that purpose, this function will add the myint typedef
18506 and the scope C through which its being accessed to a list of typedefs
18507 tied to the template S. That list will be walked at template instantiation
18508 time and access check performed on each typedefs it contains.
18509 Note that this particular code snippet should yield an error because
18510 myint is private to C. */
18513 append_type_to_template_for_access_check (tree templ,
18516 location_t location)
18518 qualified_typedef_usage_t *iter;
18521 gcc_assert (type_decl && (TREE_CODE (type_decl) == TYPE_DECL));
18523 /* Make sure we don't append the type to the template twice. */
18525 VEC_iterate (qualified_typedef_usage_t,
18526 get_types_needing_access_check (templ),
18529 if (iter->typedef_decl == type_decl && scope == iter->context)
18532 append_type_to_template_for_access_check_1 (templ, type_decl,
18536 /* Set up the hash tables for template instantiations. */
18539 init_template_processing (void)
18541 decl_specializations = htab_create_ggc (37,
18542 hash_specialization,
18543 eq_specializations,
18545 type_specializations = htab_create_ggc (37,
18546 hash_specialization,
18547 eq_specializations,
18551 #include "gt-cp-pt.h"