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"
35 #include "pointer-set.h"
39 #include "cp-objcp-common.h"
40 #include "tree-inline.h"
47 #include "tree-iterator.h"
50 /* The type of functions taking a tree, and some additional data, and
52 typedef int (*tree_fn_t) (tree, void*);
54 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
55 instantiations have been deferred, either because their definitions
56 were not yet available, or because we were putting off doing the work. */
57 struct GTY (()) pending_template {
58 struct pending_template *next;
59 struct tinst_level *tinst;
62 static GTY(()) struct pending_template *pending_templates;
63 static GTY(()) struct pending_template *last_pending_template;
65 int processing_template_parmlist;
66 static int template_header_count;
68 static GTY(()) tree saved_trees;
69 static VEC(int,heap) *inline_parm_levels;
71 static GTY(()) struct tinst_level *current_tinst_level;
73 static GTY(()) tree saved_access_scope;
75 /* Live only within one (recursive) call to tsubst_expr. We use
76 this to pass the statement expression node from the STMT_EXPR
77 to the EXPR_STMT that is its result. */
78 static tree cur_stmt_expr;
80 /* A map from local variable declarations in the body of the template
81 presently being instantiated to the corresponding instantiated
83 static htab_t local_specializations;
85 typedef struct GTY(()) spec_entry
92 static GTY ((param_is (spec_entry)))
93 htab_t decl_specializations;
95 static GTY ((param_is (spec_entry)))
96 htab_t type_specializations;
98 /* Contains canonical template parameter types. The vector is indexed by
99 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
100 TREE_LIST, whose TREE_VALUEs contain the canonical template
101 parameters of various types and levels. */
102 static GTY(()) VEC(tree,gc) *canonical_template_parms;
104 #define UNIFY_ALLOW_NONE 0
105 #define UNIFY_ALLOW_MORE_CV_QUAL 1
106 #define UNIFY_ALLOW_LESS_CV_QUAL 2
107 #define UNIFY_ALLOW_DERIVED 4
108 #define UNIFY_ALLOW_INTEGER 8
109 #define UNIFY_ALLOW_OUTER_LEVEL 16
110 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
111 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
113 static void push_access_scope (tree);
114 static void pop_access_scope (tree);
115 static bool resolve_overloaded_unification (tree, tree, tree, tree,
116 unification_kind_t, int);
117 static int try_one_overload (tree, tree, tree, tree, tree,
118 unification_kind_t, int, bool);
119 static int unify (tree, tree, tree, tree, int);
120 static void add_pending_template (tree);
121 static int push_tinst_level (tree);
122 static void pop_tinst_level (void);
123 static tree reopen_tinst_level (struct tinst_level *);
124 static tree tsubst_initializer_list (tree, tree);
125 static tree get_class_bindings (tree, tree, tree);
126 static tree coerce_template_parms (tree, tree, tree, tsubst_flags_t,
128 static void tsubst_enum (tree, tree, tree);
129 static tree add_to_template_args (tree, tree);
130 static tree add_outermost_template_args (tree, tree);
131 static bool check_instantiated_args (tree, tree, tsubst_flags_t);
132 static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*,
134 static int type_unification_real (tree, tree, tree, const tree *,
135 unsigned int, int, unification_kind_t, int);
136 static void note_template_header (int);
137 static tree convert_nontype_argument_function (tree, tree);
138 static tree convert_nontype_argument (tree, tree);
139 static tree convert_template_argument (tree, tree, tree,
140 tsubst_flags_t, int, tree);
141 static int for_each_template_parm (tree, tree_fn_t, void*,
142 struct pointer_set_t*, bool);
143 static tree expand_template_argument_pack (tree);
144 static tree build_template_parm_index (int, int, int, tree, tree);
145 static bool inline_needs_template_parms (tree);
146 static void push_inline_template_parms_recursive (tree, int);
147 static tree retrieve_local_specialization (tree);
148 static void register_local_specialization (tree, tree);
149 static hashval_t hash_specialization (const void *p);
150 static tree reduce_template_parm_level (tree, tree, int, tree, tsubst_flags_t);
151 static int mark_template_parm (tree, void *);
152 static int template_parm_this_level_p (tree, void *);
153 static tree tsubst_friend_function (tree, tree);
154 static tree tsubst_friend_class (tree, tree);
155 static int can_complete_type_without_circularity (tree);
156 static tree get_bindings (tree, tree, tree, bool);
157 static int template_decl_level (tree);
158 static int check_cv_quals_for_unify (int, tree, tree);
159 static void template_parm_level_and_index (tree, int*, int*);
160 static int unify_pack_expansion (tree, tree, tree, tree, int, bool, bool);
161 static tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree);
162 static tree tsubst_template_args (tree, tree, tsubst_flags_t, tree);
163 static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
164 static void regenerate_decl_from_template (tree, tree);
165 static tree most_specialized_class (tree, tree);
166 static tree tsubst_aggr_type (tree, tree, tsubst_flags_t, tree, int);
167 static tree tsubst_arg_types (tree, tree, tsubst_flags_t, tree);
168 static tree tsubst_function_type (tree, tree, tsubst_flags_t, tree);
169 static bool check_specialization_scope (void);
170 static tree process_partial_specialization (tree);
171 static void set_current_access_from_decl (tree);
172 static tree get_template_base (tree, tree, tree, tree);
173 static tree try_class_unification (tree, tree, tree, tree);
174 static int coerce_template_template_parms (tree, tree, tsubst_flags_t,
176 static bool template_template_parm_bindings_ok_p (tree, tree);
177 static int template_args_equal (tree, tree);
178 static void tsubst_default_arguments (tree);
179 static tree for_each_template_parm_r (tree *, int *, void *);
180 static tree copy_default_args_to_explicit_spec_1 (tree, tree);
181 static void copy_default_args_to_explicit_spec (tree);
182 static int invalid_nontype_parm_type_p (tree, tsubst_flags_t);
183 static int eq_local_specializations (const void *, const void *);
184 static bool dependent_template_arg_p (tree);
185 static bool any_template_arguments_need_structural_equality_p (tree);
186 static bool dependent_type_p_r (tree);
187 static tree tsubst_expr (tree, tree, tsubst_flags_t, tree, bool);
188 static tree tsubst_copy (tree, tree, tsubst_flags_t, tree);
189 static tree tsubst_pack_expansion (tree, tree, tsubst_flags_t, tree);
190 static tree tsubst_decl (tree, tree, tsubst_flags_t);
191 static void perform_typedefs_access_check (tree tmpl, tree targs);
192 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 bool primary_template_instantiation_p (const_tree);
195 static tree listify (tree);
196 static tree listify_autos (tree, tree);
198 /* Make the current scope suitable for access checking when we are
199 processing T. T can be FUNCTION_DECL for instantiated function
200 template, or VAR_DECL for static member variable (need by
201 instantiate_decl). */
204 push_access_scope (tree t)
206 gcc_assert (TREE_CODE (t) == FUNCTION_DECL
207 || TREE_CODE (t) == VAR_DECL);
209 if (DECL_FRIEND_CONTEXT (t))
210 push_nested_class (DECL_FRIEND_CONTEXT (t));
211 else if (DECL_CLASS_SCOPE_P (t))
212 push_nested_class (DECL_CONTEXT (t));
214 push_to_top_level ();
216 if (TREE_CODE (t) == FUNCTION_DECL)
218 saved_access_scope = tree_cons
219 (NULL_TREE, current_function_decl, saved_access_scope);
220 current_function_decl = t;
224 /* Restore the scope set up by push_access_scope. T is the node we
228 pop_access_scope (tree t)
230 if (TREE_CODE (t) == FUNCTION_DECL)
232 current_function_decl = TREE_VALUE (saved_access_scope);
233 saved_access_scope = TREE_CHAIN (saved_access_scope);
236 if (DECL_FRIEND_CONTEXT (t) || DECL_CLASS_SCOPE_P (t))
239 pop_from_top_level ();
242 /* Do any processing required when DECL (a member template
243 declaration) is finished. Returns the TEMPLATE_DECL corresponding
244 to DECL, unless it is a specialization, in which case the DECL
245 itself is returned. */
248 finish_member_template_decl (tree decl)
250 if (decl == error_mark_node)
251 return error_mark_node;
253 gcc_assert (DECL_P (decl));
255 if (TREE_CODE (decl) == TYPE_DECL)
259 type = TREE_TYPE (decl);
260 if (type == error_mark_node)
261 return error_mark_node;
262 if (MAYBE_CLASS_TYPE_P (type)
263 && CLASSTYPE_TEMPLATE_INFO (type)
264 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
266 tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
267 check_member_template (tmpl);
272 else if (TREE_CODE (decl) == FIELD_DECL)
273 error ("data member %qD cannot be a member template", decl);
274 else if (DECL_TEMPLATE_INFO (decl))
276 if (!DECL_TEMPLATE_SPECIALIZATION (decl))
278 check_member_template (DECL_TI_TEMPLATE (decl));
279 return DECL_TI_TEMPLATE (decl);
285 error ("invalid member template declaration %qD", decl);
287 return error_mark_node;
290 /* Return the template info node corresponding to T, whatever T is. */
293 get_template_info (const_tree t)
295 tree tinfo = NULL_TREE;
297 if (!t || t == error_mark_node)
300 if (DECL_P (t) && DECL_LANG_SPECIFIC (t))
301 tinfo = DECL_TEMPLATE_INFO (t);
303 if (!tinfo && DECL_IMPLICIT_TYPEDEF_P (t))
306 if (TAGGED_TYPE_P (t))
307 tinfo = TYPE_TEMPLATE_INFO (t);
312 /* Returns the template nesting level of the indicated class TYPE.
322 A<T>::B<U> has depth two, while A<T> has depth one.
323 Both A<T>::B<int> and A<int>::B<U> have depth one, if
324 they are instantiations, not specializations.
326 This function is guaranteed to return 0 if passed NULL_TREE so
327 that, for example, `template_class_depth (current_class_type)' is
331 template_class_depth (tree type)
336 type && TREE_CODE (type) != NAMESPACE_DECL;
337 type = (TREE_CODE (type) == FUNCTION_DECL)
338 ? CP_DECL_CONTEXT (type) : TYPE_CONTEXT (type))
340 tree tinfo = get_template_info (type);
342 if (tinfo && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo))
343 && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo))))
350 /* Subroutine of maybe_begin_member_template_processing.
351 Returns true if processing DECL needs us to push template parms. */
354 inline_needs_template_parms (tree decl)
356 if (! DECL_TEMPLATE_INFO (decl))
359 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl)))
360 > (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl)));
363 /* Subroutine of maybe_begin_member_template_processing.
364 Push the template parms in PARMS, starting from LEVELS steps into the
365 chain, and ending at the beginning, since template parms are listed
369 push_inline_template_parms_recursive (tree parmlist, int levels)
371 tree parms = TREE_VALUE (parmlist);
375 push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1);
377 ++processing_template_decl;
378 current_template_parms
379 = tree_cons (size_int (processing_template_decl),
380 parms, current_template_parms);
381 TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1;
383 begin_scope (TREE_VEC_LENGTH (parms) ? sk_template_parms : sk_template_spec,
385 for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
387 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
389 if (parm == error_mark_node)
392 gcc_assert (DECL_P (parm));
394 switch (TREE_CODE (parm))
403 /* Make a CONST_DECL as is done in process_template_parm.
404 It is ugly that we recreate this here; the original
405 version built in process_template_parm is no longer
407 tree decl = build_decl (DECL_SOURCE_LOCATION (parm),
408 CONST_DECL, DECL_NAME (parm),
410 DECL_ARTIFICIAL (decl) = 1;
411 TREE_CONSTANT (decl) = 1;
412 TREE_READONLY (decl) = 1;
413 DECL_INITIAL (decl) = DECL_INITIAL (parm);
414 SET_DECL_TEMPLATE_PARM_P (decl);
425 /* Restore the template parameter context for a member template or
426 a friend template defined in a class definition. */
429 maybe_begin_member_template_processing (tree decl)
434 if (inline_needs_template_parms (decl))
436 parms = DECL_TEMPLATE_PARMS (most_general_template (decl));
437 levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl;
439 if (DECL_TEMPLATE_SPECIALIZATION (decl))
442 parms = TREE_CHAIN (parms);
445 push_inline_template_parms_recursive (parms, levels);
448 /* Remember how many levels of template parameters we pushed so that
449 we can pop them later. */
450 VEC_safe_push (int, heap, inline_parm_levels, levels);
453 /* Undo the effects of maybe_begin_member_template_processing. */
456 maybe_end_member_template_processing (void)
461 if (VEC_length (int, inline_parm_levels) == 0)
464 last = VEC_pop (int, inline_parm_levels);
465 for (i = 0; i < last; ++i)
467 --processing_template_decl;
468 current_template_parms = TREE_CHAIN (current_template_parms);
473 /* Return a new template argument vector which contains all of ARGS,
474 but has as its innermost set of arguments the EXTRA_ARGS. */
477 add_to_template_args (tree args, tree extra_args)
484 extra_depth = TMPL_ARGS_DEPTH (extra_args);
485 new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth);
487 for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i)
488 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));
490 for (j = 1; j <= extra_depth; ++j, ++i)
491 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));
496 /* Like add_to_template_args, but only the outermost ARGS are added to
497 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
498 (EXTRA_ARGS) levels are added. This function is used to combine
499 the template arguments from a partial instantiation with the
500 template arguments used to attain the full instantiation from the
501 partial instantiation. */
504 add_outermost_template_args (tree args, tree extra_args)
508 /* If there are more levels of EXTRA_ARGS than there are ARGS,
509 something very fishy is going on. */
510 gcc_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args));
512 /* If *all* the new arguments will be the EXTRA_ARGS, just return
514 if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
517 /* For the moment, we make ARGS look like it contains fewer levels. */
518 TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);
520 new_args = add_to_template_args (args, extra_args);
522 /* Now, we restore ARGS to its full dimensions. */
523 TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);
528 /* Return the N levels of innermost template arguments from the ARGS. */
531 get_innermost_template_args (tree args, int n)
539 /* If N is 1, just return the innermost set of template arguments. */
541 return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args));
543 /* If we're not removing anything, just return the arguments we were
545 extra_levels = TMPL_ARGS_DEPTH (args) - n;
546 gcc_assert (extra_levels >= 0);
547 if (extra_levels == 0)
550 /* Make a new set of arguments, not containing the outer arguments. */
551 new_args = make_tree_vec (n);
552 for (i = 1; i <= n; ++i)
553 SET_TMPL_ARGS_LEVEL (new_args, i,
554 TMPL_ARGS_LEVEL (args, i + extra_levels));
559 /* The inverse of get_innermost_template_args: Return all but the innermost
560 EXTRA_LEVELS levels of template arguments from the ARGS. */
563 strip_innermost_template_args (tree args, int extra_levels)
566 int n = TMPL_ARGS_DEPTH (args) - extra_levels;
571 /* If N is 1, just return the outermost set of template arguments. */
573 return TMPL_ARGS_LEVEL (args, 1);
575 /* If we're not removing anything, just return the arguments we were
577 gcc_assert (extra_levels >= 0);
578 if (extra_levels == 0)
581 /* Make a new set of arguments, not containing the inner arguments. */
582 new_args = make_tree_vec (n);
583 for (i = 1; i <= n; ++i)
584 SET_TMPL_ARGS_LEVEL (new_args, i,
585 TMPL_ARGS_LEVEL (args, i));
590 /* We've got a template header coming up; push to a new level for storing
594 begin_template_parm_list (void)
596 /* We use a non-tag-transparent scope here, which causes pushtag to
597 put tags in this scope, rather than in the enclosing class or
598 namespace scope. This is the right thing, since we want
599 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
600 global template class, push_template_decl handles putting the
601 TEMPLATE_DECL into top-level scope. For a nested template class,
604 template <class T> struct S1 {
605 template <class T> struct S2 {};
608 pushtag contains special code to call pushdecl_with_scope on the
609 TEMPLATE_DECL for S2. */
610 begin_scope (sk_template_parms, NULL);
611 ++processing_template_decl;
612 ++processing_template_parmlist;
613 note_template_header (0);
616 /* This routine is called when a specialization is declared. If it is
617 invalid to declare a specialization here, an error is reported and
618 false is returned, otherwise this routine will return true. */
621 check_specialization_scope (void)
623 tree scope = current_scope ();
627 An explicit specialization shall be declared in the namespace of
628 which the template is a member, or, for member templates, in the
629 namespace of which the enclosing class or enclosing class
630 template is a member. An explicit specialization of a member
631 function, member class or static data member of a class template
632 shall be declared in the namespace of which the class template
634 if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
636 error ("explicit specialization in non-namespace scope %qD", scope);
642 In an explicit specialization declaration for a member of a class
643 template or a member template that appears in namespace scope,
644 the member template and some of its enclosing class templates may
645 remain unspecialized, except that the declaration shall not
646 explicitly specialize a class member template if its enclosing
647 class templates are not explicitly specialized as well. */
648 if (current_template_parms)
650 error ("enclosing class templates are not explicitly specialized");
657 /* We've just seen template <>. */
660 begin_specialization (void)
662 begin_scope (sk_template_spec, NULL);
663 note_template_header (1);
664 return check_specialization_scope ();
667 /* Called at then end of processing a declaration preceded by
671 end_specialization (void)
674 reset_specialization ();
677 /* Any template <>'s that we have seen thus far are not referring to a
678 function specialization. */
681 reset_specialization (void)
683 processing_specialization = 0;
684 template_header_count = 0;
687 /* We've just seen a template header. If SPECIALIZATION is nonzero,
688 it was of the form template <>. */
691 note_template_header (int specialization)
693 processing_specialization = specialization;
694 template_header_count++;
697 /* We're beginning an explicit instantiation. */
700 begin_explicit_instantiation (void)
702 gcc_assert (!processing_explicit_instantiation);
703 processing_explicit_instantiation = true;
708 end_explicit_instantiation (void)
710 gcc_assert (processing_explicit_instantiation);
711 processing_explicit_instantiation = false;
714 /* An explicit specialization or partial specialization TMPL is being
715 declared. Check that the namespace in which the specialization is
716 occurring is permissible. Returns false iff it is invalid to
717 specialize TMPL in the current namespace. */
720 check_specialization_namespace (tree tmpl)
722 tree tpl_ns = decl_namespace_context (tmpl);
726 An explicit specialization shall be declared in the namespace of
727 which the template is a member, or, for member templates, in the
728 namespace of which the enclosing class or enclosing class
729 template is a member. An explicit specialization of a member
730 function, member class or static data member of a class template
731 shall be declared in the namespace of which the class template is
733 if (is_associated_namespace (current_namespace, tpl_ns))
734 /* Same or super-using namespace. */
738 permerror (input_location, "specialization of %qD in different namespace", tmpl);
739 permerror (input_location, " from definition of %q+#D", tmpl);
744 /* SPEC is an explicit instantiation. Check that it is valid to
745 perform this explicit instantiation in the current namespace. */
748 check_explicit_instantiation_namespace (tree spec)
752 /* DR 275: An explicit instantiation shall appear in an enclosing
753 namespace of its template. */
754 ns = decl_namespace_context (spec);
755 if (!is_ancestor (current_namespace, ns))
756 permerror (input_location, "explicit instantiation of %qD in namespace %qD "
757 "(which does not enclose namespace %qD)",
758 spec, current_namespace, ns);
761 /* The TYPE is being declared. If it is a template type, that means it
762 is a partial specialization. Do appropriate error-checking. */
765 maybe_process_partial_specialization (tree type)
769 if (type == error_mark_node)
770 return error_mark_node;
772 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
774 error ("name of class shadows template template parameter %qD",
776 return error_mark_node;
779 context = TYPE_CONTEXT (type);
781 if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type))
783 /* This is for ordinary explicit specialization and partial
784 specialization of a template class such as:
786 template <> class C<int>;
790 template <class T> class C<T*>;
792 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
794 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
795 && !COMPLETE_TYPE_P (type))
797 check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type));
798 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
799 if (processing_template_decl)
801 if (push_template_decl (TYPE_MAIN_DECL (type))
803 return error_mark_node;
806 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
807 error ("specialization of %qT after instantiation", type);
809 else if (CLASS_TYPE_P (type)
810 && !CLASSTYPE_USE_TEMPLATE (type)
811 && CLASSTYPE_TEMPLATE_INFO (type)
812 && context && CLASS_TYPE_P (context)
813 && CLASSTYPE_TEMPLATE_INFO (context))
815 /* This is for an explicit specialization of member class
816 template according to [temp.expl.spec/18]:
818 template <> template <class U> class C<int>::D;
820 The context `C<int>' must be an implicit instantiation.
821 Otherwise this is just a member class template declared
824 template <> class C<int> { template <class U> class D; };
825 template <> template <class U> class C<int>::D;
827 In the first case, `C<int>::D' is a specialization of `C<T>::D'
828 while in the second case, `C<int>::D' is a primary template
829 and `C<T>::D' may not exist. */
831 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context)
832 && !COMPLETE_TYPE_P (type))
835 tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
837 if (current_namespace
838 != decl_namespace_context (tmpl))
840 permerror (input_location, "specializing %q#T in different namespace", type);
841 permerror (input_location, " from definition of %q+#D", tmpl);
844 /* Check for invalid specialization after instantiation:
846 template <> template <> class C<int>::D<int>;
847 template <> template <class U> class C<int>::D; */
849 for (t = DECL_TEMPLATE_INSTANTIATIONS (tmpl);
850 t; t = TREE_CHAIN (t))
852 tree inst = TREE_VALUE (t);
853 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst))
855 /* We already have a full specialization of this partial
856 instantiation. Reassign it to the new member
857 specialization template. */
861 elt.tmpl = most_general_template (tmpl);
862 elt.args = CLASSTYPE_TI_ARGS (inst);
865 htab_remove_elt (type_specializations, &elt);
868 elt.args = INNERMOST_TEMPLATE_ARGS (elt.args);
870 slot = (spec_entry **)
871 htab_find_slot (type_specializations, &elt, INSERT);
872 *slot = GGC_NEW (spec_entry);
875 else if (COMPLETE_TYPE_P (inst) || TYPE_BEING_DEFINED (inst))
876 /* But if we've had an implicit instantiation, that's a
877 problem ([temp.expl.spec]/6). */
878 error ("specialization %qT after instantiation %qT",
882 /* Mark TYPE as a specialization. And as a result, we only
883 have one level of template argument for the innermost
885 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
886 CLASSTYPE_TI_ARGS (type)
887 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
890 else if (processing_specialization)
892 error ("explicit specialization of non-template %qT", type);
893 return error_mark_node;
899 /* Returns nonzero if we can optimize the retrieval of specializations
900 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
901 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
904 optimize_specialization_lookup_p (tree tmpl)
906 return (DECL_FUNCTION_TEMPLATE_P (tmpl)
907 && DECL_CLASS_SCOPE_P (tmpl)
908 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
910 && CLASS_TYPE_P (DECL_CONTEXT (tmpl))
911 /* The optimized lookup depends on the fact that the
912 template arguments for the member function template apply
913 purely to the containing class, which is not true if the
914 containing class is an explicit or partial
916 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl))
917 && !DECL_MEMBER_TEMPLATE_P (tmpl)
918 && !DECL_CONV_FN_P (tmpl)
919 /* It is possible to have a template that is not a member
920 template and is not a member of a template class:
922 template <typename T>
923 struct S { friend A::f(); };
925 Here, the friend function is a template, but the context does
926 not have template information. The optimized lookup relies
927 on having ARGS be the template arguments for both the class
928 and the function template. */
929 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl)));
932 /* Retrieve the specialization (in the sense of [temp.spec] - a
933 specialization is either an instantiation or an explicit
934 specialization) of TMPL for the given template ARGS. If there is
935 no such specialization, return NULL_TREE. The ARGS are a vector of
936 arguments, or a vector of vectors of arguments, in the case of
937 templates with more than one level of parameters.
939 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
940 then we search for a partial specialization matching ARGS. This
941 parameter is ignored if TMPL is not a class template. */
944 retrieve_specialization (tree tmpl, tree args, hashval_t hash)
946 if (args == error_mark_node)
949 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
951 /* There should be as many levels of arguments as there are
952 levels of parameters. */
953 gcc_assert (TMPL_ARGS_DEPTH (args)
954 == TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl)));
956 if (optimize_specialization_lookup_p (tmpl))
959 tree class_specialization;
960 VEC(tree,gc) *methods;
964 /* The template arguments actually apply to the containing
965 class. Find the class specialization with those
967 class_template = CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl));
969 = retrieve_specialization (class_template, args, 0);
970 if (!class_specialization)
972 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
973 for the specialization. */
974 idx = class_method_index_for_fn (class_specialization, tmpl);
977 /* Iterate through the methods with the indicated name, looking
978 for the one that has an instance of TMPL. */
979 methods = CLASSTYPE_METHOD_VEC (class_specialization);
980 for (fns = VEC_index (tree, methods, idx); fns; fns = OVL_NEXT (fns))
982 tree fn = OVL_CURRENT (fns);
983 if (DECL_TEMPLATE_INFO (fn) && DECL_TI_TEMPLATE (fn) == tmpl
984 /* using-declarations can add base methods to the method vec,
985 and we don't want those here. */
986 && DECL_CONTEXT (fn) == class_specialization)
995 htab_t specializations;
999 elt.spec = NULL_TREE;
1001 if (DECL_CLASS_TEMPLATE_P (tmpl))
1002 specializations = type_specializations;
1004 specializations = decl_specializations;
1007 hash = hash_specialization (&elt);
1008 found = (spec_entry *) htab_find_with_hash (specializations, &elt, hash);
1016 /* Like retrieve_specialization, but for local declarations. */
1019 retrieve_local_specialization (tree tmpl)
1023 if (local_specializations == NULL)
1026 spec = (tree) htab_find_with_hash (local_specializations, tmpl,
1027 htab_hash_pointer (tmpl));
1028 return spec ? TREE_PURPOSE (spec) : NULL_TREE;
1031 /* Returns nonzero iff DECL is a specialization of TMPL. */
1034 is_specialization_of (tree decl, tree tmpl)
1038 if (TREE_CODE (decl) == FUNCTION_DECL)
1042 t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
1048 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
1050 for (t = TREE_TYPE (decl);
1052 t = CLASSTYPE_USE_TEMPLATE (t)
1053 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
1054 if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl)))
1061 /* Returns nonzero iff DECL is a specialization of friend declaration
1062 FRIEND_DECL according to [temp.friend]. */
1065 is_specialization_of_friend (tree decl, tree friend_decl)
1067 bool need_template = true;
1070 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
1071 || TREE_CODE (decl) == TYPE_DECL);
1073 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1074 of a template class, we want to check if DECL is a specialization
1076 if (TREE_CODE (friend_decl) == FUNCTION_DECL
1077 && DECL_TEMPLATE_INFO (friend_decl)
1078 && !DECL_USE_TEMPLATE (friend_decl))
1080 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1081 friend_decl = DECL_TI_TEMPLATE (friend_decl);
1082 need_template = false;
1084 else if (TREE_CODE (friend_decl) == TEMPLATE_DECL
1085 && !PRIMARY_TEMPLATE_P (friend_decl))
1086 need_template = false;
1088 /* There is nothing to do if this is not a template friend. */
1089 if (TREE_CODE (friend_decl) != TEMPLATE_DECL)
1092 if (is_specialization_of (decl, friend_decl))
1096 A member of a class template may be declared to be a friend of a
1097 non-template class. In this case, the corresponding member of
1098 every specialization of the class template is a friend of the
1099 class granting friendship.
1101 For example, given a template friend declaration
1103 template <class T> friend void A<T>::f();
1105 the member function below is considered a friend
1107 template <> struct A<int> {
1111 For this type of template friend, TEMPLATE_DEPTH below will be
1112 nonzero. To determine if DECL is a friend of FRIEND, we first
1113 check if the enclosing class is a specialization of another. */
1115 template_depth = template_class_depth (DECL_CONTEXT (friend_decl));
1117 && DECL_CLASS_SCOPE_P (decl)
1118 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)),
1119 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl))))
1121 /* Next, we check the members themselves. In order to handle
1122 a few tricky cases, such as when FRIEND_DECL's are
1124 template <class T> friend void A<T>::g(T t);
1125 template <class T> template <T t> friend void A<T>::h();
1129 void A<int>::g(int);
1130 template <int> void A<int>::h();
1132 we need to figure out ARGS, the template arguments from
1133 the context of DECL. This is required for template substitution
1134 of `T' in the function parameter of `g' and template parameter
1135 of `h' in the above examples. Here ARGS corresponds to `int'. */
1137 tree context = DECL_CONTEXT (decl);
1138 tree args = NULL_TREE;
1139 int current_depth = 0;
1141 while (current_depth < template_depth)
1143 if (CLASSTYPE_TEMPLATE_INFO (context))
1145 if (current_depth == 0)
1146 args = TYPE_TI_ARGS (context);
1148 args = add_to_template_args (TYPE_TI_ARGS (context), args);
1151 context = TYPE_CONTEXT (context);
1154 if (TREE_CODE (decl) == FUNCTION_DECL)
1159 tree friend_args_type;
1160 tree decl_args_type;
1162 /* Make sure that both DECL and FRIEND_DECL are templates or
1164 is_template = DECL_TEMPLATE_INFO (decl)
1165 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl));
1166 if (need_template ^ is_template)
1168 else if (is_template)
1170 /* If both are templates, check template parameter list. */
1172 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl),
1174 if (!comp_template_parms
1175 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)),
1179 decl_type = TREE_TYPE (DECL_TI_TEMPLATE (decl));
1182 decl_type = TREE_TYPE (decl);
1184 friend_type = tsubst_function_type (TREE_TYPE (friend_decl), args,
1185 tf_none, NULL_TREE);
1186 if (friend_type == error_mark_node)
1189 /* Check if return types match. */
1190 if (!same_type_p (TREE_TYPE (decl_type), TREE_TYPE (friend_type)))
1193 /* Check if function parameter types match, ignoring the
1194 `this' parameter. */
1195 friend_args_type = TYPE_ARG_TYPES (friend_type);
1196 decl_args_type = TYPE_ARG_TYPES (decl_type);
1197 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl))
1198 friend_args_type = TREE_CHAIN (friend_args_type);
1199 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1200 decl_args_type = TREE_CHAIN (decl_args_type);
1202 return compparms (decl_args_type, friend_args_type);
1206 /* DECL is a TYPE_DECL */
1208 tree decl_type = TREE_TYPE (decl);
1210 /* Make sure that both DECL and FRIEND_DECL are templates or
1213 = CLASSTYPE_TEMPLATE_INFO (decl_type)
1214 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type));
1216 if (need_template ^ is_template)
1218 else if (is_template)
1221 /* If both are templates, check the name of the two
1222 TEMPLATE_DECL's first because is_friend didn't. */
1223 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type))
1224 != DECL_NAME (friend_decl))
1227 /* Now check template parameter list. */
1229 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl),
1231 return comp_template_parms
1232 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type)),
1236 return (DECL_NAME (decl)
1237 == DECL_NAME (friend_decl));
1243 /* Register the specialization SPEC as a specialization of TMPL with
1244 the indicated ARGS. IS_FRIEND indicates whether the specialization
1245 is actually just a friend declaration. Returns SPEC, or an
1246 equivalent prior declaration, if available. */
1249 register_specialization (tree spec, tree tmpl, tree args, bool is_friend,
1253 spec_entry **slot = NULL;
1256 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL && DECL_P (spec));
1258 if (TREE_CODE (spec) == FUNCTION_DECL
1259 && uses_template_parms (DECL_TI_ARGS (spec)))
1260 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1261 register it; we want the corresponding TEMPLATE_DECL instead.
1262 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1263 the more obvious `uses_template_parms (spec)' to avoid problems
1264 with default function arguments. In particular, given
1265 something like this:
1267 template <class T> void f(T t1, T t = T())
1269 the default argument expression is not substituted for in an
1270 instantiation unless and until it is actually needed. */
1273 if (optimize_specialization_lookup_p (tmpl))
1274 /* We don't put these specializations in the hash table, but we might
1275 want to give an error about a mismatch. */
1276 fn = retrieve_specialization (tmpl, args, 0);
1284 hash = hash_specialization (&elt);
1286 slot = (spec_entry **)
1287 htab_find_slot_with_hash (decl_specializations, &elt, hash, INSERT);
1294 /* We can sometimes try to re-register a specialization that we've
1295 already got. In particular, regenerate_decl_from_template calls
1296 duplicate_decls which will update the specialization list. But,
1297 we'll still get called again here anyhow. It's more convenient
1298 to simply allow this than to try to prevent it. */
1301 else if (fn && DECL_TEMPLATE_SPECIALIZATION (spec))
1303 if (DECL_TEMPLATE_INSTANTIATION (fn))
1305 if (DECL_ODR_USED (fn)
1306 || DECL_EXPLICIT_INSTANTIATION (fn))
1308 error ("specialization of %qD after instantiation",
1310 return error_mark_node;
1315 /* This situation should occur only if the first
1316 specialization is an implicit instantiation, the
1317 second is an explicit specialization, and the
1318 implicit instantiation has not yet been used. That
1319 situation can occur if we have implicitly
1320 instantiated a member function and then specialized
1323 We can also wind up here if a friend declaration that
1324 looked like an instantiation turns out to be a
1327 template <class T> void foo(T);
1328 class S { friend void foo<>(int) };
1329 template <> void foo(int);
1331 We transform the existing DECL in place so that any
1332 pointers to it become pointers to the updated
1335 If there was a definition for the template, but not
1336 for the specialization, we want this to look as if
1337 there were no definition, and vice versa. */
1338 DECL_INITIAL (fn) = NULL_TREE;
1339 duplicate_decls (spec, fn, is_friend);
1340 /* The call to duplicate_decls will have applied
1343 An explicit specialization of a function template
1344 is inline only if it is explicitly declared to be,
1345 and independently of whether its function template
1348 to the primary function; now copy the inline bits to
1349 the various clones. */
1350 FOR_EACH_CLONE (clone, fn)
1352 DECL_DECLARED_INLINE_P (clone)
1353 = DECL_DECLARED_INLINE_P (fn);
1354 DECL_SOURCE_LOCATION (clone)
1355 = DECL_SOURCE_LOCATION (fn);
1357 check_specialization_namespace (fn);
1362 else if (DECL_TEMPLATE_SPECIALIZATION (fn))
1364 if (!duplicate_decls (spec, fn, is_friend) && DECL_INITIAL (spec))
1365 /* Dup decl failed, but this is a new definition. Set the
1366 line number so any errors match this new
1368 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec);
1374 return duplicate_decls (spec, fn, is_friend);
1376 /* A specialization must be declared in the same namespace as the
1377 template it is specializing. */
1378 if (DECL_TEMPLATE_SPECIALIZATION (spec)
1379 && !check_specialization_namespace (tmpl))
1380 DECL_CONTEXT (spec) = DECL_CONTEXT (tmpl);
1382 if (!optimize_specialization_lookup_p (tmpl))
1384 gcc_assert (tmpl && args && spec);
1385 *slot = GGC_NEW (spec_entry);
1387 if (TREE_CODE (spec) == FUNCTION_DECL && DECL_NAMESPACE_SCOPE_P (spec)
1388 && PRIMARY_TEMPLATE_P (tmpl)
1389 && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl)) == NULL_TREE)
1390 /* TMPL is a forward declaration of a template function; keep a list
1391 of all specializations in case we need to reassign them to a friend
1392 template later in tsubst_friend_function. */
1393 DECL_TEMPLATE_INSTANTIATIONS (tmpl)
1394 = tree_cons (args, spec, DECL_TEMPLATE_INSTANTIATIONS (tmpl));
1400 /* Returns true iff two spec_entry nodes are equivalent. Only compares the
1401 TMPL and ARGS members, ignores SPEC. */
1404 eq_specializations (const void *p1, const void *p2)
1406 const spec_entry *e1 = (const spec_entry *)p1;
1407 const spec_entry *e2 = (const spec_entry *)p2;
1409 return (e1->tmpl == e2->tmpl
1410 && comp_template_args (e1->args, e2->args));
1413 /* Returns a hash for a template TMPL and template arguments ARGS. */
1416 hash_tmpl_and_args (tree tmpl, tree args)
1418 hashval_t val = DECL_UID (tmpl);
1419 return iterative_hash_template_arg (args, val);
1422 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1426 hash_specialization (const void *p)
1428 const spec_entry *e = (const spec_entry *)p;
1429 return hash_tmpl_and_args (e->tmpl, e->args);
1432 /* Recursively calculate a hash value for a template argument ARG, for use
1433 in the hash tables of template specializations. */
1436 iterative_hash_template_arg (tree arg, hashval_t val)
1438 unsigned HOST_WIDE_INT i;
1439 enum tree_code code;
1442 if (arg == NULL_TREE)
1443 return iterative_hash_object (arg, val);
1448 code = TREE_CODE (arg);
1449 tclass = TREE_CODE_CLASS (code);
1451 val = iterative_hash_object (code, val);
1458 case IDENTIFIER_NODE:
1459 return iterative_hash_object (IDENTIFIER_HASH_VALUE (arg), val);
1463 int i, len = TREE_VEC_LENGTH (arg);
1464 for (i = 0; i < len; ++i)
1465 val = iterative_hash_template_arg (TREE_VEC_ELT (arg, i), val);
1469 case TYPE_PACK_EXPANSION:
1470 case EXPR_PACK_EXPANSION:
1471 return iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg), val);
1473 case ARGUMENT_PACK_SELECT:
1474 /* We can get one of these when re-hashing a previous entry in the middle
1475 of substituting into a pack expansion. Just look through it... */
1476 arg = ARGUMENT_PACK_SELECT_FROM_PACK (arg);
1477 /* ...and fall through. */
1478 case TYPE_ARGUMENT_PACK:
1479 case NONTYPE_ARGUMENT_PACK:
1480 return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg), val);
1483 for (; arg; arg = TREE_CHAIN (arg))
1484 val = iterative_hash_template_arg (TREE_VALUE (arg), val);
1488 for (; arg; arg = OVL_CHAIN (arg))
1489 val = iterative_hash_template_arg (OVL_FUNCTION (arg), val);
1495 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg), i, field, value)
1497 val = iterative_hash_template_arg (field, val);
1498 val = iterative_hash_template_arg (value, val);
1504 val = iterative_hash_object (DECL_PARM_INDEX (arg), val);
1505 return iterative_hash_template_arg (TREE_TYPE (arg), val);
1508 return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg), val);
1511 val = iterative_hash_template_arg (PTRMEM_CST_CLASS (arg), val);
1512 return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg), val);
1514 case TEMPLATE_PARM_INDEX:
1515 val = iterative_hash_template_arg
1516 (TREE_TYPE (TEMPLATE_PARM_DECL (arg)), val);
1517 val = iterative_hash_object (TEMPLATE_PARM_LEVEL (arg), val);
1518 return iterative_hash_object (TEMPLATE_PARM_IDX (arg), val);
1521 val = iterative_hash_object (TRAIT_EXPR_KIND (arg), val);
1522 val = iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg), val);
1523 return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg), val);
1526 val = iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg)),
1528 return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg)),
1532 val = iterative_hash_template_arg (TREE_OPERAND (arg, 0), val);
1533 code = TREE_CODE (TREE_OPERAND (arg, 1));
1534 val = iterative_hash_object (code, val);
1535 return iterative_hash_template_arg (TREE_OPERAND (arg, 2), val);
1541 if (TYPE_CANONICAL (arg))
1542 return iterative_hash_object (TYPE_HASH (TYPE_CANONICAL (arg)),
1544 else if (TREE_CODE (arg) == DECLTYPE_TYPE)
1545 return iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg), val);
1546 /* Otherwise just compare the types during lookup. */
1549 case tcc_declaration:
1551 return iterative_hash_expr (arg, val);
1554 gcc_assert (IS_EXPR_CODE_CLASS (tclass));
1556 unsigned n = TREE_OPERAND_LENGTH (arg);
1557 for (i = 0; i < n; ++i)
1558 val = iterative_hash_template_arg (TREE_OPERAND (arg, i), val);
1567 /* Unregister the specialization SPEC as a specialization of TMPL.
1568 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1569 if the SPEC was listed as a specialization of TMPL.
1571 Note that SPEC has been ggc_freed, so we can't look inside it. */
1574 reregister_specialization (tree spec, tree tinfo, tree new_spec)
1579 elt.tmpl = most_general_template (TI_TEMPLATE (tinfo));
1580 elt.args = TI_ARGS (tinfo);
1581 elt.spec = NULL_TREE;
1583 slot = (spec_entry **) htab_find_slot (decl_specializations, &elt, INSERT);
1586 gcc_assert ((*slot)->spec == spec || (*slot)->spec == new_spec);
1587 gcc_assert (new_spec != NULL_TREE);
1588 (*slot)->spec = new_spec;
1595 /* Compare an entry in the local specializations hash table P1 (which
1596 is really a pointer to a TREE_LIST) with P2 (which is really a
1600 eq_local_specializations (const void *p1, const void *p2)
1602 return TREE_VALUE ((const_tree) p1) == (const_tree) p2;
1605 /* Hash P1, an entry in the local specializations table. */
1608 hash_local_specialization (const void* p1)
1610 return htab_hash_pointer (TREE_VALUE ((const_tree) p1));
1613 /* Like register_specialization, but for local declarations. We are
1614 registering SPEC, an instantiation of TMPL. */
1617 register_local_specialization (tree spec, tree tmpl)
1621 slot = htab_find_slot_with_hash (local_specializations, tmpl,
1622 htab_hash_pointer (tmpl), INSERT);
1623 *slot = build_tree_list (spec, tmpl);
1626 /* TYPE is a class type. Returns true if TYPE is an explicitly
1627 specialized class. */
1630 explicit_class_specialization_p (tree type)
1632 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
1634 return !uses_template_parms (CLASSTYPE_TI_ARGS (type));
1637 /* Print the list of candidate FNS in an error message. */
1640 print_candidates (tree fns)
1644 const char *str = "candidates are:";
1646 for (fn = fns; fn != NULL_TREE; fn = TREE_CHAIN (fn))
1650 for (f = TREE_VALUE (fn); f; f = OVL_NEXT (f))
1651 error ("%s %+#D", str, OVL_CURRENT (f));
1656 /* Returns the template (one of the functions given by TEMPLATE_ID)
1657 which can be specialized to match the indicated DECL with the
1658 explicit template args given in TEMPLATE_ID. The DECL may be
1659 NULL_TREE if none is available. In that case, the functions in
1660 TEMPLATE_ID are non-members.
1662 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1663 specialization of a member template.
1665 The TEMPLATE_COUNT is the number of references to qualifying
1666 template classes that appeared in the name of the function. See
1667 check_explicit_specialization for a more accurate description.
1669 TSK indicates what kind of template declaration (if any) is being
1670 declared. TSK_TEMPLATE indicates that the declaration given by
1671 DECL, though a FUNCTION_DECL, has template parameters, and is
1672 therefore a template function.
1674 The template args (those explicitly specified and those deduced)
1675 are output in a newly created vector *TARGS_OUT.
1677 If it is impossible to determine the result, an error message is
1678 issued. The error_mark_node is returned to indicate failure. */
1681 determine_specialization (tree template_id,
1684 int need_member_template,
1690 tree explicit_targs;
1691 tree candidates = NULL_TREE;
1692 /* A TREE_LIST of templates of which DECL may be a specialization.
1693 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1694 corresponding TREE_PURPOSE is the set of template arguments that,
1695 when used to instantiate the template, would produce a function
1696 with the signature of DECL. */
1697 tree templates = NULL_TREE;
1699 struct cp_binding_level *b;
1701 *targs_out = NULL_TREE;
1703 if (template_id == error_mark_node || decl == error_mark_node)
1704 return error_mark_node;
1706 fns = TREE_OPERAND (template_id, 0);
1707 explicit_targs = TREE_OPERAND (template_id, 1);
1709 if (fns == error_mark_node)
1710 return error_mark_node;
1712 /* Check for baselinks. */
1713 if (BASELINK_P (fns))
1714 fns = BASELINK_FUNCTIONS (fns);
1716 if (!is_overloaded_fn (fns))
1718 error ("%qD is not a function template", fns);
1719 return error_mark_node;
1722 /* Count the number of template headers specified for this
1725 for (b = current_binding_level;
1726 b->kind == sk_template_parms;
1730 for (; fns; fns = OVL_NEXT (fns))
1732 tree fn = OVL_CURRENT (fns);
1734 if (TREE_CODE (fn) == TEMPLATE_DECL)
1736 tree decl_arg_types;
1739 /* In case of explicit specialization, we need to check if
1740 the number of template headers appearing in the specialization
1741 is correct. This is usually done in check_explicit_specialization,
1742 but the check done there cannot be exhaustive when specializing
1743 member functions. Consider the following code:
1745 template <> void A<int>::f(int);
1746 template <> template <> void A<int>::f(int);
1748 Assuming that A<int> is not itself an explicit specialization
1749 already, the first line specializes "f" which is a non-template
1750 member function, whilst the second line specializes "f" which
1751 is a template member function. So both lines are syntactically
1752 correct, and check_explicit_specialization does not reject
1755 Here, we can do better, as we are matching the specialization
1756 against the declarations. We count the number of template
1757 headers, and we check if they match TEMPLATE_COUNT + 1
1758 (TEMPLATE_COUNT is the number of qualifying template classes,
1759 plus there must be another header for the member template
1762 Notice that if header_count is zero, this is not a
1763 specialization but rather a template instantiation, so there
1764 is no check we can perform here. */
1765 if (header_count && header_count != template_count + 1)
1768 /* Check that the number of template arguments at the
1769 innermost level for DECL is the same as for FN. */
1770 if (current_binding_level->kind == sk_template_parms
1771 && !current_binding_level->explicit_spec_p
1772 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn))
1773 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
1774 (current_template_parms))))
1777 /* DECL might be a specialization of FN. */
1778 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1779 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
1781 /* For a non-static member function, we need to make sure
1782 that the const qualification is the same. Since
1783 get_bindings does not try to merge the "this" parameter,
1784 we must do the comparison explicitly. */
1785 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1786 && !same_type_p (TREE_VALUE (fn_arg_types),
1787 TREE_VALUE (decl_arg_types)))
1790 /* Skip the "this" parameter and, for constructors of
1791 classes with virtual bases, the VTT parameter. A
1792 full specialization of a constructor will have a VTT
1793 parameter, but a template never will. */
1795 = skip_artificial_parms_for (decl, decl_arg_types);
1797 = skip_artificial_parms_for (fn, fn_arg_types);
1799 /* Check that the number of function parameters matches.
1801 template <class T> void f(int i = 0);
1802 template <> void f<int>();
1803 The specialization f<int> is invalid but is not caught
1804 by get_bindings below. */
1805 if (list_length (fn_arg_types) != list_length (decl_arg_types))
1808 /* Function templates cannot be specializations; there are
1809 no partial specializations of functions. Therefore, if
1810 the type of DECL does not match FN, there is no
1812 if (tsk == tsk_template)
1814 if (compparms (fn_arg_types, decl_arg_types))
1815 candidates = tree_cons (NULL_TREE, fn, candidates);
1819 /* See whether this function might be a specialization of this
1821 targs = get_bindings (fn, decl, explicit_targs, /*check_ret=*/true);
1824 /* We cannot deduce template arguments that when used to
1825 specialize TMPL will produce DECL. */
1828 /* Save this template, and the arguments deduced. */
1829 templates = tree_cons (targs, fn, templates);
1831 else if (need_member_template)
1832 /* FN is an ordinary member function, and we need a
1833 specialization of a member template. */
1835 else if (TREE_CODE (fn) != FUNCTION_DECL)
1836 /* We can get IDENTIFIER_NODEs here in certain erroneous
1839 else if (!DECL_FUNCTION_MEMBER_P (fn))
1840 /* This is just an ordinary non-member function. Nothing can
1841 be a specialization of that. */
1843 else if (DECL_ARTIFICIAL (fn))
1844 /* Cannot specialize functions that are created implicitly. */
1848 tree decl_arg_types;
1850 /* This is an ordinary member function. However, since
1851 we're here, we can assume it's enclosing class is a
1852 template class. For example,
1854 template <typename T> struct S { void f(); };
1855 template <> void S<int>::f() {}
1857 Here, S<int>::f is a non-template, but S<int> is a
1858 template class. If FN has the same type as DECL, we
1859 might be in business. */
1861 if (!DECL_TEMPLATE_INFO (fn))
1862 /* Its enclosing class is an explicit specialization
1863 of a template class. This is not a candidate. */
1866 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
1867 TREE_TYPE (TREE_TYPE (fn))))
1868 /* The return types differ. */
1871 /* Adjust the type of DECL in case FN is a static member. */
1872 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1873 if (DECL_STATIC_FUNCTION_P (fn)
1874 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1875 decl_arg_types = TREE_CHAIN (decl_arg_types);
1877 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1880 candidates = tree_cons (NULL_TREE, fn, candidates);
1884 if (templates && TREE_CHAIN (templates))
1890 It is possible for a specialization with a given function
1891 signature to be instantiated from more than one function
1892 template. In such cases, explicit specification of the
1893 template arguments must be used to uniquely identify the
1894 function template specialization being specialized.
1896 Note that here, there's no suggestion that we're supposed to
1897 determine which of the candidate templates is most
1898 specialized. However, we, also have:
1902 Partial ordering of overloaded function template
1903 declarations is used in the following contexts to select
1904 the function template to which a function template
1905 specialization refers:
1907 -- when an explicit specialization refers to a function
1910 So, we do use the partial ordering rules, at least for now.
1911 This extension can only serve to make invalid programs valid,
1912 so it's safe. And, there is strong anecdotal evidence that
1913 the committee intended the partial ordering rules to apply;
1914 the EDG front end has that behavior, and John Spicer claims
1915 that the committee simply forgot to delete the wording in
1916 [temp.expl.spec]. */
1917 tree tmpl = most_specialized_instantiation (templates);
1918 if (tmpl != error_mark_node)
1921 TREE_CHAIN (templates) = NULL_TREE;
1925 if (templates == NULL_TREE && candidates == NULL_TREE)
1927 error ("template-id %qD for %q+D does not match any template "
1928 "declaration", template_id, decl);
1929 return error_mark_node;
1931 else if ((templates && TREE_CHAIN (templates))
1932 || (candidates && TREE_CHAIN (candidates))
1933 || (templates && candidates))
1935 error ("ambiguous template specialization %qD for %q+D",
1937 chainon (candidates, templates);
1938 print_candidates (candidates);
1939 return error_mark_node;
1942 /* We have one, and exactly one, match. */
1945 tree fn = TREE_VALUE (candidates);
1946 *targs_out = copy_node (DECL_TI_ARGS (fn));
1947 /* DECL is a re-declaration or partial instantiation of a template
1949 if (TREE_CODE (fn) == TEMPLATE_DECL)
1951 /* It was a specialization of an ordinary member function in a
1953 return DECL_TI_TEMPLATE (fn);
1956 /* It was a specialization of a template. */
1957 targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates)));
1958 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs))
1960 *targs_out = copy_node (targs);
1961 SET_TMPL_ARGS_LEVEL (*targs_out,
1962 TMPL_ARGS_DEPTH (*targs_out),
1963 TREE_PURPOSE (templates));
1966 *targs_out = TREE_PURPOSE (templates);
1967 return TREE_VALUE (templates);
1970 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
1971 but with the default argument values filled in from those in the
1975 copy_default_args_to_explicit_spec_1 (tree spec_types,
1978 tree new_spec_types;
1983 if (spec_types == void_list_node)
1984 return void_list_node;
1986 /* Substitute into the rest of the list. */
1988 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
1989 TREE_CHAIN (tmpl_types));
1991 /* Add the default argument for this parameter. */
1992 return hash_tree_cons (TREE_PURPOSE (tmpl_types),
1993 TREE_VALUE (spec_types),
1997 /* DECL is an explicit specialization. Replicate default arguments
1998 from the template it specializes. (That way, code like:
2000 template <class T> void f(T = 3);
2001 template <> void f(double);
2004 works, as required.) An alternative approach would be to look up
2005 the correct default arguments at the call-site, but this approach
2006 is consistent with how implicit instantiations are handled. */
2009 copy_default_args_to_explicit_spec (tree decl)
2014 tree new_spec_types;
2018 tree object_type = NULL_TREE;
2019 tree in_charge = NULL_TREE;
2020 tree vtt = NULL_TREE;
2022 /* See if there's anything we need to do. */
2023 tmpl = DECL_TI_TEMPLATE (decl);
2024 tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
2025 for (t = tmpl_types; t; t = TREE_CHAIN (t))
2026 if (TREE_PURPOSE (t))
2031 old_type = TREE_TYPE (decl);
2032 spec_types = TYPE_ARG_TYPES (old_type);
2034 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2036 /* Remove the this pointer, but remember the object's type for
2038 object_type = TREE_TYPE (TREE_VALUE (spec_types));
2039 spec_types = TREE_CHAIN (spec_types);
2040 tmpl_types = TREE_CHAIN (tmpl_types);
2042 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
2044 /* DECL may contain more parameters than TMPL due to the extra
2045 in-charge parameter in constructors and destructors. */
2046 in_charge = spec_types;
2047 spec_types = TREE_CHAIN (spec_types);
2049 if (DECL_HAS_VTT_PARM_P (decl))
2052 spec_types = TREE_CHAIN (spec_types);
2056 /* Compute the merged default arguments. */
2058 copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);
2060 /* Compute the new FUNCTION_TYPE. */
2064 new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt),
2069 /* Put the in-charge parameter back. */
2070 new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
2071 TREE_VALUE (in_charge),
2074 new_type = build_method_type_directly (object_type,
2075 TREE_TYPE (old_type),
2079 new_type = build_function_type (TREE_TYPE (old_type),
2081 new_type = cp_build_type_attribute_variant (new_type,
2082 TYPE_ATTRIBUTES (old_type));
2083 new_type = build_exception_variant (new_type,
2084 TYPE_RAISES_EXCEPTIONS (old_type));
2085 TREE_TYPE (decl) = new_type;
2088 /* Check to see if the function just declared, as indicated in
2089 DECLARATOR, and in DECL, is a specialization of a function
2090 template. We may also discover that the declaration is an explicit
2091 instantiation at this point.
2093 Returns DECL, or an equivalent declaration that should be used
2094 instead if all goes well. Issues an error message if something is
2095 amiss. Returns error_mark_node if the error is not easily
2098 FLAGS is a bitmask consisting of the following flags:
2100 2: The function has a definition.
2101 4: The function is a friend.
2103 The TEMPLATE_COUNT is the number of references to qualifying
2104 template classes that appeared in the name of the function. For
2107 template <class T> struct S { void f(); };
2110 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2111 classes are not counted in the TEMPLATE_COUNT, so that in
2113 template <class T> struct S {};
2114 template <> struct S<int> { void f(); }
2115 template <> void S<int>::f();
2117 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2118 invalid; there should be no template <>.)
2120 If the function is a specialization, it is marked as such via
2121 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2122 is set up correctly, and it is added to the list of specializations
2123 for that template. */
2126 check_explicit_specialization (tree declarator,
2131 int have_def = flags & 2;
2132 int is_friend = flags & 4;
2133 int specialization = 0;
2134 int explicit_instantiation = 0;
2135 int member_specialization = 0;
2136 tree ctype = DECL_CLASS_CONTEXT (decl);
2137 tree dname = DECL_NAME (decl);
2142 if (!processing_specialization)
2145 tsk = tsk_excessive_parms;
2148 tsk = current_tmpl_spec_kind (template_count);
2153 if (processing_specialization)
2156 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
2158 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
2161 /* This could be something like:
2163 template <class T> void f(T);
2164 class S { friend void f<>(int); } */
2168 /* This case handles bogus declarations like template <>
2169 template <class T> void f<int>(); */
2171 error ("template-id %qD in declaration of primary template",
2178 case tsk_invalid_member_spec:
2179 /* The error has already been reported in
2180 check_specialization_scope. */
2181 return error_mark_node;
2183 case tsk_invalid_expl_inst:
2184 error ("template parameter list used in explicit instantiation");
2190 error ("definition provided for explicit instantiation");
2192 explicit_instantiation = 1;
2195 case tsk_excessive_parms:
2196 case tsk_insufficient_parms:
2197 if (tsk == tsk_excessive_parms)
2198 error ("too many template parameter lists in declaration of %qD",
2200 else if (template_header_count)
2201 error("too few template parameter lists in declaration of %qD", decl);
2203 error("explicit specialization of %qD must be introduced by "
2204 "%<template <>%>", decl);
2208 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
2210 member_specialization = 1;
2216 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
2218 /* This case handles bogus declarations like template <>
2219 template <class T> void f<int>(); */
2221 if (uses_template_parms (declarator))
2222 error ("function template partial specialization %qD "
2223 "is not allowed", declarator);
2225 error ("template-id %qD in declaration of primary template",
2230 if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
2231 /* This is a specialization of a member template, without
2232 specialization the containing class. Something like:
2234 template <class T> struct S {
2235 template <class U> void f (U);
2237 template <> template <class U> void S<int>::f(U) {}
2239 That's a specialization -- but of the entire template. */
2247 if (specialization || member_specialization)
2249 tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
2250 for (; t; t = TREE_CHAIN (t))
2251 if (TREE_PURPOSE (t))
2253 permerror (input_location,
2254 "default argument specified in explicit specialization");
2259 if (specialization || member_specialization || explicit_instantiation)
2261 tree tmpl = NULL_TREE;
2262 tree targs = NULL_TREE;
2264 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2265 if (TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
2269 gcc_assert (TREE_CODE (declarator) == IDENTIFIER_NODE);
2274 /* If there is no class context, the explicit instantiation
2275 must be at namespace scope. */
2276 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl));
2278 /* Find the namespace binding, using the declaration
2280 fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
2282 if (fns == error_mark_node || !is_overloaded_fn (fns))
2284 error ("%qD is not a template function", dname);
2285 fns = error_mark_node;
2289 tree fn = OVL_CURRENT (fns);
2290 if (!is_associated_namespace (CP_DECL_CONTEXT (decl),
2291 CP_DECL_CONTEXT (fn)))
2292 error ("%qD is not declared in %qD",
2293 decl, current_namespace);
2297 declarator = lookup_template_function (fns, NULL_TREE);
2300 if (declarator == error_mark_node)
2301 return error_mark_node;
2303 if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
2305 if (!explicit_instantiation)
2306 /* A specialization in class scope. This is invalid,
2307 but the error will already have been flagged by
2308 check_specialization_scope. */
2309 return error_mark_node;
2312 /* It's not valid to write an explicit instantiation in
2315 class C { template void f(); }
2317 This case is caught by the parser. However, on
2320 template class C { void f(); };
2322 (which is invalid) we can get here. The error will be
2329 else if (ctype != NULL_TREE
2330 && (TREE_CODE (TREE_OPERAND (declarator, 0)) ==
2333 /* Find the list of functions in ctype that have the same
2334 name as the declared function. */
2335 tree name = TREE_OPERAND (declarator, 0);
2336 tree fns = NULL_TREE;
2339 if (constructor_name_p (name, ctype))
2341 int is_constructor = DECL_CONSTRUCTOR_P (decl);
2343 if (is_constructor ? !TYPE_HAS_USER_CONSTRUCTOR (ctype)
2344 : !CLASSTYPE_DESTRUCTORS (ctype))
2346 /* From [temp.expl.spec]:
2348 If such an explicit specialization for the member
2349 of a class template names an implicitly-declared
2350 special member function (clause _special_), the
2351 program is ill-formed.
2353 Similar language is found in [temp.explicit]. */
2354 error ("specialization of implicitly-declared special member function");
2355 return error_mark_node;
2358 name = is_constructor ? ctor_identifier : dtor_identifier;
2361 if (!DECL_CONV_FN_P (decl))
2363 idx = lookup_fnfields_1 (ctype, name);
2365 fns = VEC_index (tree, CLASSTYPE_METHOD_VEC (ctype), idx);
2369 VEC(tree,gc) *methods;
2372 /* For a type-conversion operator, we cannot do a
2373 name-based lookup. We might be looking for `operator
2374 int' which will be a specialization of `operator T'.
2375 So, we find *all* the conversion operators, and then
2376 select from them. */
2379 methods = CLASSTYPE_METHOD_VEC (ctype);
2381 for (idx = CLASSTYPE_FIRST_CONVERSION_SLOT;
2382 VEC_iterate (tree, methods, idx, ovl);
2385 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl)))
2386 /* There are no more conversion functions. */
2389 /* Glue all these conversion functions together
2390 with those we already have. */
2391 for (; ovl; ovl = OVL_NEXT (ovl))
2392 fns = ovl_cons (OVL_CURRENT (ovl), fns);
2396 if (fns == NULL_TREE)
2398 error ("no member function %qD declared in %qT", name, ctype);
2399 return error_mark_node;
2402 TREE_OPERAND (declarator, 0) = fns;
2405 /* Figure out what exactly is being specialized at this point.
2406 Note that for an explicit instantiation, even one for a
2407 member function, we cannot tell apriori whether the
2408 instantiation is for a member template, or just a member
2409 function of a template class. Even if a member template is
2410 being instantiated, the member template arguments may be
2411 elided if they can be deduced from the rest of the
2413 tmpl = determine_specialization (declarator, decl,
2415 member_specialization,
2419 if (!tmpl || tmpl == error_mark_node)
2420 /* We couldn't figure out what this declaration was
2422 return error_mark_node;
2425 tree gen_tmpl = most_general_template (tmpl);
2427 if (explicit_instantiation)
2429 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2430 is done by do_decl_instantiation later. */
2432 int arg_depth = TMPL_ARGS_DEPTH (targs);
2433 int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
2435 if (arg_depth > parm_depth)
2437 /* If TMPL is not the most general template (for
2438 example, if TMPL is a friend template that is
2439 injected into namespace scope), then there will
2440 be too many levels of TARGS. Remove some of them
2445 new_targs = make_tree_vec (parm_depth);
2446 for (i = arg_depth - parm_depth; i < arg_depth; ++i)
2447 TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
2448 = TREE_VEC_ELT (targs, i);
2452 return instantiate_template (tmpl, targs, tf_error);
2455 /* If we thought that the DECL was a member function, but it
2456 turns out to be specializing a static member function,
2457 make DECL a static member function as well. */
2458 if (DECL_STATIC_FUNCTION_P (tmpl)
2459 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2460 revert_static_member_fn (decl);
2462 /* If this is a specialization of a member template of a
2463 template class, we want to return the TEMPLATE_DECL, not
2464 the specialization of it. */
2465 if (tsk == tsk_template)
2467 tree result = DECL_TEMPLATE_RESULT (tmpl);
2468 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
2469 DECL_INITIAL (result) = NULL_TREE;
2473 DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
2474 DECL_SOURCE_LOCATION (result)
2475 = DECL_SOURCE_LOCATION (decl);
2476 /* We want to use the argument list specified in the
2477 definition, not in the original declaration. */
2478 DECL_ARGUMENTS (result) = DECL_ARGUMENTS (decl);
2479 for (parm = DECL_ARGUMENTS (result); parm;
2480 parm = TREE_CHAIN (parm))
2481 DECL_CONTEXT (parm) = result;
2483 return register_specialization (tmpl, gen_tmpl, targs,
2487 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2488 DECL_TEMPLATE_INFO (decl) = tree_cons (tmpl, targs, NULL_TREE);
2490 /* Inherit default function arguments from the template
2491 DECL is specializing. */
2492 copy_default_args_to_explicit_spec (decl);
2494 /* This specialization has the same protection as the
2495 template it specializes. */
2496 TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
2497 TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
2499 /* 7.1.1-1 [dcl.stc]
2501 A storage-class-specifier shall not be specified in an
2502 explicit specialization...
2504 The parser rejects these, so unless action is taken here,
2505 explicit function specializations will always appear with
2508 The action recommended by the C++ CWG in response to C++
2509 defect report 605 is to make the storage class and linkage
2510 of the explicit specialization match the templated function:
2512 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2514 if (tsk == tsk_expl_spec && DECL_FUNCTION_TEMPLATE_P (gen_tmpl))
2516 tree tmpl_func = DECL_TEMPLATE_RESULT (gen_tmpl);
2517 gcc_assert (TREE_CODE (tmpl_func) == FUNCTION_DECL);
2519 /* This specialization has the same linkage and visibility as
2520 the function template it specializes. */
2521 TREE_PUBLIC (decl) = TREE_PUBLIC (tmpl_func);
2522 if (! TREE_PUBLIC (decl))
2524 DECL_INTERFACE_KNOWN (decl) = 1;
2525 DECL_NOT_REALLY_EXTERN (decl) = 1;
2527 DECL_THIS_STATIC (decl) = DECL_THIS_STATIC (tmpl_func);
2528 if (DECL_VISIBILITY_SPECIFIED (tmpl_func))
2530 DECL_VISIBILITY_SPECIFIED (decl) = 1;
2531 DECL_VISIBILITY (decl) = DECL_VISIBILITY (tmpl_func);
2535 /* If DECL is a friend declaration, declared using an
2536 unqualified name, the namespace associated with DECL may
2537 have been set incorrectly. For example, in:
2539 template <typename T> void f(T);
2541 struct S { friend void f<int>(int); }
2544 we will have set the DECL_CONTEXT for the friend
2545 declaration to N, rather than to the global namespace. */
2546 if (DECL_NAMESPACE_SCOPE_P (decl))
2547 DECL_CONTEXT (decl) = DECL_CONTEXT (tmpl);
2549 if (is_friend && !have_def)
2550 /* This is not really a declaration of a specialization.
2551 It's just the name of an instantiation. But, it's not
2552 a request for an instantiation, either. */
2553 SET_DECL_IMPLICIT_INSTANTIATION (decl);
2554 else if (DECL_CONSTRUCTOR_P (decl) || DECL_DESTRUCTOR_P (decl))
2555 /* This is indeed a specialization. In case of constructors
2556 and destructors, we need in-charge and not-in-charge
2557 versions in V3 ABI. */
2558 clone_function_decl (decl, /*update_method_vec_p=*/0);
2560 /* Register this specialization so that we can find it
2562 decl = register_specialization (decl, gen_tmpl, targs, is_friend, 0);
2569 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2570 parameters. These are represented in the same format used for
2571 DECL_TEMPLATE_PARMS. */
2574 comp_template_parms (const_tree parms1, const_tree parms2)
2579 if (parms1 == parms2)
2582 for (p1 = parms1, p2 = parms2;
2583 p1 != NULL_TREE && p2 != NULL_TREE;
2584 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2))
2586 tree t1 = TREE_VALUE (p1);
2587 tree t2 = TREE_VALUE (p2);
2590 gcc_assert (TREE_CODE (t1) == TREE_VEC);
2591 gcc_assert (TREE_CODE (t2) == TREE_VEC);
2593 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
2596 for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
2598 tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
2599 tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
2601 /* If either of the template parameters are invalid, assume
2602 they match for the sake of error recovery. */
2603 if (parm1 == error_mark_node || parm2 == error_mark_node)
2606 if (TREE_CODE (parm1) != TREE_CODE (parm2))
2609 if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM
2610 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1)
2611 == TEMPLATE_TYPE_PARAMETER_PACK (parm2)))
2613 else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
2618 if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
2619 /* One set of parameters has more parameters lists than the
2626 /* Determine whether PARM is a parameter pack. */
2629 template_parameter_pack_p (const_tree parm)
2631 /* Determine if we have a non-type template parameter pack. */
2632 if (TREE_CODE (parm) == PARM_DECL)
2633 return (DECL_TEMPLATE_PARM_P (parm)
2634 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)));
2636 /* If this is a list of template parameters, we could get a
2637 TYPE_DECL or a TEMPLATE_DECL. */
2638 if (TREE_CODE (parm) == TYPE_DECL || TREE_CODE (parm) == TEMPLATE_DECL)
2639 parm = TREE_TYPE (parm);
2641 return ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
2642 || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM)
2643 && TEMPLATE_TYPE_PARAMETER_PACK (parm));
2646 /* Determine if T is a function parameter pack. */
2649 function_parameter_pack_p (const_tree t)
2651 if (t && TREE_CODE (t) == PARM_DECL)
2652 return FUNCTION_PARAMETER_PACK_P (t);
2656 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
2657 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
2660 get_function_template_decl (const_tree primary_func_tmpl_inst)
2662 if (! primary_func_tmpl_inst
2663 || TREE_CODE (primary_func_tmpl_inst) != FUNCTION_DECL
2664 || ! primary_template_instantiation_p (primary_func_tmpl_inst))
2667 return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst));
2670 /* Return true iff the function parameter PARAM_DECL was expanded
2671 from the function parameter pack PACK. */
2674 function_parameter_expanded_from_pack_p (tree param_decl, tree pack)
2676 if (DECL_ARTIFICIAL (param_decl)
2677 || !function_parameter_pack_p (pack))
2680 gcc_assert (DECL_NAME (param_decl) && DECL_NAME (pack));
2682 /* The parameter pack and its pack arguments have the same
2684 return DECL_PARM_INDEX (pack) == DECL_PARM_INDEX (param_decl);
2687 /* Determine whether ARGS describes a variadic template args list,
2688 i.e., one that is terminated by a template argument pack. */
2691 template_args_variadic_p (tree args)
2696 if (args == NULL_TREE)
2699 args = INNERMOST_TEMPLATE_ARGS (args);
2700 nargs = TREE_VEC_LENGTH (args);
2705 last_parm = TREE_VEC_ELT (args, nargs - 1);
2707 return ARGUMENT_PACK_P (last_parm);
2710 /* Generate a new name for the parameter pack name NAME (an
2711 IDENTIFIER_NODE) that incorporates its */
2714 make_ith_pack_parameter_name (tree name, int i)
2716 /* Munge the name to include the parameter index. */
2717 #define NUMBUF_LEN 128
2718 char numbuf[NUMBUF_LEN];
2722 snprintf (numbuf, NUMBUF_LEN, "%i", i);
2723 newname_len = IDENTIFIER_LENGTH (name)
2724 + strlen (numbuf) + 2;
2725 newname = (char*)alloca (newname_len);
2726 snprintf (newname, newname_len,
2727 "%s#%i", IDENTIFIER_POINTER (name), i);
2728 return get_identifier (newname);
2731 /* Return true if T is a primary function
2732 or class template instantiation. */
2735 primary_template_instantiation_p (const_tree t)
2740 if (TREE_CODE (t) == FUNCTION_DECL)
2741 return DECL_LANG_SPECIFIC (t)
2742 && DECL_TEMPLATE_INSTANTIATION (t)
2743 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t));
2744 else if (CLASS_TYPE_P (t))
2745 return CLASSTYPE_TEMPLATE_INSTANTIATION (t)
2746 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t));
2750 /* Return true if PARM is a template template parameter. */
2753 template_template_parameter_p (const_tree parm)
2755 return DECL_TEMPLATE_TEMPLATE_PARM_P (parm);
2758 /* Return the template parameters of T if T is a
2759 primary template instantiation, NULL otherwise. */
2762 get_primary_template_innermost_parameters (const_tree t)
2764 tree parms = NULL, template_info = NULL;
2766 if ((template_info = get_template_info (t))
2767 && primary_template_instantiation_p (t))
2768 parms = INNERMOST_TEMPLATE_PARMS
2769 (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info)));
2774 /* Returns the template arguments of T if T is a template instantiation,
2778 get_template_innermost_arguments (const_tree t)
2780 tree args = NULL, template_info = NULL;
2782 if ((template_info = get_template_info (t))
2783 && TI_ARGS (template_info))
2784 args = INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info));
2789 /* Return the argument pack elements of T if T is a template argument pack,
2793 get_template_argument_pack_elems (const_tree t)
2795 if (TREE_CODE (t) != TYPE_ARGUMENT_PACK
2796 && TREE_CODE (t) != NONTYPE_ARGUMENT_PACK)
2799 return ARGUMENT_PACK_ARGS (t);
2802 /* Structure used to track the progress of find_parameter_packs_r. */
2803 struct find_parameter_pack_data
2805 /* TREE_LIST that will contain all of the parameter packs found by
2807 tree* parameter_packs;
2809 /* Set of AST nodes that have been visited by the traversal. */
2810 struct pointer_set_t *visited;
2813 /* Identifies all of the argument packs that occur in a template
2814 argument and appends them to the TREE_LIST inside DATA, which is a
2815 find_parameter_pack_data structure. This is a subroutine of
2816 make_pack_expansion and uses_parameter_packs. */
2818 find_parameter_packs_r (tree *tp, int *walk_subtrees, void* data)
2821 struct find_parameter_pack_data* ppd =
2822 (struct find_parameter_pack_data*)data;
2823 bool parameter_pack_p = false;
2825 /* Identify whether this is a parameter pack or not. */
2826 switch (TREE_CODE (t))
2828 case TEMPLATE_PARM_INDEX:
2829 if (TEMPLATE_PARM_PARAMETER_PACK (t))
2830 parameter_pack_p = true;
2833 case TEMPLATE_TYPE_PARM:
2834 case TEMPLATE_TEMPLATE_PARM:
2835 if (TEMPLATE_TYPE_PARAMETER_PACK (t))
2836 parameter_pack_p = true;
2840 if (FUNCTION_PARAMETER_PACK_P (t))
2842 /* We don't want to walk into the type of a PARM_DECL,
2843 because we don't want to see the type parameter pack. */
2845 parameter_pack_p = true;
2850 /* Not a parameter pack. */
2854 if (parameter_pack_p)
2856 /* Add this parameter pack to the list. */
2857 *ppd->parameter_packs = tree_cons (NULL_TREE, t, *ppd->parameter_packs);
2861 cp_walk_tree (&TYPE_CONTEXT (t),
2862 &find_parameter_packs_r, ppd, ppd->visited);
2864 /* This switch statement will return immediately if we don't find a
2866 switch (TREE_CODE (t))
2868 case TEMPLATE_PARM_INDEX:
2871 case BOUND_TEMPLATE_TEMPLATE_PARM:
2872 /* Check the template itself. */
2873 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t)),
2874 &find_parameter_packs_r, ppd, ppd->visited);
2875 /* Check the template arguments. */
2876 cp_walk_tree (&TYPE_TI_ARGS (t), &find_parameter_packs_r, ppd,
2881 case TEMPLATE_TYPE_PARM:
2882 case TEMPLATE_TEMPLATE_PARM:
2889 if (TYPE_PTRMEMFUNC_P (t))
2895 if (TYPE_TEMPLATE_INFO (t))
2896 cp_walk_tree (&TREE_VALUE (TYPE_TEMPLATE_INFO (t)),
2897 &find_parameter_packs_r, ppd, ppd->visited);
2903 cp_walk_tree (&TREE_TYPE (t),
2904 &find_parameter_packs_r, ppd, ppd->visited);
2908 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t), &find_parameter_packs_r,
2913 case TYPE_PACK_EXPANSION:
2914 case EXPR_PACK_EXPANSION:
2919 cp_walk_tree (&TYPE_MAX_VALUE (t), &find_parameter_packs_r,
2924 case IDENTIFIER_NODE:
2925 cp_walk_tree (&TREE_TYPE (t), &find_parameter_packs_r, ppd,
2937 /* Determines if the expression or type T uses any parameter packs. */
2939 uses_parameter_packs (tree t)
2941 tree parameter_packs = NULL_TREE;
2942 struct find_parameter_pack_data ppd;
2943 ppd.parameter_packs = ¶meter_packs;
2944 ppd.visited = pointer_set_create ();
2945 cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
2946 pointer_set_destroy (ppd.visited);
2947 return parameter_packs != NULL_TREE;
2950 /* Turn ARG, which may be an expression, type, or a TREE_LIST
2951 representation a base-class initializer into a parameter pack
2952 expansion. If all goes well, the resulting node will be an
2953 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
2956 make_pack_expansion (tree arg)
2959 tree parameter_packs = NULL_TREE;
2960 bool for_types = false;
2961 struct find_parameter_pack_data ppd;
2963 if (!arg || arg == error_mark_node)
2966 if (TREE_CODE (arg) == TREE_LIST)
2968 /* The only time we will see a TREE_LIST here is for a base
2969 class initializer. In this case, the TREE_PURPOSE will be a
2970 _TYPE node (representing the base class expansion we're
2971 initializing) and the TREE_VALUE will be a TREE_LIST
2972 containing the initialization arguments.
2974 The resulting expansion looks somewhat different from most
2975 expansions. Rather than returning just one _EXPANSION, we
2976 return a TREE_LIST whose TREE_PURPOSE is a
2977 TYPE_PACK_EXPANSION containing the bases that will be
2978 initialized. The TREE_VALUE will be identical to the
2979 original TREE_VALUE, which is a list of arguments that will
2980 be passed to each base. We do not introduce any new pack
2981 expansion nodes into the TREE_VALUE (although it is possible
2982 that some already exist), because the TREE_PURPOSE and
2983 TREE_VALUE all need to be expanded together with the same
2984 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
2985 resulting TREE_PURPOSE will mention the parameter packs in
2986 both the bases and the arguments to the bases. */
2989 tree parameter_packs = NULL_TREE;
2991 /* Determine which parameter packs will be used by the base
2993 ppd.visited = pointer_set_create ();
2994 ppd.parameter_packs = ¶meter_packs;
2995 cp_walk_tree (&TREE_PURPOSE (arg), &find_parameter_packs_r,
2998 if (parameter_packs == NULL_TREE)
3000 error ("base initializer expansion %<%T%> contains no parameter packs", arg);
3001 pointer_set_destroy (ppd.visited);
3002 return error_mark_node;
3005 if (TREE_VALUE (arg) != void_type_node)
3007 /* Collect the sets of parameter packs used in each of the
3008 initialization arguments. */
3009 for (value = TREE_VALUE (arg); value; value = TREE_CHAIN (value))
3011 /* Determine which parameter packs will be expanded in this
3013 cp_walk_tree (&TREE_VALUE (value), &find_parameter_packs_r,
3018 pointer_set_destroy (ppd.visited);
3020 /* Create the pack expansion type for the base type. */
3021 purpose = cxx_make_type (TYPE_PACK_EXPANSION);
3022 SET_PACK_EXPANSION_PATTERN (purpose, TREE_PURPOSE (arg));
3023 PACK_EXPANSION_PARAMETER_PACKS (purpose) = parameter_packs;
3025 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3026 they will rarely be compared to anything. */
3027 SET_TYPE_STRUCTURAL_EQUALITY (purpose);
3029 return tree_cons (purpose, TREE_VALUE (arg), NULL_TREE);
3032 if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
3035 /* Build the PACK_EXPANSION_* node. */
3037 ? cxx_make_type (TYPE_PACK_EXPANSION)
3038 : make_node (EXPR_PACK_EXPANSION);
3039 SET_PACK_EXPANSION_PATTERN (result, arg);
3040 if (TREE_CODE (result) == EXPR_PACK_EXPANSION)
3042 /* Propagate type and const-expression information. */
3043 TREE_TYPE (result) = TREE_TYPE (arg);
3044 TREE_CONSTANT (result) = TREE_CONSTANT (arg);
3047 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3048 they will rarely be compared to anything. */
3049 SET_TYPE_STRUCTURAL_EQUALITY (result);
3051 /* Determine which parameter packs will be expanded. */
3052 ppd.parameter_packs = ¶meter_packs;
3053 ppd.visited = pointer_set_create ();
3054 cp_walk_tree (&arg, &find_parameter_packs_r, &ppd, ppd.visited);
3055 pointer_set_destroy (ppd.visited);
3057 /* Make sure we found some parameter packs. */
3058 if (parameter_packs == NULL_TREE)
3061 error ("expansion pattern %<%T%> contains no argument packs", arg);
3063 error ("expansion pattern %<%E%> contains no argument packs", arg);
3064 return error_mark_node;
3066 PACK_EXPANSION_PARAMETER_PACKS (result) = parameter_packs;
3071 /* Checks T for any "bare" parameter packs, which have not yet been
3072 expanded, and issues an error if any are found. This operation can
3073 only be done on full expressions or types (e.g., an expression
3074 statement, "if" condition, etc.), because we could have expressions like:
3076 foo(f(g(h(args)))...)
3078 where "args" is a parameter pack. check_for_bare_parameter_packs
3079 should not be called for the subexpressions args, h(args),
3080 g(h(args)), or f(g(h(args))), because we would produce erroneous
3083 Returns TRUE and emits an error if there were bare parameter packs,
3084 returns FALSE otherwise. */
3086 check_for_bare_parameter_packs (tree t)
3088 tree parameter_packs = NULL_TREE;
3089 struct find_parameter_pack_data ppd;
3091 if (!processing_template_decl || !t || t == error_mark_node)
3094 if (TREE_CODE (t) == TYPE_DECL)
3097 ppd.parameter_packs = ¶meter_packs;
3098 ppd.visited = pointer_set_create ();
3099 cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
3100 pointer_set_destroy (ppd.visited);
3102 if (parameter_packs)
3104 error ("parameter packs not expanded with %<...%>:");
3105 while (parameter_packs)
3107 tree pack = TREE_VALUE (parameter_packs);
3108 tree name = NULL_TREE;
3110 if (TREE_CODE (pack) == TEMPLATE_TYPE_PARM
3111 || TREE_CODE (pack) == TEMPLATE_TEMPLATE_PARM)
3112 name = TYPE_NAME (pack);
3113 else if (TREE_CODE (pack) == TEMPLATE_PARM_INDEX)
3114 name = DECL_NAME (TEMPLATE_PARM_DECL (pack));
3116 name = DECL_NAME (pack);
3119 inform (input_location, " %qD", name);
3121 inform (input_location, " <anonymous>");
3123 parameter_packs = TREE_CHAIN (parameter_packs);
3132 /* Expand any parameter packs that occur in the template arguments in
3135 expand_template_argument_pack (tree args)
3137 tree result_args = NULL_TREE;
3138 int in_arg, out_arg = 0, nargs = args ? TREE_VEC_LENGTH (args) : 0;
3139 int num_result_args = -1;
3141 /* First, determine if we need to expand anything, and the number of
3142 slots we'll need. */
3143 for (in_arg = 0; in_arg < nargs; ++in_arg)
3145 tree arg = TREE_VEC_ELT (args, in_arg);
3146 if (ARGUMENT_PACK_P (arg))
3148 int num_packed = TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg));
3149 if (num_result_args < 0)
3150 num_result_args = in_arg + num_packed;
3152 num_result_args += num_packed;
3156 if (num_result_args >= 0)
3161 /* If no expansion is necessary, we're done. */
3162 if (num_result_args < 0)
3165 /* Expand arguments. */
3166 result_args = make_tree_vec (num_result_args);
3167 for (in_arg = 0; in_arg < nargs; ++in_arg)
3169 tree arg = TREE_VEC_ELT (args, in_arg);
3170 if (ARGUMENT_PACK_P (arg))
3172 tree packed = ARGUMENT_PACK_ARGS (arg);
3173 int i, num_packed = TREE_VEC_LENGTH (packed);
3174 for (i = 0; i < num_packed; ++i, ++out_arg)
3175 TREE_VEC_ELT (result_args, out_arg) = TREE_VEC_ELT(packed, i);
3179 TREE_VEC_ELT (result_args, out_arg) = arg;
3187 /* Checks if DECL shadows a template parameter.
3189 [temp.local]: A template-parameter shall not be redeclared within its
3190 scope (including nested scopes).
3192 Emits an error and returns TRUE if the DECL shadows a parameter,
3193 returns FALSE otherwise. */
3196 check_template_shadow (tree decl)
3200 /* If we're not in a template, we can't possibly shadow a template
3202 if (!current_template_parms)
3205 /* Figure out what we're shadowing. */
3206 if (TREE_CODE (decl) == OVERLOAD)
3207 decl = OVL_CURRENT (decl);
3208 olddecl = innermost_non_namespace_value (DECL_NAME (decl));
3210 /* If there's no previous binding for this name, we're not shadowing
3211 anything, let alone a template parameter. */
3215 /* If we're not shadowing a template parameter, we're done. Note
3216 that OLDDECL might be an OVERLOAD (or perhaps even an
3217 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3219 if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
3222 /* We check for decl != olddecl to avoid bogus errors for using a
3223 name inside a class. We check TPFI to avoid duplicate errors for
3224 inline member templates. */
3226 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms))
3229 error ("declaration of %q+#D", decl);
3230 error (" shadows template parm %q+#D", olddecl);
3234 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3235 ORIG_LEVEL, DECL, and TYPE. */
3238 build_template_parm_index (int index,
3244 tree t = make_node (TEMPLATE_PARM_INDEX);
3245 TEMPLATE_PARM_IDX (t) = index;
3246 TEMPLATE_PARM_LEVEL (t) = level;
3247 TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
3248 TEMPLATE_PARM_DECL (t) = decl;
3249 TREE_TYPE (t) = type;
3250 TREE_CONSTANT (t) = TREE_CONSTANT (decl);
3251 TREE_READONLY (t) = TREE_READONLY (decl);
3256 /* Find the canonical type parameter for the given template type
3257 parameter. Returns the canonical type parameter, which may be TYPE
3258 if no such parameter existed. */
3260 canonical_type_parameter (tree type)
3263 int idx = TEMPLATE_TYPE_IDX (type);
3264 if (!canonical_template_parms)
3265 canonical_template_parms = VEC_alloc (tree, gc, idx+1);
3267 while (VEC_length (tree, canonical_template_parms) <= (unsigned)idx)
3268 VEC_safe_push (tree, gc, canonical_template_parms, NULL_TREE);
3270 list = VEC_index (tree, canonical_template_parms, idx);
3271 while (list && !comptypes (type, TREE_VALUE (list), COMPARE_STRUCTURAL))
3272 list = TREE_CHAIN (list);
3275 return TREE_VALUE (list);
3278 VEC_replace(tree, canonical_template_parms, idx,
3279 tree_cons (NULL_TREE, type,
3280 VEC_index (tree, canonical_template_parms, idx)));
3285 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3286 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3287 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3288 new one is created. */
3291 reduce_template_parm_level (tree index, tree type, int levels, tree args,
3292 tsubst_flags_t complain)
3294 if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
3295 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
3296 != TEMPLATE_PARM_LEVEL (index) - levels))
3298 tree orig_decl = TEMPLATE_PARM_DECL (index);
3301 decl = build_decl (DECL_SOURCE_LOCATION (orig_decl),
3302 TREE_CODE (orig_decl), DECL_NAME (orig_decl), type);
3303 TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl);
3304 TREE_READONLY (decl) = TREE_READONLY (orig_decl);
3305 DECL_ARTIFICIAL (decl) = 1;
3306 SET_DECL_TEMPLATE_PARM_P (decl);
3308 t = build_template_parm_index (TEMPLATE_PARM_IDX (index),
3309 TEMPLATE_PARM_LEVEL (index) - levels,
3310 TEMPLATE_PARM_ORIG_LEVEL (index),
3312 TEMPLATE_PARM_DESCENDANTS (index) = t;
3313 TEMPLATE_PARM_PARAMETER_PACK (t)
3314 = TEMPLATE_PARM_PARAMETER_PACK (index);
3316 /* Template template parameters need this. */
3317 if (TREE_CODE (decl) == TEMPLATE_DECL)
3318 DECL_TEMPLATE_PARMS (decl) = tsubst_template_parms
3319 (DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index)),
3323 return TEMPLATE_PARM_DESCENDANTS (index);
3326 /* Process information from new template parameter PARM and append it to the
3327 LIST being built. This new parameter is a non-type parameter iff
3328 IS_NON_TYPE is true. This new parameter is a parameter
3329 pack iff IS_PARAMETER_PACK is true. The location of PARM is in
3333 process_template_parm (tree list, location_t parm_loc, tree parm, bool is_non_type,
3334 bool is_parameter_pack)
3341 gcc_assert (TREE_CODE (parm) == TREE_LIST);
3342 defval = TREE_PURPOSE (parm);
3346 tree p = tree_last (list);
3348 if (p && TREE_VALUE (p) != error_mark_node)
3351 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
3352 idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
3354 idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
3364 parm = TREE_VALUE (parm);
3366 SET_DECL_TEMPLATE_PARM_P (parm);
3368 if (TREE_TYPE (parm) == error_mark_node)
3370 err_parm_list = build_tree_list (defval, parm);
3371 TREE_VALUE (err_parm_list) = error_mark_node;
3372 return chainon (list, err_parm_list);
3378 The top-level cv-qualifiers on the template-parameter are
3379 ignored when determining its type. */
3380 TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
3381 if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
3383 err_parm_list = build_tree_list (defval, parm);
3384 TREE_VALUE (err_parm_list) = error_mark_node;
3385 return chainon (list, err_parm_list);
3388 if (uses_parameter_packs (TREE_TYPE (parm)) && !is_parameter_pack)
3390 /* This template parameter is not a parameter pack, but it
3391 should be. Complain about "bare" parameter packs. */
3392 check_for_bare_parameter_packs (TREE_TYPE (parm));
3394 /* Recover by calling this a parameter pack. */
3395 is_parameter_pack = true;
3399 /* A template parameter is not modifiable. */
3400 TREE_CONSTANT (parm) = 1;
3401 TREE_READONLY (parm) = 1;
3402 decl = build_decl (parm_loc,
3403 CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
3404 TREE_CONSTANT (decl) = 1;
3405 TREE_READONLY (decl) = 1;
3406 DECL_INITIAL (parm) = DECL_INITIAL (decl)
3407 = build_template_parm_index (idx, processing_template_decl,
3408 processing_template_decl,
3409 decl, TREE_TYPE (parm));
3411 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm))
3412 = is_parameter_pack;
3417 parm = TREE_VALUE (TREE_VALUE (parm));
3419 if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
3421 t = cxx_make_type (TEMPLATE_TEMPLATE_PARM);
3422 /* This is for distinguishing between real templates and template
3423 template parameters */
3424 TREE_TYPE (parm) = t;
3425 TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t;
3430 t = cxx_make_type (TEMPLATE_TYPE_PARM);
3431 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3432 decl = build_decl (parm_loc,
3433 TYPE_DECL, parm, t);
3436 TYPE_NAME (t) = decl;
3437 TYPE_STUB_DECL (t) = decl;
3439 TEMPLATE_TYPE_PARM_INDEX (t)
3440 = build_template_parm_index (idx, processing_template_decl,
3441 processing_template_decl,
3442 decl, TREE_TYPE (parm));
3443 TEMPLATE_TYPE_PARAMETER_PACK (t) = is_parameter_pack;
3444 TYPE_CANONICAL (t) = canonical_type_parameter (t);
3446 DECL_ARTIFICIAL (decl) = 1;
3447 SET_DECL_TEMPLATE_PARM_P (decl);
3449 parm = build_tree_list (defval, parm);
3450 return chainon (list, parm);
3453 /* The end of a template parameter list has been reached. Process the
3454 tree list into a parameter vector, converting each parameter into a more
3455 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3459 end_template_parm_list (tree parms)
3463 tree saved_parmlist = make_tree_vec (list_length (parms));
3465 current_template_parms
3466 = tree_cons (size_int (processing_template_decl),
3467 saved_parmlist, current_template_parms);
3469 for (parm = parms, nparms = 0; parm; parm = next, nparms++)
3471 next = TREE_CHAIN (parm);
3472 TREE_VEC_ELT (saved_parmlist, nparms) = parm;
3473 TREE_CHAIN (parm) = NULL_TREE;
3476 --processing_template_parmlist;
3478 return saved_parmlist;
3481 /* end_template_decl is called after a template declaration is seen. */
3484 end_template_decl (void)
3486 reset_specialization ();
3488 if (! processing_template_decl)
3491 /* This matches the pushlevel in begin_template_parm_list. */
3494 --processing_template_decl;
3495 current_template_parms = TREE_CHAIN (current_template_parms);
3498 /* Within the declaration of a template, return all levels of template
3499 parameters that apply. The template parameters are represented as
3500 a TREE_VEC, in the form documented in cp-tree.h for template
3504 current_template_args (void)
3507 tree args = NULL_TREE;
3508 int length = TMPL_PARMS_DEPTH (current_template_parms);
3511 /* If there is only one level of template parameters, we do not
3512 create a TREE_VEC of TREE_VECs. Instead, we return a single
3513 TREE_VEC containing the arguments. */
3515 args = make_tree_vec (length);
3517 for (header = current_template_parms; header; header = TREE_CHAIN (header))
3519 tree a = copy_node (TREE_VALUE (header));
3522 TREE_TYPE (a) = NULL_TREE;
3523 for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
3525 tree t = TREE_VEC_ELT (a, i);
3527 /* T will be a list if we are called from within a
3528 begin/end_template_parm_list pair, but a vector directly
3529 if within a begin/end_member_template_processing pair. */
3530 if (TREE_CODE (t) == TREE_LIST)
3534 if (!error_operand_p (t))
3536 if (TREE_CODE (t) == TYPE_DECL
3537 || TREE_CODE (t) == TEMPLATE_DECL)
3541 if (TEMPLATE_TYPE_PARAMETER_PACK (t))
3543 /* Turn this argument into a TYPE_ARGUMENT_PACK
3544 with a single element, which expands T. */
3545 tree vec = make_tree_vec (1);
3546 TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
3548 t = cxx_make_type (TYPE_ARGUMENT_PACK);
3549 SET_ARGUMENT_PACK_ARGS (t, vec);
3554 t = DECL_INITIAL (t);
3556 if (TEMPLATE_PARM_PARAMETER_PACK (t))
3558 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3559 with a single element, which expands T. */
3560 tree vec = make_tree_vec (1);
3561 tree type = TREE_TYPE (TEMPLATE_PARM_DECL (t));
3562 TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
3564 t = make_node (NONTYPE_ARGUMENT_PACK);
3565 SET_ARGUMENT_PACK_ARGS (t, vec);
3566 TREE_TYPE (t) = type;
3569 TREE_VEC_ELT (a, i) = t;
3575 TREE_VEC_ELT (args, --l) = a;
3583 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
3584 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
3585 a member template. Used by push_template_decl below. */
3588 build_template_decl (tree decl, tree parms, bool member_template_p)
3590 tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
3591 DECL_TEMPLATE_PARMS (tmpl) = parms;
3592 DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
3593 DECL_MEMBER_TEMPLATE_P (tmpl) = member_template_p;
3598 struct template_parm_data
3600 /* The level of the template parameters we are currently
3604 /* The index of the specialization argument we are currently
3608 /* An array whose size is the number of template parameters. The
3609 elements are nonzero if the parameter has been used in any one
3610 of the arguments processed so far. */
3613 /* An array whose size is the number of template arguments. The
3614 elements are nonzero if the argument makes use of template
3615 parameters of this level. */
3616 int* arg_uses_template_parms;
3619 /* Subroutine of push_template_decl used to see if each template
3620 parameter in a partial specialization is used in the explicit
3621 argument list. If T is of the LEVEL given in DATA (which is
3622 treated as a template_parm_data*), then DATA->PARMS is marked
3626 mark_template_parm (tree t, void* data)
3630 struct template_parm_data* tpd = (struct template_parm_data*) data;
3632 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
3634 level = TEMPLATE_PARM_LEVEL (t);
3635 idx = TEMPLATE_PARM_IDX (t);
3639 level = TEMPLATE_TYPE_LEVEL (t);
3640 idx = TEMPLATE_TYPE_IDX (t);
3643 if (level == tpd->level)
3645 tpd->parms[idx] = 1;
3646 tpd->arg_uses_template_parms[tpd->current_arg] = 1;
3649 /* Return zero so that for_each_template_parm will continue the
3650 traversal of the tree; we want to mark *every* template parm. */
3654 /* Process the partial specialization DECL. */
3657 process_partial_specialization (tree decl)
3659 tree type = TREE_TYPE (decl);
3660 tree maintmpl = CLASSTYPE_TI_TEMPLATE (type);
3661 tree specargs = CLASSTYPE_TI_ARGS (type);
3662 tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
3663 tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
3665 int nargs = TREE_VEC_LENGTH (inner_args);
3668 int did_error_intro = 0;
3669 struct template_parm_data tpd;
3670 struct template_parm_data tpd2;
3672 gcc_assert (current_template_parms);
3674 inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
3675 ntparms = TREE_VEC_LENGTH (inner_parms);
3677 /* We check that each of the template parameters given in the
3678 partial specialization is used in the argument list to the
3679 specialization. For example:
3681 template <class T> struct S;
3682 template <class T> struct S<T*>;
3684 The second declaration is OK because `T*' uses the template
3685 parameter T, whereas
3687 template <class T> struct S<int>;
3689 is no good. Even trickier is:
3700 The S2<T> declaration is actually invalid; it is a
3701 full-specialization. Of course,
3704 struct S2<T (*)(U)>;
3706 or some such would have been OK. */
3707 tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
3708 tpd.parms = (int *) alloca (sizeof (int) * ntparms);
3709 memset (tpd.parms, 0, sizeof (int) * ntparms);
3711 tpd.arg_uses_template_parms = (int *) alloca (sizeof (int) * nargs);
3712 memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
3713 for (i = 0; i < nargs; ++i)
3715 tpd.current_arg = i;
3716 for_each_template_parm (TREE_VEC_ELT (inner_args, i),
3717 &mark_template_parm,
3720 /*include_nondeduced_p=*/false);
3722 for (i = 0; i < ntparms; ++i)
3723 if (tpd.parms[i] == 0)
3725 /* One of the template parms was not used in the
3727 if (!did_error_intro)
3729 error ("template parameters not used in partial specialization:");
3730 did_error_intro = 1;
3733 error (" %qD", TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
3736 /* [temp.class.spec]
3738 The argument list of the specialization shall not be identical to
3739 the implicit argument list of the primary template. */
3740 if (comp_template_args
3742 INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE
3744 error ("partial specialization %qT does not specialize any template arguments", type);
3746 /* [temp.class.spec]
3748 A partially specialized non-type argument expression shall not
3749 involve template parameters of the partial specialization except
3750 when the argument expression is a simple identifier.
3752 The type of a template parameter corresponding to a specialized
3753 non-type argument shall not be dependent on a parameter of the
3756 Also, we verify that pack expansions only occur at the
3757 end of the argument list. */
3758 gcc_assert (nargs == DECL_NTPARMS (maintmpl));
3760 for (i = 0; i < nargs; ++i)
3762 tree parm = TREE_VALUE (TREE_VEC_ELT (main_inner_parms, i));
3763 tree arg = TREE_VEC_ELT (inner_args, i);
3764 tree packed_args = NULL_TREE;
3767 if (ARGUMENT_PACK_P (arg))
3769 /* Extract the arguments from the argument pack. We'll be
3770 iterating over these in the following loop. */
3771 packed_args = ARGUMENT_PACK_ARGS (arg);
3772 len = TREE_VEC_LENGTH (packed_args);
3775 for (j = 0; j < len; j++)
3778 /* Get the Jth argument in the parameter pack. */
3779 arg = TREE_VEC_ELT (packed_args, j);
3781 if (PACK_EXPANSION_P (arg))
3783 /* Pack expansions must come at the end of the
3785 if ((packed_args && j < len - 1)
3786 || (!packed_args && i < nargs - 1))
3788 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
3789 error ("parameter pack argument %qE must be at the end of the template argument list", arg);
3791 error ("parameter pack argument %qT must be at the end of the template argument list", arg);
3794 TREE_VEC_ELT (packed_args, j) = error_mark_node;
3798 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
3799 /* We only care about the pattern. */
3800 arg = PACK_EXPANSION_PATTERN (arg);
3802 if (/* These first two lines are the `non-type' bit. */
3804 && TREE_CODE (arg) != TEMPLATE_DECL
3805 /* This next line is the `argument expression is not just a
3806 simple identifier' condition and also the `specialized
3807 non-type argument' bit. */
3808 && TREE_CODE (arg) != TEMPLATE_PARM_INDEX)
3810 if ((!packed_args && tpd.arg_uses_template_parms[i])
3811 || (packed_args && uses_template_parms (arg)))
3812 error ("template argument %qE involves template parameter(s)",
3816 /* Look at the corresponding template parameter,
3817 marking which template parameters its type depends
3819 tree type = TREE_TYPE (parm);
3823 /* We haven't yet initialized TPD2. Do so now. */
3824 tpd2.arg_uses_template_parms
3825 = (int *) alloca (sizeof (int) * nargs);
3826 /* The number of parameters here is the number in the
3827 main template, which, as checked in the assertion
3829 tpd2.parms = (int *) alloca (sizeof (int) * nargs);
3831 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
3834 /* Mark the template parameters. But this time, we're
3835 looking for the template parameters of the main
3836 template, not in the specialization. */
3837 tpd2.current_arg = i;
3838 tpd2.arg_uses_template_parms[i] = 0;
3839 memset (tpd2.parms, 0, sizeof (int) * nargs);
3840 for_each_template_parm (type,
3841 &mark_template_parm,
3844 /*include_nondeduced_p=*/false);
3846 if (tpd2.arg_uses_template_parms [i])
3848 /* The type depended on some template parameters.
3849 If they are fully specialized in the
3850 specialization, that's OK. */
3852 for (j = 0; j < nargs; ++j)
3853 if (tpd2.parms[j] != 0
3854 && tpd.arg_uses_template_parms [j])
3856 error ("type %qT of template argument %qE depends "
3857 "on template parameter(s)",
3868 /* We should only get here once. */
3869 gcc_assert (!COMPLETE_TYPE_P (type));
3871 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
3872 = tree_cons (specargs, inner_parms,
3873 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
3874 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
3878 /* Check that a template declaration's use of default arguments and
3879 parameter packs is not invalid. Here, PARMS are the template
3880 parameters. IS_PRIMARY is nonzero if DECL is the thing declared by
3881 a primary template. IS_PARTIAL is nonzero if DECL is a partial
3885 IS_FRIEND_DECL is nonzero if DECL is a friend function template
3886 declaration (but not a definition); 1 indicates a declaration, 2
3887 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
3888 emitted for extraneous default arguments.
3890 Returns TRUE if there were no errors found, FALSE otherwise. */
3893 check_default_tmpl_args (tree decl, tree parms, int is_primary,
3894 int is_partial, int is_friend_decl)
3897 int last_level_to_check;
3899 bool no_errors = true;
3903 A default template-argument shall not be specified in a
3904 function template declaration or a function template definition, nor
3905 in the template-parameter-list of the definition of a member of a
3908 if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
3909 /* You can't have a function template declaration in a local
3910 scope, nor you can you define a member of a class template in a
3914 if (current_class_type
3915 && !TYPE_BEING_DEFINED (current_class_type)
3916 && DECL_LANG_SPECIFIC (decl)
3917 && DECL_DECLARES_FUNCTION_P (decl)
3918 /* If this is either a friend defined in the scope of the class
3919 or a member function. */
3920 && (DECL_FUNCTION_MEMBER_P (decl)
3921 ? same_type_p (DECL_CONTEXT (decl), current_class_type)
3922 : DECL_FRIEND_CONTEXT (decl)
3923 ? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type)
3925 /* And, if it was a member function, it really was defined in
3926 the scope of the class. */
3927 && (!DECL_FUNCTION_MEMBER_P (decl)
3928 || DECL_INITIALIZED_IN_CLASS_P (decl)))
3929 /* We already checked these parameters when the template was
3930 declared, so there's no need to do it again now. This function
3931 was defined in class scope, but we're processing it's body now
3932 that the class is complete. */
3935 /* Core issue 226 (C++0x only): the following only applies to class
3937 if ((cxx_dialect == cxx98) || TREE_CODE (decl) != FUNCTION_DECL)
3941 If a template-parameter has a default template-argument, all
3942 subsequent template-parameters shall have a default
3943 template-argument supplied. */
3944 for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
3946 tree inner_parms = TREE_VALUE (parm_level);
3947 int ntparms = TREE_VEC_LENGTH (inner_parms);
3948 int seen_def_arg_p = 0;
3951 for (i = 0; i < ntparms; ++i)
3953 tree parm = TREE_VEC_ELT (inner_parms, i);
3955 if (parm == error_mark_node)
3958 if (TREE_PURPOSE (parm))
3960 else if (seen_def_arg_p
3961 && !template_parameter_pack_p (TREE_VALUE (parm)))
3963 error ("no default argument for %qD", TREE_VALUE (parm));
3964 /* For better subsequent error-recovery, we indicate that
3965 there should have been a default argument. */
3966 TREE_PURPOSE (parm) = error_mark_node;
3972 /* Don't complain about an enclosing partial
3974 && parm_level == parms
3975 && TREE_CODE (decl) == TYPE_DECL
3977 && template_parameter_pack_p (TREE_VALUE (parm)))
3979 /* A primary class template can only have one
3980 parameter pack, at the end of the template
3983 if (TREE_CODE (TREE_VALUE (parm)) == PARM_DECL)
3984 error ("parameter pack %qE must be at the end of the"
3985 " template parameter list", TREE_VALUE (parm));
3987 error ("parameter pack %qT must be at the end of the"
3988 " template parameter list",
3989 TREE_TYPE (TREE_VALUE (parm)));
3991 TREE_VALUE (TREE_VEC_ELT (inner_parms, i))
3999 if (((cxx_dialect == cxx98) && TREE_CODE (decl) != TYPE_DECL)
4003 /* For an ordinary class template, default template arguments are
4004 allowed at the innermost level, e.g.:
4005 template <class T = int>
4007 but, in a partial specialization, they're not allowed even
4008 there, as we have in [temp.class.spec]:
4010 The template parameter list of a specialization shall not
4011 contain default template argument values.
4013 So, for a partial specialization, or for a function template
4014 (in C++98/C++03), we look at all of them. */
4017 /* But, for a primary class template that is not a partial
4018 specialization we look at all template parameters except the
4020 parms = TREE_CHAIN (parms);
4022 /* Figure out what error message to issue. */
4023 if (is_friend_decl == 2)
4024 msg = "default template arguments may not be used in function template friend re-declaration";
4025 else if (is_friend_decl)
4026 msg = "default template arguments may not be used in function template friend declarations";
4027 else if (TREE_CODE (decl) == FUNCTION_DECL && (cxx_dialect == cxx98))
4028 msg = "default template arguments may not be used in function templates";
4029 else if (is_partial)
4030 msg = "default template arguments may not be used in partial specializations";
4032 msg = "default argument for template parameter for class enclosing %qD";
4034 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
4035 /* If we're inside a class definition, there's no need to
4036 examine the parameters to the class itself. On the one
4037 hand, they will be checked when the class is defined, and,
4038 on the other, default arguments are valid in things like:
4039 template <class T = double>
4040 struct S { template <class U> void f(U); };
4041 Here the default argument for `S' has no bearing on the
4042 declaration of `f'. */
4043 last_level_to_check = template_class_depth (current_class_type) + 1;
4045 /* Check everything. */
4046 last_level_to_check = 0;
4048 for (parm_level = parms;
4049 parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
4050 parm_level = TREE_CHAIN (parm_level))
4052 tree inner_parms = TREE_VALUE (parm_level);
4056 ntparms = TREE_VEC_LENGTH (inner_parms);
4057 for (i = 0; i < ntparms; ++i)
4059 if (TREE_VEC_ELT (inner_parms, i) == error_mark_node)
4062 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
4067 if (is_friend_decl == 2)
4074 /* Clear out the default argument so that we are not
4076 TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
4080 /* At this point, if we're still interested in issuing messages,
4081 they must apply to classes surrounding the object declared. */
4083 msg = "default argument for template parameter for class enclosing %qD";
4089 /* Worker for push_template_decl_real, called via
4090 for_each_template_parm. DATA is really an int, indicating the
4091 level of the parameters we are interested in. If T is a template
4092 parameter of that level, return nonzero. */
4095 template_parm_this_level_p (tree t, void* data)
4097 int this_level = *(int *)data;
4100 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
4101 level = TEMPLATE_PARM_LEVEL (t);
4103 level = TEMPLATE_TYPE_LEVEL (t);
4104 return level == this_level;
4107 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
4108 parameters given by current_template_args, or reuses a
4109 previously existing one, if appropriate. Returns the DECL, or an
4110 equivalent one, if it is replaced via a call to duplicate_decls.
4112 If IS_FRIEND is true, DECL is a friend declaration. */
4115 push_template_decl_real (tree decl, bool is_friend)
4123 int new_template_p = 0;
4124 /* True if the template is a member template, in the sense of
4126 bool member_template_p = false;
4128 if (decl == error_mark_node || !current_template_parms)
4129 return error_mark_node;
4131 /* See if this is a partial specialization. */
4132 is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl)
4133 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
4134 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)));
4136 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl))
4140 /* For a friend, we want the context of the friend function, not
4141 the type of which it is a friend. */
4142 ctx = DECL_CONTEXT (decl);
4143 else if (CP_DECL_CONTEXT (decl)
4144 && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4145 /* In the case of a virtual function, we want the class in which
4147 ctx = CP_DECL_CONTEXT (decl);
4149 /* Otherwise, if we're currently defining some class, the DECL
4150 is assumed to be a member of the class. */
4151 ctx = current_scope ();
4153 if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
4156 if (!DECL_CONTEXT (decl))
4157 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
4159 /* See if this is a primary template. */
4160 if (is_friend && ctx)
4161 /* A friend template that specifies a class context, i.e.
4162 template <typename T> friend void A<T>::f();
4166 primary = template_parm_scope_p ();
4170 if (DECL_CLASS_SCOPE_P (decl))
4171 member_template_p = true;
4172 if (TREE_CODE (decl) == TYPE_DECL
4173 && ANON_AGGRNAME_P (DECL_NAME (decl)))
4175 error ("template class without a name");
4176 return error_mark_node;
4178 else if (TREE_CODE (decl) == FUNCTION_DECL)
4180 if (DECL_DESTRUCTOR_P (decl))
4184 A destructor shall not be a member template. */
4185 error ("destructor %qD declared as member template", decl);
4186 return error_mark_node;
4188 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl))
4189 && (!TYPE_ARG_TYPES (TREE_TYPE (decl))
4190 || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
4191 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
4192 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl))))
4193 == void_list_node)))
4195 /* [basic.stc.dynamic.allocation]
4197 An allocation function can be a function
4198 template. ... Template allocation functions shall
4199 have two or more parameters. */
4200 error ("invalid template declaration of %qD", decl);
4201 return error_mark_node;
4204 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
4205 && CLASS_TYPE_P (TREE_TYPE (decl)))
4209 error ("template declaration of %q#D", decl);
4210 return error_mark_node;
4214 /* Check to see that the rules regarding the use of default
4215 arguments are not being violated. */
4216 check_default_tmpl_args (decl, current_template_parms,
4217 primary, is_partial, /*is_friend_decl=*/0);
4219 /* Ensure that there are no parameter packs in the type of this
4220 declaration that have not been expanded. */
4221 if (TREE_CODE (decl) == FUNCTION_DECL)
4223 /* Check each of the arguments individually to see if there are
4224 any bare parameter packs. */
4225 tree type = TREE_TYPE (decl);
4226 tree arg = DECL_ARGUMENTS (decl);
4227 tree argtype = TYPE_ARG_TYPES (type);
4229 while (arg && argtype)
4231 if (!FUNCTION_PARAMETER_PACK_P (arg)
4232 && check_for_bare_parameter_packs (TREE_TYPE (arg)))
4234 /* This is a PARM_DECL that contains unexpanded parameter
4235 packs. We have already complained about this in the
4236 check_for_bare_parameter_packs call, so just replace
4237 these types with ERROR_MARK_NODE. */
4238 TREE_TYPE (arg) = error_mark_node;
4239 TREE_VALUE (argtype) = error_mark_node;
4242 arg = TREE_CHAIN (arg);
4243 argtype = TREE_CHAIN (argtype);
4246 /* Check for bare parameter packs in the return type and the
4247 exception specifiers. */
4248 if (check_for_bare_parameter_packs (TREE_TYPE (type)))
4249 /* Errors were already issued, set return type to int
4250 as the frontend doesn't expect error_mark_node as
4252 TREE_TYPE (type) = integer_type_node;
4253 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type)))
4254 TYPE_RAISES_EXCEPTIONS (type) = NULL_TREE;
4256 else if (check_for_bare_parameter_packs (TREE_TYPE (decl)))
4258 TREE_TYPE (decl) = error_mark_node;
4259 return error_mark_node;
4263 return process_partial_specialization (decl);
4265 args = current_template_args ();
4268 || TREE_CODE (ctx) == FUNCTION_DECL
4269 || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
4270 || (is_friend && !DECL_TEMPLATE_INFO (decl)))
4272 if (DECL_LANG_SPECIFIC (decl)
4273 && DECL_TEMPLATE_INFO (decl)
4274 && DECL_TI_TEMPLATE (decl))
4275 tmpl = DECL_TI_TEMPLATE (decl);
4276 /* If DECL is a TYPE_DECL for a class-template, then there won't
4277 be DECL_LANG_SPECIFIC. The information equivalent to
4278 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
4279 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
4280 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
4281 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
4283 /* Since a template declaration already existed for this
4284 class-type, we must be redeclaring it here. Make sure
4285 that the redeclaration is valid. */
4286 redeclare_class_template (TREE_TYPE (decl),
4287 current_template_parms);
4288 /* We don't need to create a new TEMPLATE_DECL; just use the
4289 one we already had. */
4290 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
4294 tmpl = build_template_decl (decl, current_template_parms,
4298 if (DECL_LANG_SPECIFIC (decl)
4299 && DECL_TEMPLATE_SPECIALIZATION (decl))
4301 /* A specialization of a member template of a template
4303 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
4304 DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
4305 DECL_TEMPLATE_INFO (decl) = NULL_TREE;
4311 tree a, t, current, parms;
4313 tree tinfo = get_template_info (decl);
4317 error ("template definition of non-template %q#D", decl);
4318 return error_mark_node;
4321 tmpl = TI_TEMPLATE (tinfo);
4323 if (DECL_FUNCTION_TEMPLATE_P (tmpl)
4324 && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
4325 && DECL_TEMPLATE_SPECIALIZATION (decl)
4326 && DECL_MEMBER_TEMPLATE_P (tmpl))
4330 /* The declaration is a specialization of a member
4331 template, declared outside the class. Therefore, the
4332 innermost template arguments will be NULL, so we
4333 replace them with the arguments determined by the
4334 earlier call to check_explicit_specialization. */
4335 args = DECL_TI_ARGS (decl);
4338 = build_template_decl (decl, current_template_parms,
4340 DECL_TEMPLATE_RESULT (new_tmpl) = decl;
4341 TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
4342 DECL_TI_TEMPLATE (decl) = new_tmpl;
4343 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
4344 DECL_TEMPLATE_INFO (new_tmpl)
4345 = tree_cons (tmpl, args, NULL_TREE);
4347 register_specialization (new_tmpl,
4348 most_general_template (tmpl),
4354 /* Make sure the template headers we got make sense. */
4356 parms = DECL_TEMPLATE_PARMS (tmpl);
4357 i = TMPL_PARMS_DEPTH (parms);
4358 if (TMPL_ARGS_DEPTH (args) != i)
4360 error ("expected %d levels of template parms for %q#D, got %d",
4361 i, decl, TMPL_ARGS_DEPTH (args));
4364 for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
4366 a = TMPL_ARGS_LEVEL (args, i);
4367 t = INNERMOST_TEMPLATE_PARMS (parms);
4369 if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
4371 if (current == decl)
4372 error ("got %d template parameters for %q#D",
4373 TREE_VEC_LENGTH (a), decl);
4375 error ("got %d template parameters for %q#T",
4376 TREE_VEC_LENGTH (a), current);
4377 error (" but %d required", TREE_VEC_LENGTH (t));
4378 return error_mark_node;
4381 if (current == decl)
4384 current = (TYPE_P (current)
4385 ? TYPE_CONTEXT (current)
4386 : DECL_CONTEXT (current));
4389 /* Check that the parms are used in the appropriate qualifying scopes
4390 in the declarator. */
4391 if (!comp_template_args
4393 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl)))))
4396 template arguments to %qD do not match original template %qD",
4397 decl, DECL_TEMPLATE_RESULT (tmpl));
4398 if (!uses_template_parms (TI_ARGS (tinfo)))
4399 inform (input_location, "use template<> for an explicit specialization");
4400 /* Avoid crash in import_export_decl. */
4401 DECL_INTERFACE_KNOWN (decl) = 1;
4402 return error_mark_node;
4406 DECL_TEMPLATE_RESULT (tmpl) = decl;
4407 TREE_TYPE (tmpl) = TREE_TYPE (decl);
4409 /* Push template declarations for global functions and types. Note
4410 that we do not try to push a global template friend declared in a
4411 template class; such a thing may well depend on the template
4412 parameters of the class. */
4413 if (new_template_p && !ctx
4414 && !(is_friend && template_class_depth (current_class_type) > 0))
4416 tmpl = pushdecl_namespace_level (tmpl, is_friend);
4417 if (tmpl == error_mark_node)
4418 return error_mark_node;
4420 /* Hide template friend classes that haven't been declared yet. */
4421 if (is_friend && TREE_CODE (decl) == TYPE_DECL)
4423 DECL_ANTICIPATED (tmpl) = 1;
4424 DECL_FRIEND_P (tmpl) = 1;
4430 tree parms = DECL_TEMPLATE_PARMS (tmpl);
4433 DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
4434 if (DECL_CONV_FN_P (tmpl))
4436 int depth = TMPL_PARMS_DEPTH (parms);
4438 /* It is a conversion operator. See if the type converted to
4439 depends on innermost template operands. */
4441 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl)),
4443 DECL_TEMPLATE_CONV_FN_P (tmpl) = 1;
4446 /* Give template template parms a DECL_CONTEXT of the template
4447 for which they are a parameter. */
4448 parms = INNERMOST_TEMPLATE_PARMS (parms);
4449 for (i = TREE_VEC_LENGTH (parms) - 1; i >= 0; --i)
4451 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
4452 if (TREE_CODE (parm) == TEMPLATE_DECL)
4453 DECL_CONTEXT (parm) = tmpl;
4457 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
4458 back to its most general template. If TMPL is a specialization,
4459 ARGS may only have the innermost set of arguments. Add the missing
4460 argument levels if necessary. */
4461 if (DECL_TEMPLATE_INFO (tmpl))
4462 args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);
4464 info = tree_cons (tmpl, args, NULL_TREE);
4466 if (DECL_IMPLICIT_TYPEDEF_P (decl))
4467 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
4468 else if (DECL_LANG_SPECIFIC (decl))
4469 DECL_TEMPLATE_INFO (decl) = info;
4471 return DECL_TEMPLATE_RESULT (tmpl);
4475 push_template_decl (tree decl)
4477 return push_template_decl_real (decl, false);
4480 /* Called when a class template TYPE is redeclared with the indicated
4481 template PARMS, e.g.:
4483 template <class T> struct S;
4484 template <class T> struct S {}; */
4487 redeclare_class_template (tree type, tree parms)
4493 if (!TYPE_TEMPLATE_INFO (type))
4495 error ("%qT is not a template type", type);
4499 tmpl = TYPE_TI_TEMPLATE (type);
4500 if (!PRIMARY_TEMPLATE_P (tmpl))
4501 /* The type is nested in some template class. Nothing to worry
4502 about here; there are no new template parameters for the nested
4508 error ("template specifiers not specified in declaration of %qD",
4513 parms = INNERMOST_TEMPLATE_PARMS (parms);
4514 tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
4516 if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
4518 error ("redeclared with %d template parameter(s)",
4519 TREE_VEC_LENGTH (parms));
4520 inform (input_location, "previous declaration %q+D used %d template parameter(s)",
4521 tmpl, TREE_VEC_LENGTH (tmpl_parms));
4525 for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
4532 if (TREE_VEC_ELT (tmpl_parms, i) == error_mark_node
4533 || TREE_VEC_ELT (parms, i) == error_mark_node)
4536 tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
4537 parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
4538 tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i));
4539 parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
4541 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
4543 if (tmpl_parm != error_mark_node
4544 && (TREE_CODE (tmpl_parm) != TREE_CODE (parm)
4545 || (TREE_CODE (tmpl_parm) != TYPE_DECL
4546 && !same_type_p (TREE_TYPE (tmpl_parm), TREE_TYPE (parm)))
4547 || (TREE_CODE (tmpl_parm) != PARM_DECL
4548 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm))
4549 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm))))
4550 || (TREE_CODE (tmpl_parm) == PARM_DECL
4551 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm))
4552 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm))))))
4554 error ("template parameter %q+#D", tmpl_parm);
4555 error ("redeclared here as %q#D", parm);
4559 if (tmpl_default != NULL_TREE && parm_default != NULL_TREE)
4561 /* We have in [temp.param]:
4563 A template-parameter may not be given default arguments
4564 by two different declarations in the same scope. */
4565 error_at (input_location, "redefinition of default argument for %q#D", parm);
4566 inform (DECL_SOURCE_LOCATION (tmpl_parm),
4567 "original definition appeared here");
4571 if (parm_default != NULL_TREE)
4572 /* Update the previous template parameters (which are the ones
4573 that will really count) with the new default value. */
4574 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default;
4575 else if (tmpl_default != NULL_TREE)
4576 /* Update the new parameters, too; they'll be used as the
4577 parameters for any members. */
4578 TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default;
4584 /* Simplify EXPR if it is a non-dependent expression. Returns the
4585 (possibly simplified) expression. */
4588 fold_non_dependent_expr (tree expr)
4590 if (expr == NULL_TREE)
4593 /* If we're in a template, but EXPR isn't value dependent, simplify
4594 it. We're supposed to treat:
4596 template <typename T> void f(T[1 + 1]);
4597 template <typename T> void f(T[2]);
4599 as two declarations of the same function, for example. */
4600 if (processing_template_decl
4601 && !type_dependent_expression_p (expr)
4602 && !value_dependent_expression_p (expr))
4604 HOST_WIDE_INT saved_processing_template_decl;
4606 saved_processing_template_decl = processing_template_decl;
4607 processing_template_decl = 0;
4608 expr = tsubst_copy_and_build (expr,
4611 /*in_decl=*/NULL_TREE,
4612 /*function_p=*/false,
4613 /*integral_constant_expression_p=*/true);
4614 processing_template_decl = saved_processing_template_decl;
4619 /* EXPR is an expression which is used in a constant-expression context.
4620 For instance, it could be a VAR_DECL with a constant initializer.
4621 Extract the innermost constant expression.
4623 This is basically a more powerful version of
4624 integral_constant_value, which can be used also in templates where
4625 initializers can maintain a syntactic rather than semantic form
4626 (even if they are non-dependent, for access-checking purposes). */
4629 fold_decl_constant_value (tree expr)
4631 tree const_expr = expr;
4634 expr = fold_non_dependent_expr (const_expr);
4635 const_expr = integral_constant_value (expr);
4637 while (expr != const_expr);
4642 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
4643 must be a function or a pointer-to-function type, as specified
4644 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
4645 and check that the resulting function has external linkage. */
4648 convert_nontype_argument_function (tree type, tree expr)
4653 fn = instantiate_type (type, fns, tf_none);
4654 if (fn == error_mark_node)
4655 return error_mark_node;
4658 if (TREE_CODE (fn_no_ptr) == ADDR_EXPR)
4659 fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0);
4660 if (TREE_CODE (fn_no_ptr) == BASELINK)
4661 fn_no_ptr = BASELINK_FUNCTIONS (fn_no_ptr);
4663 /* [temp.arg.nontype]/1
4665 A template-argument for a non-type, non-template template-parameter
4668 -- the address of an object or function with external linkage. */
4669 if (!DECL_EXTERNAL_LINKAGE_P (fn_no_ptr))
4671 error ("%qE is not a valid template argument for type %qT "
4672 "because function %qD has not external linkage",
4673 expr, type, fn_no_ptr);
4680 /* Attempt to convert the non-type template parameter EXPR to the
4681 indicated TYPE. If the conversion is successful, return the
4682 converted value. If the conversion is unsuccessful, return
4683 NULL_TREE if we issued an error message, or error_mark_node if we
4684 did not. We issue error messages for out-and-out bad template
4685 parameters, but not simply because the conversion failed, since we
4686 might be just trying to do argument deduction. Both TYPE and EXPR
4687 must be non-dependent.
4689 The conversion follows the special rules described in
4690 [temp.arg.nontype], and it is much more strict than an implicit
4693 This function is called twice for each template argument (see
4694 lookup_template_class for a more accurate description of this
4695 problem). This means that we need to handle expressions which
4696 are not valid in a C++ source, but can be created from the
4697 first call (for instance, casts to perform conversions). These
4698 hacks can go away after we fix the double coercion problem. */
4701 convert_nontype_argument (tree type, tree expr)
4705 /* Detect immediately string literals as invalid non-type argument.
4706 This special-case is not needed for correctness (we would easily
4707 catch this later), but only to provide better diagnostic for this
4708 common user mistake. As suggested by DR 100, we do not mention
4709 linkage issues in the diagnostic as this is not the point. */
4710 if (TREE_CODE (expr) == STRING_CST)
4712 error ("%qE is not a valid template argument for type %qT "
4713 "because string literals can never be used in this context",
4718 /* If we are in a template, EXPR may be non-dependent, but still
4719 have a syntactic, rather than semantic, form. For example, EXPR
4720 might be a SCOPE_REF, rather than the VAR_DECL to which the
4721 SCOPE_REF refers. Preserving the qualifying scope is necessary
4722 so that access checking can be performed when the template is
4723 instantiated -- but here we need the resolved form so that we can
4724 convert the argument. */
4725 expr = fold_non_dependent_expr (expr);
4726 if (error_operand_p (expr))
4727 return error_mark_node;
4728 expr_type = TREE_TYPE (expr);
4730 /* HACK: Due to double coercion, we can get a
4731 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
4732 which is the tree that we built on the first call (see
4733 below when coercing to reference to object or to reference to
4734 function). We just strip everything and get to the arg.
4735 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
4737 if (TREE_CODE (expr) == NOP_EXPR)
4739 if (TYPE_REF_OBJ_P (type) || TYPE_REFFN_P (type))
4741 /* ??? Maybe we could use convert_from_reference here, but we
4742 would need to relax its constraints because the NOP_EXPR
4743 could actually change the type to something more cv-qualified,
4744 and this is not folded by convert_from_reference. */
4745 tree addr = TREE_OPERAND (expr, 0);
4746 gcc_assert (TREE_CODE (expr_type) == REFERENCE_TYPE);
4747 gcc_assert (TREE_CODE (addr) == ADDR_EXPR);
4748 gcc_assert (TREE_CODE (TREE_TYPE (addr)) == POINTER_TYPE);
4749 gcc_assert (same_type_ignoring_top_level_qualifiers_p
4750 (TREE_TYPE (expr_type),
4751 TREE_TYPE (TREE_TYPE (addr))));
4753 expr = TREE_OPERAND (addr, 0);
4754 expr_type = TREE_TYPE (expr);
4757 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
4758 parameter is a pointer to object, through decay and
4759 qualification conversion. Let's strip everything. */
4760 else if (TYPE_PTROBV_P (type))
4763 gcc_assert (TREE_CODE (expr) == ADDR_EXPR);
4764 gcc_assert (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE);
4765 /* Skip the ADDR_EXPR only if it is part of the decay for
4766 an array. Otherwise, it is part of the original argument
4767 in the source code. */
4768 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == ARRAY_TYPE)
4769 expr = TREE_OPERAND (expr, 0);
4770 expr_type = TREE_TYPE (expr);
4774 /* [temp.arg.nontype]/5, bullet 1
4776 For a non-type template-parameter of integral or enumeration type,
4777 integral promotions (_conv.prom_) and integral conversions
4778 (_conv.integral_) are applied. */
4779 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type))
4781 if (!INTEGRAL_OR_ENUMERATION_TYPE_P (expr_type))
4782 return error_mark_node;
4784 expr = fold_decl_constant_value (expr);
4785 /* Notice that there are constant expressions like '4 % 0' which
4786 do not fold into integer constants. */
4787 if (TREE_CODE (expr) != INTEGER_CST)
4789 error ("%qE is not a valid template argument for type %qT "
4790 "because it is a non-constant expression", expr, type);
4794 /* At this point, an implicit conversion does what we want,
4795 because we already know that the expression is of integral
4797 expr = ocp_convert (type, expr, CONV_IMPLICIT, LOOKUP_PROTECT);
4798 if (expr == error_mark_node)
4799 return error_mark_node;
4801 /* Conversion was allowed: fold it to a bare integer constant. */
4804 /* [temp.arg.nontype]/5, bullet 2
4806 For a non-type template-parameter of type pointer to object,
4807 qualification conversions (_conv.qual_) and the array-to-pointer
4808 conversion (_conv.array_) are applied. */
4809 else if (TYPE_PTROBV_P (type))
4811 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
4813 A template-argument for a non-type, non-template template-parameter
4814 shall be one of: [...]
4816 -- the name of a non-type template-parameter;
4817 -- the address of an object or function with external linkage, [...]
4818 expressed as "& id-expression" where the & is optional if the name
4819 refers to a function or array, or if the corresponding
4820 template-parameter is a reference.
4822 Here, we do not care about functions, as they are invalid anyway
4823 for a parameter of type pointer-to-object. */
4825 if (DECL_P (expr) && DECL_TEMPLATE_PARM_P (expr))
4826 /* Non-type template parameters are OK. */
4828 else if (TREE_CODE (expr) != ADDR_EXPR
4829 && TREE_CODE (expr_type) != ARRAY_TYPE)
4831 if (TREE_CODE (expr) == VAR_DECL)
4833 error ("%qD is not a valid template argument "
4834 "because %qD is a variable, not the address of "
4839 /* Other values, like integer constants, might be valid
4840 non-type arguments of some other type. */
4841 return error_mark_node;
4847 decl = ((TREE_CODE (expr) == ADDR_EXPR)
4848 ? TREE_OPERAND (expr, 0) : expr);
4849 if (TREE_CODE (decl) != VAR_DECL)
4851 error ("%qE is not a valid template argument of type %qT "
4852 "because %qE is not a variable",
4856 else if (!DECL_EXTERNAL_LINKAGE_P (decl))
4858 error ("%qE is not a valid template argument of type %qT "
4859 "because %qD does not have external linkage",
4865 expr = decay_conversion (expr);
4866 if (expr == error_mark_node)
4867 return error_mark_node;
4869 expr = perform_qualification_conversions (type, expr);
4870 if (expr == error_mark_node)
4871 return error_mark_node;
4873 /* [temp.arg.nontype]/5, bullet 3
4875 For a non-type template-parameter of type reference to object, no
4876 conversions apply. The type referred to by the reference may be more
4877 cv-qualified than the (otherwise identical) type of the
4878 template-argument. The template-parameter is bound directly to the
4879 template-argument, which must be an lvalue. */
4880 else if (TYPE_REF_OBJ_P (type))
4882 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type),
4884 return error_mark_node;
4886 if (!at_least_as_qualified_p (TREE_TYPE (type), expr_type))
4888 error ("%qE is not a valid template argument for type %qT "
4889 "because of conflicts in cv-qualification", expr, type);
4893 if (!real_lvalue_p (expr))
4895 error ("%qE is not a valid template argument for type %qT "
4896 "because it is not an lvalue", expr, type);
4900 /* [temp.arg.nontype]/1
4902 A template-argument for a non-type, non-template template-parameter
4903 shall be one of: [...]
4905 -- the address of an object or function with external linkage. */
4906 if (!DECL_EXTERNAL_LINKAGE_P (expr))
4908 error ("%qE is not a valid template argument for type %qT "
4909 "because object %qD has not external linkage",
4914 expr = build_nop (type, build_address (expr));
4916 /* [temp.arg.nontype]/5, bullet 4
4918 For a non-type template-parameter of type pointer to function, only
4919 the function-to-pointer conversion (_conv.func_) is applied. If the
4920 template-argument represents a set of overloaded functions (or a
4921 pointer to such), the matching function is selected from the set
4923 else if (TYPE_PTRFN_P (type))
4925 /* If the argument is a template-id, we might not have enough
4926 context information to decay the pointer. */
4927 if (!type_unknown_p (expr_type))
4929 expr = decay_conversion (expr);
4930 if (expr == error_mark_node)
4931 return error_mark_node;
4934 expr = convert_nontype_argument_function (type, expr);
4935 if (!expr || expr == error_mark_node)
4938 if (TREE_CODE (expr) != ADDR_EXPR)
4940 error ("%qE is not a valid template argument for type %qT", expr, type);
4941 error ("it must be the address of a function with external linkage");
4945 /* [temp.arg.nontype]/5, bullet 5
4947 For a non-type template-parameter of type reference to function, no
4948 conversions apply. If the template-argument represents a set of
4949 overloaded functions, the matching function is selected from the set
4951 else if (TYPE_REFFN_P (type))
4953 if (TREE_CODE (expr) == ADDR_EXPR)
4955 error ("%qE is not a valid template argument for type %qT "
4956 "because it is a pointer", expr, type);
4957 inform (input_location, "try using %qE instead", TREE_OPERAND (expr, 0));
4961 expr = convert_nontype_argument_function (TREE_TYPE (type), expr);
4962 if (!expr || expr == error_mark_node)
4965 expr = build_nop (type, build_address (expr));
4967 /* [temp.arg.nontype]/5, bullet 6
4969 For a non-type template-parameter of type pointer to member function,
4970 no conversions apply. If the template-argument represents a set of
4971 overloaded member functions, the matching member function is selected
4972 from the set (_over.over_). */
4973 else if (TYPE_PTRMEMFUNC_P (type))
4975 expr = instantiate_type (type, expr, tf_none);
4976 if (expr == error_mark_node)
4977 return error_mark_node;
4979 /* There is no way to disable standard conversions in
4980 resolve_address_of_overloaded_function (called by
4981 instantiate_type). It is possible that the call succeeded by
4982 converting &B::I to &D::I (where B is a base of D), so we need
4983 to reject this conversion here.
4985 Actually, even if there was a way to disable standard conversions,
4986 it would still be better to reject them here so that we can
4987 provide a superior diagnostic. */
4988 if (!same_type_p (TREE_TYPE (expr), type))
4990 /* Make sure we are just one standard conversion off. */
4991 gcc_assert (can_convert (type, TREE_TYPE (expr)));
4992 error ("%qE is not a valid template argument for type %qT "
4993 "because it is of type %qT", expr, type,
4995 inform (input_location, "standard conversions are not allowed in this context");
4999 /* [temp.arg.nontype]/5, bullet 7
5001 For a non-type template-parameter of type pointer to data member,
5002 qualification conversions (_conv.qual_) are applied. */
5003 else if (TYPE_PTRMEM_P (type))
5005 expr = perform_qualification_conversions (type, expr);
5006 if (expr == error_mark_node)
5009 /* A template non-type parameter must be one of the above. */
5013 /* Sanity check: did we actually convert the argument to the
5015 gcc_assert (same_type_p (type, TREE_TYPE (expr)));
5019 /* Subroutine of coerce_template_template_parms, which returns 1 if
5020 PARM_PARM and ARG_PARM match using the rule for the template
5021 parameters of template template parameters. Both PARM and ARG are
5022 template parameters; the rest of the arguments are the same as for
5023 coerce_template_template_parms.
5026 coerce_template_template_parm (tree parm,
5028 tsubst_flags_t complain,
5032 if (arg == NULL_TREE || arg == error_mark_node
5033 || parm == NULL_TREE || parm == error_mark_node)
5036 if (TREE_CODE (arg) != TREE_CODE (parm))
5039 switch (TREE_CODE (parm))
5042 /* We encounter instantiations of templates like
5043 template <template <template <class> class> class TT>
5046 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
5047 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
5049 if (!coerce_template_template_parms
5050 (parmparm, argparm, complain, in_decl, outer_args))
5056 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg))
5057 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm)))
5058 /* Argument is a parameter pack but parameter is not. */
5063 /* The tsubst call is used to handle cases such as
5065 template <int> class C {};
5066 template <class T, template <T> class TT> class D {};
5069 i.e. the parameter list of TT depends on earlier parameters. */
5070 if (!uses_template_parms (TREE_TYPE (arg))
5072 (tsubst (TREE_TYPE (parm), outer_args, complain, in_decl),
5076 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg))
5077 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))
5078 /* Argument is a parameter pack but parameter is not. */
5091 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
5092 template template parameters. Both PARM_PARMS and ARG_PARMS are
5093 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
5096 Consider the example:
5097 template <class T> class A;
5098 template<template <class U> class TT> class B;
5100 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
5101 the parameters to A, and OUTER_ARGS contains A. */
5104 coerce_template_template_parms (tree parm_parms,
5106 tsubst_flags_t complain,
5110 int nparms, nargs, i;
5114 gcc_assert (TREE_CODE (parm_parms) == TREE_VEC);
5115 gcc_assert (TREE_CODE (arg_parms) == TREE_VEC);
5117 nparms = TREE_VEC_LENGTH (parm_parms);
5118 nargs = TREE_VEC_LENGTH (arg_parms);
5120 /* Determine whether we have a parameter pack at the end of the
5121 template template parameter's template parameter list. */
5122 if (TREE_VEC_ELT (parm_parms, nparms - 1) != error_mark_node)
5124 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, nparms - 1));
5126 if (parm == error_mark_node)
5129 switch (TREE_CODE (parm))
5133 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm)))
5138 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))
5148 && !(variadic_p && nargs >= nparms - 1))
5151 /* Check all of the template parameters except the parameter pack at
5152 the end (if any). */
5153 for (i = 0; i < nparms - variadic_p; ++i)
5155 if (TREE_VEC_ELT (parm_parms, i) == error_mark_node
5156 || TREE_VEC_ELT (arg_parms, i) == error_mark_node)
5159 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
5160 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
5162 if (!coerce_template_template_parm (parm, arg, complain, in_decl,
5170 /* Check each of the template parameters in the template
5171 argument against the template parameter pack at the end of
5172 the template template parameter. */
5173 if (TREE_VEC_ELT (parm_parms, i) == error_mark_node)
5176 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
5178 for (; i < nargs; ++i)
5180 if (TREE_VEC_ELT (arg_parms, i) == error_mark_node)
5183 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
5185 if (!coerce_template_template_parm (parm, arg, complain, in_decl,
5194 /* Verifies that the deduced template arguments (in TARGS) for the
5195 template template parameters (in TPARMS) represent valid bindings,
5196 by comparing the template parameter list of each template argument
5197 to the template parameter list of its corresponding template
5198 template parameter, in accordance with DR150. This
5199 routine can only be called after all template arguments have been
5200 deduced. It will return TRUE if all of the template template
5201 parameter bindings are okay, FALSE otherwise. */
5203 template_template_parm_bindings_ok_p (tree tparms, tree targs)
5205 int i, ntparms = TREE_VEC_LENGTH (tparms);
5208 /* We're dealing with template parms in this process. */
5209 ++processing_template_decl;
5211 targs = INNERMOST_TEMPLATE_ARGS (targs);
5213 for (i = 0; i < ntparms; ++i)
5215 tree tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
5216 tree targ = TREE_VEC_ELT (targs, i);
5218 if (TREE_CODE (tparm) == TEMPLATE_DECL && targ)
5220 tree packed_args = NULL_TREE;
5223 if (ARGUMENT_PACK_P (targ))
5225 /* Look inside the argument pack. */
5226 packed_args = ARGUMENT_PACK_ARGS (targ);
5227 len = TREE_VEC_LENGTH (packed_args);
5230 for (idx = 0; idx < len; ++idx)
5232 tree targ_parms = NULL_TREE;
5235 /* Extract the next argument from the argument
5237 targ = TREE_VEC_ELT (packed_args, idx);
5239 if (PACK_EXPANSION_P (targ))
5240 /* Look at the pattern of the pack expansion. */
5241 targ = PACK_EXPANSION_PATTERN (targ);
5243 /* Extract the template parameters from the template
5245 if (TREE_CODE (targ) == TEMPLATE_DECL)
5246 targ_parms = DECL_INNERMOST_TEMPLATE_PARMS (targ);
5247 else if (TREE_CODE (targ) == TEMPLATE_TEMPLATE_PARM)
5248 targ_parms = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ));
5250 /* Verify that we can coerce the template template
5251 parameters from the template argument to the template
5252 parameter. This requires an exact match. */
5254 && !coerce_template_template_parms
5255 (DECL_INNERMOST_TEMPLATE_PARMS (tparm),
5270 --processing_template_decl;
5274 /* Convert the indicated template ARG as necessary to match the
5275 indicated template PARM. Returns the converted ARG, or
5276 error_mark_node if the conversion was unsuccessful. Error and
5277 warning messages are issued under control of COMPLAIN. This
5278 conversion is for the Ith parameter in the parameter list. ARGS is
5279 the full set of template arguments deduced so far. */
5282 convert_template_argument (tree parm,
5285 tsubst_flags_t complain,
5291 int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
5293 if (TREE_CODE (arg) == TREE_LIST
5294 && TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF)
5296 /* The template argument was the name of some
5297 member function. That's usually
5298 invalid, but static members are OK. In any
5299 case, grab the underlying fields/functions
5300 and issue an error later if required. */
5301 orig_arg = TREE_VALUE (arg);
5302 TREE_TYPE (arg) = unknown_type_node;
5307 requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
5308 requires_type = (TREE_CODE (parm) == TYPE_DECL
5309 || requires_tmpl_type);
5311 /* When determining whether an argument pack expansion is a template,
5312 look at the pattern. */
5313 if (TREE_CODE (arg) == TYPE_PACK_EXPANSION)
5314 arg = PACK_EXPANSION_PATTERN (arg);
5317 ((TREE_CODE (arg) == TEMPLATE_DECL
5318 && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
5319 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
5320 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
5323 && (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
5324 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE))
5325 arg = TYPE_STUB_DECL (arg);
5327 is_type = TYPE_P (arg) || is_tmpl_type;
5329 if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
5330 && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
5332 permerror (input_location, "to refer to a type member of a template parameter, "
5333 "use %<typename %E%>", orig_arg);
5335 orig_arg = make_typename_type (TREE_OPERAND (arg, 0),
5336 TREE_OPERAND (arg, 1),
5338 complain & tf_error);
5342 if (is_type != requires_type)
5346 if (complain & tf_error)
5348 error ("type/value mismatch at argument %d in template "
5349 "parameter list for %qD",
5352 error (" expected a constant of type %qT, got %qT",
5354 (DECL_P (arg) ? DECL_NAME (arg) : orig_arg));
5355 else if (requires_tmpl_type)
5356 error (" expected a class template, got %qE", orig_arg);
5358 error (" expected a type, got %qE", orig_arg);
5361 return error_mark_node;
5363 if (is_tmpl_type ^ requires_tmpl_type)
5365 if (in_decl && (complain & tf_error))
5367 error ("type/value mismatch at argument %d in template "
5368 "parameter list for %qD",
5371 error (" expected a type, got %qT", DECL_NAME (arg));
5373 error (" expected a class template, got %qT", orig_arg);
5375 return error_mark_node;
5380 if (requires_tmpl_type)
5382 if (TREE_CODE (TREE_TYPE (arg)) == UNBOUND_CLASS_TEMPLATE)
5383 /* The number of argument required is not known yet.
5384 Just accept it for now. */
5385 val = TREE_TYPE (arg);
5388 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
5391 argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
5393 if (coerce_template_template_parms (parmparm, argparm,
5399 /* TEMPLATE_TEMPLATE_PARM node is preferred over
5401 if (val != error_mark_node)
5403 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val))
5404 val = TREE_TYPE (val);
5405 else if (TREE_CODE (val) == TYPE_PACK_EXPANSION
5406 && DECL_TEMPLATE_TEMPLATE_PARM_P (arg))
5408 val = TREE_TYPE (arg);
5409 val = make_pack_expansion (val);
5415 if (in_decl && (complain & tf_error))
5417 error ("type/value mismatch at argument %d in "
5418 "template parameter list for %qD",
5420 error (" expected a template of type %qD, got %qD",
5424 val = error_mark_node;
5430 /* We only form one instance of each template specialization.
5431 Therefore, if we use a non-canonical variant (i.e., a
5432 typedef), any future messages referring to the type will use
5433 the typedef, which is confusing if those future uses do not
5434 themselves also use the typedef. */
5436 val = strip_typedefs (val);
5440 tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl);
5442 if (invalid_nontype_parm_type_p (t, complain))
5443 return error_mark_node;
5445 if (template_parameter_pack_p (parm) && ARGUMENT_PACK_P (orig_arg))
5447 if (same_type_p (t, TREE_TYPE (orig_arg)))
5451 /* Not sure if this is reachable, but it doesn't hurt
5453 error ("type mismatch in nontype parameter pack");
5454 val = error_mark_node;
5457 else if (!uses_template_parms (orig_arg) && !uses_template_parms (t))
5458 /* We used to call digest_init here. However, digest_init
5459 will report errors, which we don't want when complain
5460 is zero. More importantly, digest_init will try too
5461 hard to convert things: for example, `0' should not be
5462 converted to pointer type at this point according to
5463 the standard. Accepting this is not merely an
5464 extension, since deciding whether or not these
5465 conversions can occur is part of determining which
5466 function template to call, or whether a given explicit
5467 argument specification is valid. */
5468 val = convert_nontype_argument (t, orig_arg);
5472 if (val == NULL_TREE)
5473 val = error_mark_node;
5474 else if (val == error_mark_node && (complain & tf_error))
5475 error ("could not convert template argument %qE to %qT", orig_arg, t);
5481 /* Coerces the remaining template arguments in INNER_ARGS (from
5482 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
5483 Returns the coerced argument pack. PARM_IDX is the position of this
5484 parameter in the template parameter list. ARGS is the original
5485 template argument list. */
5487 coerce_template_parameter_pack (tree parms,
5495 tsubst_flags_t complain)
5497 tree parm = TREE_VEC_ELT (parms, parm_idx);
5498 int nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
5501 tree packed_types = NULL_TREE;
5503 if (arg_idx > nargs)
5506 packed_args = make_tree_vec (nargs - arg_idx);
5508 if (TREE_CODE (TREE_VALUE (parm)) == PARM_DECL
5509 && uses_parameter_packs (TREE_TYPE (TREE_VALUE (parm))))
5511 /* When the template parameter is a non-type template
5512 parameter pack whose type uses parameter packs, we need
5513 to look at each of the template arguments
5514 separately. Build a vector of the types for these
5515 non-type template parameters in PACKED_TYPES. */
5517 = make_pack_expansion (TREE_TYPE (TREE_VALUE (parm)));
5518 packed_types = tsubst_pack_expansion (expansion, args,
5521 if (packed_types == error_mark_node)
5522 return error_mark_node;
5524 /* Check that we have the right number of arguments. */
5526 && !PACK_EXPANSION_P (TREE_VEC_ELT (inner_args, arg_idx))
5527 && nargs - arg_idx != TREE_VEC_LENGTH (packed_types))
5530 = TREE_VEC_LENGTH (parms) - 1 + TREE_VEC_LENGTH (packed_types);
5531 error ("wrong number of template arguments (%d, should be %d)",
5532 nargs, needed_parms);
5533 return error_mark_node;
5536 /* If we aren't able to check the actual arguments now
5537 (because they haven't been expanded yet), we can at least
5538 verify that all of the types used for the non-type
5539 template parameter pack are, in fact, valid for non-type
5540 template parameters. */
5542 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args, arg_idx)))
5544 int j, len = TREE_VEC_LENGTH (packed_types);
5545 for (j = 0; j < len; ++j)
5547 tree t = TREE_VEC_ELT (packed_types, j);
5548 if (invalid_nontype_parm_type_p (t, complain))
5549 return error_mark_node;
5554 /* Convert the remaining arguments, which will be a part of the
5555 parameter pack "parm". */
5556 for (; arg_idx < nargs; ++arg_idx)
5558 tree arg = TREE_VEC_ELT (inner_args, arg_idx);
5559 tree actual_parm = TREE_VALUE (parm);
5561 if (packed_types && !PACK_EXPANSION_P (arg))
5563 /* When we have a vector of types (corresponding to the
5564 non-type template parameter pack that uses parameter
5565 packs in its type, as mention above), and the
5566 argument is not an expansion (which expands to a
5567 currently unknown number of arguments), clone the
5568 parm and give it the next type in PACKED_TYPES. */
5569 actual_parm = copy_node (actual_parm);
5570 TREE_TYPE (actual_parm) =
5571 TREE_VEC_ELT (packed_types, arg_idx - parm_idx);
5574 if (arg != error_mark_node)
5575 arg = convert_template_argument (actual_parm,
5576 arg, new_args, complain, parm_idx,
5578 if (arg == error_mark_node)
5580 TREE_VEC_ELT (packed_args, arg_idx - parm_idx) = arg;
5583 if (TREE_CODE (TREE_VALUE (parm)) == TYPE_DECL
5584 || TREE_CODE (TREE_VALUE (parm)) == TEMPLATE_DECL)
5585 argument_pack = cxx_make_type (TYPE_ARGUMENT_PACK);
5588 argument_pack = make_node (NONTYPE_ARGUMENT_PACK);
5589 TREE_TYPE (argument_pack)
5590 = tsubst (TREE_TYPE (TREE_VALUE (parm)), new_args, complain, in_decl);
5591 TREE_CONSTANT (argument_pack) = 1;
5594 SET_ARGUMENT_PACK_ARGS (argument_pack, packed_args);
5595 return argument_pack;
5598 /* Convert all template arguments to their appropriate types, and
5599 return a vector containing the innermost resulting template
5600 arguments. If any error occurs, return error_mark_node. Error and
5601 warning messages are issued under control of COMPLAIN.
5603 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
5604 for arguments not specified in ARGS. Otherwise, if
5605 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
5606 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
5607 USE_DEFAULT_ARGS is false, then all arguments must be specified in
5611 coerce_template_parms (tree parms,
5614 tsubst_flags_t complain,
5615 bool require_all_args,
5616 bool use_default_args)
5618 int nparms, nargs, parm_idx, arg_idx, lost = 0;
5621 tree new_inner_args;
5622 int saved_unevaluated_operand;
5623 int saved_inhibit_evaluation_warnings;
5625 /* When used as a boolean value, indicates whether this is a
5626 variadic template parameter list. Since it's an int, we can also
5627 subtract it from nparms to get the number of non-variadic
5631 nparms = TREE_VEC_LENGTH (parms);
5633 /* Determine if there are any parameter packs. */
5634 for (parm_idx = 0; parm_idx < nparms; ++parm_idx)
5636 tree tparm = TREE_VALUE (TREE_VEC_ELT (parms, parm_idx));
5637 if (template_parameter_pack_p (tparm))
5641 inner_args = INNERMOST_TEMPLATE_ARGS (args);
5642 /* If there are 0 or 1 parameter packs, we need to expand any argument
5643 packs so that we can deduce a parameter pack from some non-packed args
5644 followed by an argument pack, as in variadic85.C. If there are more
5645 than that, we need to leave argument packs intact so the arguments are
5646 assigned to the right parameter packs. This should only happen when
5647 dealing with a nested class inside a partial specialization of a class
5648 template, as in variadic92.C. */
5649 if (variadic_p <= 1)
5650 inner_args = expand_template_argument_pack (inner_args);
5652 nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
5653 if ((nargs > nparms && !variadic_p)
5654 || (nargs < nparms - variadic_p
5656 && (!use_default_args
5657 || (TREE_VEC_ELT (parms, nargs) != error_mark_node
5658 && !TREE_PURPOSE (TREE_VEC_ELT (parms, nargs))))))
5660 if (complain & tf_error)
5662 const char *or_more = "";
5665 or_more = " or more";
5669 error ("wrong number of template arguments (%d, should be %d%s)",
5670 nargs, nparms, or_more);
5673 error ("provided for %q+D", in_decl);
5676 return error_mark_node;
5679 /* We need to evaluate the template arguments, even though this
5680 template-id may be nested within a "sizeof". */
5681 saved_unevaluated_operand = cp_unevaluated_operand;
5682 cp_unevaluated_operand = 0;
5683 saved_inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
5684 c_inhibit_evaluation_warnings = 0;
5685 new_inner_args = make_tree_vec (nparms);
5686 new_args = add_outermost_template_args (args, new_inner_args);
5687 for (parm_idx = 0, arg_idx = 0; parm_idx < nparms; parm_idx++, arg_idx++)
5692 /* Get the Ith template parameter. */
5693 parm = TREE_VEC_ELT (parms, parm_idx);
5695 if (parm == error_mark_node)
5697 TREE_VEC_ELT (new_inner_args, arg_idx) = error_mark_node;
5701 /* Calculate the next argument. */
5702 if (arg_idx < nargs)
5703 arg = TREE_VEC_ELT (inner_args, arg_idx);
5707 if (template_parameter_pack_p (TREE_VALUE (parm))
5708 && !(arg && ARGUMENT_PACK_P (arg)))
5710 /* All remaining arguments will be placed in the
5711 template parameter pack PARM. */
5712 arg = coerce_template_parameter_pack (parms, parm_idx, args,
5713 inner_args, arg_idx,
5717 /* Store this argument. */
5718 if (arg == error_mark_node)
5720 TREE_VEC_ELT (new_inner_args, parm_idx) = arg;
5722 /* We are done with all of the arguments. */
5729 if (PACK_EXPANSION_P (arg))
5731 if (complain & tf_error)
5733 /* FIXME this restriction was removed by N2555; see
5735 /* If ARG is a pack expansion, but PARM is not a
5736 template parameter pack (if it were, we would have
5737 handled it above), we're trying to expand into a
5738 fixed-length argument list. */
5739 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
5740 sorry ("cannot expand %<%E%> into a fixed-length "
5741 "argument list", arg);
5743 sorry ("cannot expand %<%T%> into a fixed-length "
5744 "argument list", arg);
5746 return error_mark_node;
5749 else if (require_all_args)
5750 /* There must be a default arg in this case. */
5751 arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
5756 if (arg == error_mark_node)
5758 if (complain & tf_error)
5759 error ("template argument %d is invalid", arg_idx + 1);
5762 /* This only occurs if there was an error in the template
5763 parameter list itself (which we would already have
5764 reported) that we are trying to recover from, e.g., a class
5765 template with a parameter list such as
5766 template<typename..., typename>. */
5767 return error_mark_node;
5769 arg = convert_template_argument (TREE_VALUE (parm),
5770 arg, new_args, complain,
5773 if (arg == error_mark_node)
5775 TREE_VEC_ELT (new_inner_args, arg_idx) = arg;
5777 cp_unevaluated_operand = saved_unevaluated_operand;
5778 c_inhibit_evaluation_warnings = saved_inhibit_evaluation_warnings;
5781 return error_mark_node;
5783 return new_inner_args;
5786 /* Returns 1 if template args OT and NT are equivalent. */
5789 template_args_equal (tree ot, tree nt)
5794 if (TREE_CODE (nt) == TREE_VEC)
5795 /* For member templates */
5796 return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt);
5797 else if (PACK_EXPANSION_P (ot))
5798 return PACK_EXPANSION_P (nt)
5799 && template_args_equal (PACK_EXPANSION_PATTERN (ot),
5800 PACK_EXPANSION_PATTERN (nt));
5801 else if (ARGUMENT_PACK_P (ot))
5806 if (!ARGUMENT_PACK_P (nt))
5809 opack = ARGUMENT_PACK_ARGS (ot);
5810 npack = ARGUMENT_PACK_ARGS (nt);
5811 len = TREE_VEC_LENGTH (opack);
5812 if (TREE_VEC_LENGTH (npack) != len)
5814 for (i = 0; i < len; ++i)
5815 if (!template_args_equal (TREE_VEC_ELT (opack, i),
5816 TREE_VEC_ELT (npack, i)))
5820 else if (TYPE_P (nt))
5821 return TYPE_P (ot) && same_type_p (ot, nt);
5822 else if (TREE_CODE (ot) == TREE_VEC || TYPE_P (ot))
5825 return cp_tree_equal (ot, nt);
5828 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
5829 of template arguments. Returns 0 otherwise. */
5832 comp_template_args (tree oldargs, tree newargs)
5836 if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
5839 for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
5841 tree nt = TREE_VEC_ELT (newargs, i);
5842 tree ot = TREE_VEC_ELT (oldargs, i);
5844 if (! template_args_equal (ot, nt))
5851 add_pending_template (tree d)
5853 tree ti = (TYPE_P (d)
5854 ? CLASSTYPE_TEMPLATE_INFO (d)
5855 : DECL_TEMPLATE_INFO (d));
5856 struct pending_template *pt;
5859 if (TI_PENDING_TEMPLATE_FLAG (ti))
5862 /* We are called both from instantiate_decl, where we've already had a
5863 tinst_level pushed, and instantiate_template, where we haven't.
5865 level = !current_tinst_level || current_tinst_level->decl != d;
5868 push_tinst_level (d);
5870 pt = GGC_NEW (struct pending_template);
5872 pt->tinst = current_tinst_level;
5873 if (last_pending_template)
5874 last_pending_template->next = pt;
5876 pending_templates = pt;
5878 last_pending_template = pt;
5880 TI_PENDING_TEMPLATE_FLAG (ti) = 1;
5887 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
5888 ARGLIST. Valid choices for FNS are given in the cp-tree.def
5889 documentation for TEMPLATE_ID_EXPR. */
5892 lookup_template_function (tree fns, tree arglist)
5896 if (fns == error_mark_node || arglist == error_mark_node)
5897 return error_mark_node;
5899 gcc_assert (!arglist || TREE_CODE (arglist) == TREE_VEC);
5900 gcc_assert (fns && (is_overloaded_fn (fns)
5901 || TREE_CODE (fns) == IDENTIFIER_NODE));
5903 if (BASELINK_P (fns))
5905 BASELINK_FUNCTIONS (fns) = build2 (TEMPLATE_ID_EXPR,
5907 BASELINK_FUNCTIONS (fns),
5912 type = TREE_TYPE (fns);
5913 if (TREE_CODE (fns) == OVERLOAD || !type)
5914 type = unknown_type_node;
5916 return build2 (TEMPLATE_ID_EXPR, type, fns, arglist);
5919 /* Within the scope of a template class S<T>, the name S gets bound
5920 (in build_self_reference) to a TYPE_DECL for the class, not a
5921 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
5922 or one of its enclosing classes, and that type is a template,
5923 return the associated TEMPLATE_DECL. Otherwise, the original
5924 DECL is returned. */
5927 maybe_get_template_decl_from_type_decl (tree decl)
5929 return (decl != NULL_TREE
5930 && TREE_CODE (decl) == TYPE_DECL
5931 && DECL_ARTIFICIAL (decl)
5932 && CLASS_TYPE_P (TREE_TYPE (decl))
5933 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
5934 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl;
5937 /* Given an IDENTIFIER_NODE (type TEMPLATE_DECL) and a chain of
5938 parameters, find the desired type.
5940 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
5942 IN_DECL, if non-NULL, is the template declaration we are trying to
5945 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
5946 the class we are looking up.
5948 Issue error and warning messages under control of COMPLAIN.
5950 If the template class is really a local class in a template
5951 function, then the FUNCTION_CONTEXT is the function in which it is
5954 ??? Note that this function is currently called *twice* for each
5955 template-id: the first time from the parser, while creating the
5956 incomplete type (finish_template_type), and the second type during the
5957 real instantiation (instantiate_template_class). This is surely something
5958 that we want to avoid. It also causes some problems with argument
5959 coercion (see convert_nontype_argument for more information on this). */
5962 lookup_template_class (tree d1,
5967 tsubst_flags_t complain)
5969 tree templ = NULL_TREE, parmlist;
5976 timevar_push (TV_NAME_LOOKUP);
5978 if (TREE_CODE (d1) == IDENTIFIER_NODE)
5980 tree value = innermost_non_namespace_value (d1);
5981 if (value && DECL_TEMPLATE_TEMPLATE_PARM_P (value))
5986 push_decl_namespace (context);
5987 templ = lookup_name (d1);
5988 templ = maybe_get_template_decl_from_type_decl (templ);
5990 pop_decl_namespace ();
5993 context = DECL_CONTEXT (templ);
5995 else if (TREE_CODE (d1) == TYPE_DECL && MAYBE_CLASS_TYPE_P (TREE_TYPE (d1)))
5997 tree type = TREE_TYPE (d1);
5999 /* If we are declaring a constructor, say A<T>::A<T>, we will get
6000 an implicit typename for the second A. Deal with it. */
6001 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
6002 type = TREE_TYPE (type);
6004 if (CLASSTYPE_TEMPLATE_INFO (type))
6006 templ = CLASSTYPE_TI_TEMPLATE (type);
6007 d1 = DECL_NAME (templ);
6010 else if (TREE_CODE (d1) == ENUMERAL_TYPE
6011 || (TYPE_P (d1) && MAYBE_CLASS_TYPE_P (d1)))
6013 templ = TYPE_TI_TEMPLATE (d1);
6014 d1 = DECL_NAME (templ);
6016 else if (TREE_CODE (d1) == TEMPLATE_DECL
6017 && DECL_TEMPLATE_RESULT (d1)
6018 && TREE_CODE (DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL)
6021 d1 = DECL_NAME (templ);
6022 context = DECL_CONTEXT (templ);
6025 /* Issue an error message if we didn't find a template. */
6028 if (complain & tf_error)
6029 error ("%qT is not a template", d1);
6030 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
6033 if (TREE_CODE (templ) != TEMPLATE_DECL
6034 /* Make sure it's a user visible template, if it was named by
6036 || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (templ)
6037 && !PRIMARY_TEMPLATE_P (templ)))
6039 if (complain & tf_error)
6041 error ("non-template type %qT used as a template", d1);
6043 error ("for template declaration %q+D", in_decl);
6045 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
6048 complain &= ~tf_user;
6050 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ))
6052 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
6053 template arguments */
6059 parmlist = DECL_INNERMOST_TEMPLATE_PARMS (templ);
6061 /* Consider an example where a template template parameter declared as
6063 template <class T, class U = std::allocator<T> > class TT
6065 The template parameter level of T and U are one level larger than
6066 of TT. To proper process the default argument of U, say when an
6067 instantiation `TT<int>' is seen, we need to build the full
6068 arguments containing {int} as the innermost level. Outer levels,
6069 available when not appearing as default template argument, can be
6070 obtained from the arguments of the enclosing template.
6072 Suppose that TT is later substituted with std::vector. The above
6073 instantiation is `TT<int, std::allocator<T> >' with TT at
6074 level 1, and T at level 2, while the template arguments at level 1
6075 becomes {std::vector} and the inner level 2 is {int}. */
6077 outer = DECL_CONTEXT (templ);
6079 outer = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer)));
6080 else if (current_template_parms)
6081 /* This is an argument of the current template, so we haven't set
6082 DECL_CONTEXT yet. */
6083 outer = current_template_args ();
6086 arglist = add_to_template_args (outer, arglist);
6088 arglist2 = coerce_template_parms (parmlist, arglist, templ,
6090 /*require_all_args=*/true,
6091 /*use_default_args=*/true);
6092 if (arglist2 == error_mark_node
6093 || (!uses_template_parms (arglist2)
6094 && check_instantiated_args (templ, arglist2, complain)))
6095 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
6097 parm = bind_template_template_parm (TREE_TYPE (templ), arglist2);
6098 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, parm);
6102 tree template_type = TREE_TYPE (templ);
6105 tree found = NULL_TREE;
6108 int is_partial_instantiation;
6110 gen_tmpl = most_general_template (templ);
6111 parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
6112 parm_depth = TMPL_PARMS_DEPTH (parmlist);
6113 arg_depth = TMPL_ARGS_DEPTH (arglist);
6115 if (arg_depth == 1 && parm_depth > 1)
6117 /* We've been given an incomplete set of template arguments.
6120 template <class T> struct S1 {
6121 template <class U> struct S2 {};
6122 template <class U> struct S2<U*> {};
6125 we will be called with an ARGLIST of `U*', but the
6126 TEMPLATE will be `template <class T> template
6127 <class U> struct S1<T>::S2'. We must fill in the missing
6130 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (templ)),
6132 arg_depth = TMPL_ARGS_DEPTH (arglist);
6135 /* Now we should have enough arguments. */
6136 gcc_assert (parm_depth == arg_depth);
6138 /* From here on, we're only interested in the most general
6141 /* Calculate the BOUND_ARGS. These will be the args that are
6142 actually tsubst'd into the definition to create the
6146 /* We have multiple levels of arguments to coerce, at once. */
6148 int saved_depth = TMPL_ARGS_DEPTH (arglist);
6150 tree bound_args = make_tree_vec (parm_depth);
6152 for (i = saved_depth,
6153 t = DECL_TEMPLATE_PARMS (gen_tmpl);
6154 i > 0 && t != NULL_TREE;
6155 --i, t = TREE_CHAIN (t))
6157 tree a = coerce_template_parms (TREE_VALUE (t),
6160 /*require_all_args=*/true,
6161 /*use_default_args=*/true);
6163 /* Don't process further if one of the levels fails. */
6164 if (a == error_mark_node)
6166 /* Restore the ARGLIST to its full size. */
6167 TREE_VEC_LENGTH (arglist) = saved_depth;
6168 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
6171 SET_TMPL_ARGS_LEVEL (bound_args, i, a);
6173 /* We temporarily reduce the length of the ARGLIST so
6174 that coerce_template_parms will see only the arguments
6175 corresponding to the template parameters it is
6177 TREE_VEC_LENGTH (arglist)--;
6180 /* Restore the ARGLIST to its full size. */
6181 TREE_VEC_LENGTH (arglist) = saved_depth;
6183 arglist = bound_args;
6187 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist),
6188 INNERMOST_TEMPLATE_ARGS (arglist),
6191 /*require_all_args=*/true,
6192 /*use_default_args=*/true);
6194 if (arglist == error_mark_node)
6195 /* We were unable to bind the arguments. */
6196 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
6198 /* In the scope of a template class, explicit references to the
6199 template class refer to the type of the template, not any
6200 instantiation of it. For example, in:
6202 template <class T> class C { void f(C<T>); }
6204 the `C<T>' is just the same as `C'. Outside of the
6205 class, however, such a reference is an instantiation. */
6207 || !PRIMARY_TEMPLATE_P (gen_tmpl)
6208 || currently_open_class (template_type))
6209 /* comp_template_args is expensive, check it last. */
6210 && comp_template_args (TYPE_TI_ARGS (template_type),
6212 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, template_type);
6214 /* If we already have this specialization, return it. */
6215 elt.tmpl = gen_tmpl;
6217 hash = hash_specialization (&elt);
6218 entry = (spec_entry *) htab_find_with_hash (type_specializations,
6222 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, entry->spec);
6224 /* This type is a "partial instantiation" if any of the template
6225 arguments still involve template parameters. Note that we set
6226 IS_PARTIAL_INSTANTIATION for partial specializations as
6228 is_partial_instantiation = uses_template_parms (arglist);
6230 /* If the deduced arguments are invalid, then the binding
6232 if (!is_partial_instantiation
6233 && check_instantiated_args (gen_tmpl,
6234 INNERMOST_TEMPLATE_ARGS (arglist),
6236 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
6238 if (!is_partial_instantiation
6239 && !PRIMARY_TEMPLATE_P (gen_tmpl)
6240 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl))
6241 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl)) == NAMESPACE_DECL)
6243 found = xref_tag_from_type (TREE_TYPE (gen_tmpl),
6244 DECL_NAME (gen_tmpl),
6245 /*tag_scope=*/ts_global);
6246 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
6249 context = tsubst (DECL_CONTEXT (gen_tmpl), arglist,
6252 context = global_namespace;
6254 /* Create the type. */
6255 if (TREE_CODE (template_type) == ENUMERAL_TYPE)
6257 if (!is_partial_instantiation)
6259 set_current_access_from_decl (TYPE_NAME (template_type));
6260 t = start_enum (TYPE_IDENTIFIER (template_type),
6261 tsubst (ENUM_UNDERLYING_TYPE (template_type),
6262 arglist, complain, in_decl),
6263 SCOPED_ENUM_P (template_type));
6267 /* We don't want to call start_enum for this type, since
6268 the values for the enumeration constants may involve
6269 template parameters. And, no one should be interested
6270 in the enumeration constants for such a type. */
6271 t = cxx_make_type (ENUMERAL_TYPE);
6272 SET_SCOPED_ENUM_P (t, SCOPED_ENUM_P (template_type));
6277 t = make_class_type (TREE_CODE (template_type));
6278 CLASSTYPE_DECLARED_CLASS (t)
6279 = CLASSTYPE_DECLARED_CLASS (template_type);
6280 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
6281 TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);
6283 /* A local class. Make sure the decl gets registered properly. */
6284 if (context == current_function_decl)
6285 pushtag (DECL_NAME (gen_tmpl), t, /*tag_scope=*/ts_current);
6287 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type), arglist))
6288 /* This instantiation is another name for the primary
6289 template type. Set the TYPE_CANONICAL field
6291 TYPE_CANONICAL (t) = template_type;
6292 else if (any_template_arguments_need_structural_equality_p (arglist))
6293 /* Some of the template arguments require structural
6294 equality testing, so this template class requires
6295 structural equality testing. */
6296 SET_TYPE_STRUCTURAL_EQUALITY (t);
6299 /* If we called start_enum or pushtag above, this information
6300 will already be set up. */
6303 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
6305 type_decl = create_implicit_typedef (DECL_NAME (gen_tmpl), t);
6306 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
6307 TYPE_STUB_DECL (t) = type_decl;
6308 DECL_SOURCE_LOCATION (type_decl)
6309 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type));
6312 type_decl = TYPE_NAME (t);
6314 TREE_PRIVATE (type_decl)
6315 = TREE_PRIVATE (TYPE_STUB_DECL (template_type));
6316 TREE_PROTECTED (type_decl)
6317 = TREE_PROTECTED (TYPE_STUB_DECL (template_type));
6318 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type))
6320 DECL_VISIBILITY_SPECIFIED (type_decl) = 1;
6321 DECL_VISIBILITY (type_decl) = CLASSTYPE_VISIBILITY (template_type);
6324 /* Set up the template information. We have to figure out which
6325 template is the immediate parent if this is a full
6327 if (parm_depth == 1 || is_partial_instantiation
6328 || !PRIMARY_TEMPLATE_P (gen_tmpl))
6329 /* This case is easy; there are no member templates involved. */
6333 /* This is a full instantiation of a member template. Find
6334 the partial instantiation of which this is an instance. */
6336 /* Temporarily reduce by one the number of levels in the ARGLIST
6337 so as to avoid comparing the last set of arguments. */
6338 TREE_VEC_LENGTH (arglist)--;
6339 found = tsubst (gen_tmpl, arglist, complain, NULL_TREE);
6340 TREE_VEC_LENGTH (arglist)++;
6341 found = CLASSTYPE_TI_TEMPLATE (found);
6344 SET_TYPE_TEMPLATE_INFO (t, tree_cons (found, arglist, NULL_TREE));
6347 slot = (spec_entry **) htab_find_slot_with_hash (type_specializations,
6348 &elt, hash, INSERT);
6349 *slot = GGC_NEW (spec_entry);
6352 /* Note this use of the partial instantiation so we can check it
6353 later in maybe_process_partial_specialization. */
6354 DECL_TEMPLATE_INSTANTIATIONS (templ)
6355 = tree_cons (arglist, t,
6356 DECL_TEMPLATE_INSTANTIATIONS (templ));
6358 if (TREE_CODE (t) == ENUMERAL_TYPE
6359 && !is_partial_instantiation)
6360 /* Now that the type has been registered on the instantiations
6361 list, we set up the enumerators. Because the enumeration
6362 constants may involve the enumeration type itself, we make
6363 sure to register the type first, and then create the
6364 constants. That way, doing tsubst_expr for the enumeration
6365 constants won't result in recursive calls here; we'll find
6366 the instantiation and exit above. */
6367 tsubst_enum (template_type, t, arglist);
6369 if (is_partial_instantiation)
6370 /* If the type makes use of template parameters, the
6371 code that generates debugging information will crash. */
6372 DECL_IGNORED_P (TYPE_STUB_DECL (t)) = 1;
6374 /* Possibly limit visibility based on template args. */
6375 TREE_PUBLIC (type_decl) = 1;
6376 determine_visibility (type_decl);
6378 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
6380 timevar_pop (TV_NAME_LOOKUP);
6387 /* True when we should also visit template parameters that occur in
6388 non-deduced contexts. */
6389 bool include_nondeduced_p;
6390 struct pointer_set_t *visited;
6393 /* Called from for_each_template_parm via walk_tree. */
6396 for_each_template_parm_r (tree *tp, int *walk_subtrees, void *d)
6399 struct pair_fn_data *pfd = (struct pair_fn_data *) d;
6400 tree_fn_t fn = pfd->fn;
6401 void *data = pfd->data;
6404 && (pfd->include_nondeduced_p || TREE_CODE (t) != TYPENAME_TYPE)
6405 && for_each_template_parm (TYPE_CONTEXT (t), fn, data, pfd->visited,
6406 pfd->include_nondeduced_p))
6407 return error_mark_node;
6409 switch (TREE_CODE (t))
6412 if (TYPE_PTRMEMFUNC_P (t))
6418 if (!TYPE_TEMPLATE_INFO (t))
6420 else if (for_each_template_parm (TREE_VALUE (TYPE_TEMPLATE_INFO (t)),
6421 fn, data, pfd->visited,
6422 pfd->include_nondeduced_p))
6423 return error_mark_node;
6427 if (for_each_template_parm (TYPE_MIN_VALUE (t),
6428 fn, data, pfd->visited,
6429 pfd->include_nondeduced_p)
6430 || for_each_template_parm (TYPE_MAX_VALUE (t),
6431 fn, data, pfd->visited,
6432 pfd->include_nondeduced_p))
6433 return error_mark_node;
6437 /* Since we're not going to walk subtrees, we have to do this
6439 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data,
6440 pfd->visited, pfd->include_nondeduced_p))
6441 return error_mark_node;
6445 /* Check the return type. */
6446 if (for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited,
6447 pfd->include_nondeduced_p))
6448 return error_mark_node;
6450 /* Check the parameter types. Since default arguments are not
6451 instantiated until they are needed, the TYPE_ARG_TYPES may
6452 contain expressions that involve template parameters. But,
6453 no-one should be looking at them yet. And, once they're
6454 instantiated, they don't contain template parameters, so
6455 there's no point in looking at them then, either. */
6459 for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm))
6460 if (for_each_template_parm (TREE_VALUE (parm), fn, data,
6461 pfd->visited, pfd->include_nondeduced_p))
6462 return error_mark_node;
6464 /* Since we've already handled the TYPE_ARG_TYPES, we don't
6465 want walk_tree walking into them itself. */
6471 if (pfd->include_nondeduced_p
6472 && for_each_template_parm (TYPE_FIELDS (t), fn, data,
6474 pfd->include_nondeduced_p))
6475 return error_mark_node;
6480 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
6481 && for_each_template_parm (DECL_TI_ARGS (t), fn, data,
6482 pfd->visited, pfd->include_nondeduced_p))
6483 return error_mark_node;
6488 if (TREE_CODE (t) == CONST_DECL && DECL_TEMPLATE_PARM_P (t)
6489 && for_each_template_parm (DECL_INITIAL (t), fn, data,
6490 pfd->visited, pfd->include_nondeduced_p))
6491 return error_mark_node;
6492 if (DECL_CONTEXT (t)
6493 && pfd->include_nondeduced_p
6494 && for_each_template_parm (DECL_CONTEXT (t), fn, data,
6495 pfd->visited, pfd->include_nondeduced_p))
6496 return error_mark_node;
6499 case BOUND_TEMPLATE_TEMPLATE_PARM:
6500 /* Record template parameters such as `T' inside `TT<T>'. */
6501 if (for_each_template_parm (TYPE_TI_ARGS (t), fn, data, pfd->visited,
6502 pfd->include_nondeduced_p))
6503 return error_mark_node;
6506 case TEMPLATE_TEMPLATE_PARM:
6507 case TEMPLATE_TYPE_PARM:
6508 case TEMPLATE_PARM_INDEX:
6509 if (fn && (*fn)(t, data))
6510 return error_mark_node;
6512 return error_mark_node;
6516 /* A template template parameter is encountered. */
6517 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)
6518 && for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited,
6519 pfd->include_nondeduced_p))
6520 return error_mark_node;
6522 /* Already substituted template template parameter */
6528 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t), fn,
6530 pfd->include_nondeduced_p))
6531 return error_mark_node;
6535 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))
6536 && pfd->include_nondeduced_p
6537 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
6538 (TREE_TYPE (t)), fn, data,
6539 pfd->visited, pfd->include_nondeduced_p))
6540 return error_mark_node;
6545 /* If there's no type, then this thing must be some expression
6546 involving template parameters. */
6547 if (!fn && !TREE_TYPE (t))
6548 return error_mark_node;
6553 case REINTERPRET_CAST_EXPR:
6554 case CONST_CAST_EXPR:
6555 case STATIC_CAST_EXPR:
6556 case DYNAMIC_CAST_EXPR:
6560 case PSEUDO_DTOR_EXPR:
6562 return error_mark_node;
6569 /* We didn't find any template parameters we liked. */
6573 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
6574 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
6575 call FN with the parameter and the DATA.
6576 If FN returns nonzero, the iteration is terminated, and
6577 for_each_template_parm returns 1. Otherwise, the iteration
6578 continues. If FN never returns a nonzero value, the value
6579 returned by for_each_template_parm is 0. If FN is NULL, it is
6580 considered to be the function which always returns 1.
6582 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
6583 parameters that occur in non-deduced contexts. When false, only
6584 visits those template parameters that can be deduced. */
6587 for_each_template_parm (tree t, tree_fn_t fn, void* data,
6588 struct pointer_set_t *visited,
6589 bool include_nondeduced_p)
6591 struct pair_fn_data pfd;
6597 pfd.include_nondeduced_p = include_nondeduced_p;
6599 /* Walk the tree. (Conceptually, we would like to walk without
6600 duplicates, but for_each_template_parm_r recursively calls
6601 for_each_template_parm, so we would need to reorganize a fair
6602 bit to use walk_tree_without_duplicates, so we keep our own
6605 pfd.visited = visited;
6607 pfd.visited = pointer_set_create ();
6608 result = cp_walk_tree (&t,
6609 for_each_template_parm_r,
6611 pfd.visited) != NULL_TREE;
6616 pointer_set_destroy (pfd.visited);
6623 /* Returns true if T depends on any template parameter. */
6626 uses_template_parms (tree t)
6629 int saved_processing_template_decl;
6631 saved_processing_template_decl = processing_template_decl;
6632 if (!saved_processing_template_decl)
6633 processing_template_decl = 1;
6635 dependent_p = dependent_type_p (t);
6636 else if (TREE_CODE (t) == TREE_VEC)
6637 dependent_p = any_dependent_template_arguments_p (t);
6638 else if (TREE_CODE (t) == TREE_LIST)
6639 dependent_p = (uses_template_parms (TREE_VALUE (t))
6640 || uses_template_parms (TREE_CHAIN (t)));
6641 else if (TREE_CODE (t) == TYPE_DECL)
6642 dependent_p = dependent_type_p (TREE_TYPE (t));
6645 || TREE_CODE (t) == TEMPLATE_PARM_INDEX
6646 || TREE_CODE (t) == OVERLOAD
6647 || TREE_CODE (t) == BASELINK
6648 || TREE_CODE (t) == IDENTIFIER_NODE
6649 || TREE_CODE (t) == TRAIT_EXPR
6650 || TREE_CODE (t) == CONSTRUCTOR
6651 || CONSTANT_CLASS_P (t))
6652 dependent_p = (type_dependent_expression_p (t)
6653 || value_dependent_expression_p (t));
6656 gcc_assert (t == error_mark_node);
6657 dependent_p = false;
6660 processing_template_decl = saved_processing_template_decl;
6665 /* Returns true if T depends on any template parameter with level LEVEL. */
6668 uses_template_parms_level (tree t, int level)
6670 return for_each_template_parm (t, template_parm_this_level_p, &level, NULL,
6671 /*include_nondeduced_p=*/true);
6674 static int tinst_depth;
6675 extern int max_tinst_depth;
6676 #ifdef GATHER_STATISTICS
6679 static int tinst_level_tick;
6680 static int last_template_error_tick;
6682 /* We're starting to instantiate D; record the template instantiation context
6683 for diagnostics and to restore it later. */
6686 push_tinst_level (tree d)
6688 struct tinst_level *new_level;
6690 if (tinst_depth >= max_tinst_depth)
6692 /* If the instantiation in question still has unbound template parms,
6693 we don't really care if we can't instantiate it, so just return.
6694 This happens with base instantiation for implicit `typename'. */
6695 if (uses_template_parms (d))
6698 last_template_error_tick = tinst_level_tick;
6699 error ("template instantiation depth exceeds maximum of %d (use "
6700 "-ftemplate-depth-NN to increase the maximum) instantiating %qD",
6701 max_tinst_depth, d);
6703 print_instantiation_context ();
6708 new_level = GGC_NEW (struct tinst_level);
6709 new_level->decl = d;
6710 new_level->locus = input_location;
6711 new_level->in_system_header_p = in_system_header;
6712 new_level->next = current_tinst_level;
6713 current_tinst_level = new_level;
6716 #ifdef GATHER_STATISTICS
6717 if (tinst_depth > depth_reached)
6718 depth_reached = tinst_depth;
6725 /* We're done instantiating this template; return to the instantiation
6729 pop_tinst_level (void)
6731 /* Restore the filename and line number stashed away when we started
6732 this instantiation. */
6733 input_location = current_tinst_level->locus;
6734 current_tinst_level = current_tinst_level->next;
6739 /* We're instantiating a deferred template; restore the template
6740 instantiation context in which the instantiation was requested, which
6741 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
6744 reopen_tinst_level (struct tinst_level *level)
6746 struct tinst_level *t;
6749 for (t = level; t; t = t->next)
6752 current_tinst_level = level;
6757 /* Returns the TINST_LEVEL which gives the original instantiation
6760 struct tinst_level *
6761 outermost_tinst_level (void)
6763 struct tinst_level *level = current_tinst_level;
6766 level = level->next;
6770 /* Returns TRUE if PARM is a parameter of the template TEMPL. */
6773 parameter_of_template_p (tree parm, tree templ)
6778 if (!parm || !templ)
6781 gcc_assert (DECL_TEMPLATE_PARM_P (parm));
6782 gcc_assert (TREE_CODE (templ) == TEMPLATE_DECL);
6784 parms = DECL_TEMPLATE_PARMS (templ);
6785 parms = INNERMOST_TEMPLATE_PARMS (parms);
6787 for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
6788 if (parm == TREE_VALUE (TREE_VEC_ELT (parms, i)))
6794 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
6795 vector of template arguments, as for tsubst.
6797 Returns an appropriate tsubst'd friend declaration. */
6800 tsubst_friend_function (tree decl, tree args)
6804 if (TREE_CODE (decl) == FUNCTION_DECL
6805 && DECL_TEMPLATE_INSTANTIATION (decl)
6806 && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
6807 /* This was a friend declared with an explicit template
6808 argument list, e.g.:
6812 to indicate that f was a template instantiation, not a new
6813 function declaration. Now, we have to figure out what
6814 instantiation of what template. */
6816 tree template_id, arglist, fns;
6819 tree ns = decl_namespace_context (TYPE_MAIN_DECL (current_class_type));
6821 /* Friend functions are looked up in the containing namespace scope.
6822 We must enter that scope, to avoid finding member functions of the
6823 current class with same name. */
6824 push_nested_namespace (ns);
6825 fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args,
6826 tf_warning_or_error, NULL_TREE,
6827 /*integral_constant_expression_p=*/false);
6828 pop_nested_namespace (ns);
6829 arglist = tsubst (DECL_TI_ARGS (decl), args,
6830 tf_warning_or_error, NULL_TREE);
6831 template_id = lookup_template_function (fns, arglist);
6833 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
6834 tmpl = determine_specialization (template_id, new_friend,
6836 /*need_member_template=*/0,
6837 TREE_VEC_LENGTH (args),
6839 return instantiate_template (tmpl, new_args, tf_error);
6842 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
6844 /* The NEW_FRIEND will look like an instantiation, to the
6845 compiler, but is not an instantiation from the point of view of
6846 the language. For example, we might have had:
6848 template <class T> struct S {
6849 template <class U> friend void f(T, U);
6852 Then, in S<int>, template <class U> void f(int, U) is not an
6853 instantiation of anything. */
6854 if (new_friend == error_mark_node)
6855 return error_mark_node;
6857 DECL_USE_TEMPLATE (new_friend) = 0;
6858 if (TREE_CODE (decl) == TEMPLATE_DECL)
6860 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0;
6861 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend))
6862 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
6865 /* The mangled name for the NEW_FRIEND is incorrect. The function
6866 is not a template instantiation and should not be mangled like
6867 one. Therefore, we forget the mangling here; we'll recompute it
6868 later if we need it. */
6869 if (TREE_CODE (new_friend) != TEMPLATE_DECL)
6871 SET_DECL_RTL (new_friend, NULL_RTX);
6872 SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE);
6875 if (DECL_NAMESPACE_SCOPE_P (new_friend))
6878 tree new_friend_template_info;
6879 tree new_friend_result_template_info;
6881 int new_friend_is_defn;
6883 /* We must save some information from NEW_FRIEND before calling
6884 duplicate decls since that function will free NEW_FRIEND if
6886 new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
6887 new_friend_is_defn =
6888 (DECL_INITIAL (DECL_TEMPLATE_RESULT
6889 (template_for_substitution (new_friend)))
6891 if (TREE_CODE (new_friend) == TEMPLATE_DECL)
6893 /* This declaration is a `primary' template. */
6894 DECL_PRIMARY_TEMPLATE (new_friend) = new_friend;
6896 new_friend_result_template_info
6897 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend));
6900 new_friend_result_template_info = NULL_TREE;
6902 /* Make the init_value nonzero so pushdecl knows this is a defn. */
6903 if (new_friend_is_defn)
6904 DECL_INITIAL (new_friend) = error_mark_node;
6906 /* Inside pushdecl_namespace_level, we will push into the
6907 current namespace. However, the friend function should go
6908 into the namespace of the template. */
6909 ns = decl_namespace_context (new_friend);
6910 push_nested_namespace (ns);
6911 old_decl = pushdecl_namespace_level (new_friend, /*is_friend=*/true);
6912 pop_nested_namespace (ns);
6914 if (old_decl == error_mark_node)
6915 return error_mark_node;
6917 if (old_decl != new_friend)
6919 /* This new friend declaration matched an existing
6920 declaration. For example, given:
6922 template <class T> void f(T);
6923 template <class U> class C {
6924 template <class T> friend void f(T) {}
6927 the friend declaration actually provides the definition
6928 of `f', once C has been instantiated for some type. So,
6929 old_decl will be the out-of-class template declaration,
6930 while new_friend is the in-class definition.
6932 But, if `f' was called before this point, the
6933 instantiation of `f' will have DECL_TI_ARGS corresponding
6934 to `T' but not to `U', references to which might appear
6935 in the definition of `f'. Previously, the most general
6936 template for an instantiation of `f' was the out-of-class
6937 version; now it is the in-class version. Therefore, we
6938 run through all specialization of `f', adding to their
6939 DECL_TI_ARGS appropriately. In particular, they need a
6940 new set of outer arguments, corresponding to the
6941 arguments for this class instantiation.
6943 The same situation can arise with something like this:
6946 template <class T> class C {
6950 when `C<int>' is instantiated. Now, `f(int)' is defined
6953 if (!new_friend_is_defn)
6954 /* On the other hand, if the in-class declaration does
6955 *not* provide a definition, then we don't want to alter
6956 existing definitions. We can just leave everything
6961 tree new_template = TI_TEMPLATE (new_friend_template_info);
6962 tree new_args = TI_ARGS (new_friend_template_info);
6964 /* Overwrite whatever template info was there before, if
6965 any, with the new template information pertaining to
6967 DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
6969 if (TREE_CODE (old_decl) != TEMPLATE_DECL)
6970 /* We should have called reregister_specialization in
6972 gcc_assert (retrieve_specialization (new_template,
6979 /* Indicate that the old function template is a partial
6981 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl))
6982 = new_friend_result_template_info;
6984 gcc_assert (new_template
6985 == most_general_template (new_template));
6986 gcc_assert (new_template != old_decl);
6988 /* Reassign any specializations already in the hash table
6989 to the new more general template, and add the
6990 additional template args. */
6991 for (t = DECL_TEMPLATE_INSTANTIATIONS (old_decl);
6995 tree spec = TREE_VALUE (t);
6998 elt.tmpl = old_decl;
6999 elt.args = DECL_TI_ARGS (spec);
7000 elt.spec = NULL_TREE;
7002 htab_remove_elt (decl_specializations, &elt);
7005 = add_outermost_template_args (new_args,
7006 DECL_TI_ARGS (spec));
7008 register_specialization
7009 (spec, new_template, DECL_TI_ARGS (spec), true, 0);
7012 DECL_TEMPLATE_INSTANTIATIONS (old_decl) = NULL_TREE;
7016 /* The information from NEW_FRIEND has been merged into OLD_DECL
7017 by duplicate_decls. */
7018 new_friend = old_decl;
7023 tree context = DECL_CONTEXT (new_friend);
7027 template <class T> class C {
7028 template <class U> friend void C1<U>::f (); // case 1
7029 friend void C2<T>::f (); // case 2
7031 we only need to make sure CONTEXT is a complete type for
7032 case 2. To distinguish between the two cases, we note that
7033 CONTEXT of case 1 remains dependent type after tsubst while
7034 this isn't true for case 2. */
7035 ++processing_template_decl;
7036 dependent_p = dependent_type_p (context);
7037 --processing_template_decl;
7040 && !complete_type_or_else (context, NULL_TREE))
7041 return error_mark_node;
7043 if (COMPLETE_TYPE_P (context))
7045 /* Check to see that the declaration is really present, and,
7046 possibly obtain an improved declaration. */
7047 tree fn = check_classfn (context,
7048 new_friend, NULL_TREE);
7058 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
7059 template arguments, as for tsubst.
7061 Returns an appropriate tsubst'd friend type or error_mark_node on
7065 tsubst_friend_class (tree friend_tmpl, tree args)
7071 context = DECL_CONTEXT (friend_tmpl);
7075 if (TREE_CODE (context) == NAMESPACE_DECL)
7076 push_nested_namespace (context);
7078 push_nested_class (tsubst (context, args, tf_none, NULL_TREE));
7081 /* Look for a class template declaration. We look for hidden names
7082 because two friend declarations of the same template are the
7083 same. For example, in:
7086 template <typename> friend class F;
7088 template <typename> struct B {
7089 template <typename> friend class F;
7092 both F templates are the same. */
7093 tmpl = lookup_name_real (DECL_NAME (friend_tmpl), 0, 0,
7094 /*block_p=*/true, 0,
7095 LOOKUP_COMPLAIN | LOOKUP_HIDDEN);
7097 /* But, if we don't find one, it might be because we're in a
7098 situation like this:
7106 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
7107 for `S<int>', not the TEMPLATE_DECL. */
7108 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
7110 tmpl = lookup_name_prefer_type (DECL_NAME (friend_tmpl), 1);
7111 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
7114 if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
7116 /* The friend template has already been declared. Just
7117 check to see that the declarations match, and install any new
7118 default parameters. We must tsubst the default parameters,
7119 of course. We only need the innermost template parameters
7120 because that is all that redeclare_class_template will look
7122 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl))
7123 > TMPL_ARGS_DEPTH (args))
7126 location_t saved_input_location;
7127 parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
7128 args, tf_warning_or_error);
7130 saved_input_location = input_location;
7131 input_location = DECL_SOURCE_LOCATION (friend_tmpl);
7132 redeclare_class_template (TREE_TYPE (tmpl), parms);
7133 input_location = saved_input_location;
7137 friend_type = TREE_TYPE (tmpl);
7141 /* The friend template has not already been declared. In this
7142 case, the instantiation of the template class will cause the
7143 injection of this template into the global scope. */
7144 tmpl = tsubst (friend_tmpl, args, tf_warning_or_error, NULL_TREE);
7145 if (tmpl == error_mark_node)
7146 return error_mark_node;
7148 /* The new TMPL is not an instantiation of anything, so we
7149 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
7150 the new type because that is supposed to be the corresponding
7151 template decl, i.e., TMPL. */
7152 DECL_USE_TEMPLATE (tmpl) = 0;
7153 DECL_TEMPLATE_INFO (tmpl) = NULL_TREE;
7154 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0;
7155 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl))
7156 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)));
7158 /* Inject this template into the global scope. */
7159 friend_type = TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl, true));
7164 if (TREE_CODE (context) == NAMESPACE_DECL)
7165 pop_nested_namespace (context);
7167 pop_nested_class ();
7173 /* Returns zero if TYPE cannot be completed later due to circularity.
7174 Otherwise returns one. */
7177 can_complete_type_without_circularity (tree type)
7179 if (type == NULL_TREE || type == error_mark_node)
7181 else if (COMPLETE_TYPE_P (type))
7183 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
7184 return can_complete_type_without_circularity (TREE_TYPE (type));
7185 else if (CLASS_TYPE_P (type)
7186 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type)))
7192 /* Apply any attributes which had to be deferred until instantiation
7193 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
7194 ARGS, COMPLAIN, IN_DECL are as tsubst. */
7197 apply_late_template_attributes (tree *decl_p, tree attributes, int attr_flags,
7198 tree args, tsubst_flags_t complain, tree in_decl)
7200 tree last_dep = NULL_TREE;
7204 for (t = attributes; t; t = TREE_CHAIN (t))
7205 if (ATTR_IS_DEPENDENT (t))
7208 attributes = copy_list (attributes);
7212 if (DECL_P (*decl_p))
7214 if (TREE_TYPE (*decl_p) == error_mark_node)
7216 p = &DECL_ATTRIBUTES (*decl_p);
7219 p = &TYPE_ATTRIBUTES (*decl_p);
7223 tree late_attrs = NULL_TREE;
7224 tree *q = &late_attrs;
7226 for (*p = attributes; *p; )
7229 if (ATTR_IS_DEPENDENT (t))
7231 *p = TREE_CHAIN (t);
7232 TREE_CHAIN (t) = NULL_TREE;
7233 /* If the first attribute argument is an identifier, don't
7234 pass it through tsubst. Attributes like mode, format,
7235 cleanup and several target specific attributes expect it
7238 && TREE_CODE (TREE_VALUE (t)) == TREE_LIST
7239 && TREE_VALUE (TREE_VALUE (t))
7240 && (TREE_CODE (TREE_VALUE (TREE_VALUE (t)))
7241 == IDENTIFIER_NODE))
7244 = tsubst_expr (TREE_CHAIN (TREE_VALUE (t)), args, complain,
7246 /*integral_constant_expression_p=*/false);
7247 if (chain != TREE_CHAIN (TREE_VALUE (t)))
7249 = tree_cons (NULL_TREE, TREE_VALUE (TREE_VALUE (t)),
7254 = tsubst_expr (TREE_VALUE (t), args, complain, in_decl,
7255 /*integral_constant_expression_p=*/false);
7257 q = &TREE_CHAIN (t);
7260 p = &TREE_CHAIN (t);
7263 cplus_decl_attributes (decl_p, late_attrs, attr_flags);
7267 /* Perform (or defer) access check for typedefs that were referenced
7268 from within the template TMPL code.
7269 This is a subroutine of instantiate_template and instantiate_class_template.
7270 TMPL is the template to consider and TARGS is the list of arguments of
7274 perform_typedefs_access_check (tree tmpl, tree targs)
7279 || (!CLASS_TYPE_P (tmpl)
7280 && TREE_CODE (tmpl) != FUNCTION_DECL))
7283 for (t = get_types_needing_access_check (tmpl); t; t = TREE_CHAIN (t))
7285 tree type_decl = TREE_PURPOSE (t);
7286 tree type_scope = TREE_VALUE (t);
7288 if (!type_decl || !type_scope || !CLASS_TYPE_P (type_scope))
7291 if (uses_template_parms (type_decl))
7292 type_decl = tsubst (type_decl, targs, tf_error, NULL_TREE);
7293 if (uses_template_parms (type_scope))
7294 type_scope = tsubst (type_scope, targs, tf_error, NULL_TREE);
7296 perform_or_defer_access_check (TYPE_BINFO (type_scope),
7297 type_decl, type_decl);
7302 instantiate_class_template (tree type)
7304 tree templ, args, pattern, t, member;
7309 if (type == error_mark_node)
7310 return error_mark_node;
7312 if (TYPE_BEING_DEFINED (type)
7313 || COMPLETE_TYPE_P (type)
7314 || dependent_type_p (type))
7317 /* Figure out which template is being instantiated. */
7318 templ = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
7319 gcc_assert (TREE_CODE (templ) == TEMPLATE_DECL);
7321 /* Determine what specialization of the original template to
7323 t = most_specialized_class (type, templ);
7324 if (t == error_mark_node)
7326 TYPE_BEING_DEFINED (type) = 1;
7327 return error_mark_node;
7331 /* This TYPE is actually an instantiation of a partial
7332 specialization. We replace the innermost set of ARGS with
7333 the arguments appropriate for substitution. For example,
7336 template <class T> struct S {};
7337 template <class T> struct S<T*> {};
7339 and supposing that we are instantiating S<int*>, ARGS will
7340 presently be {int*} -- but we need {int}. */
7341 pattern = TREE_TYPE (t);
7342 args = TREE_PURPOSE (t);
7346 pattern = TREE_TYPE (templ);
7347 args = CLASSTYPE_TI_ARGS (type);
7350 /* If the template we're instantiating is incomplete, then clearly
7351 there's nothing we can do. */
7352 if (!COMPLETE_TYPE_P (pattern))
7355 /* If we've recursively instantiated too many templates, stop. */
7356 if (! push_tinst_level (type))
7359 /* Now we're really doing the instantiation. Mark the type as in
7360 the process of being defined. */
7361 TYPE_BEING_DEFINED (type) = 1;
7363 /* We may be in the middle of deferred access check. Disable
7365 push_deferring_access_checks (dk_no_deferred);
7367 push_to_top_level ();
7369 SET_CLASSTYPE_INTERFACE_UNKNOWN (type);
7371 /* Set the input location to the most specialized template definition.
7372 This is needed if tsubsting causes an error. */
7373 typedecl = TYPE_MAIN_DECL (pattern);
7374 input_location = DECL_SOURCE_LOCATION (typedecl);
7376 TYPE_HAS_USER_CONSTRUCTOR (type) = TYPE_HAS_USER_CONSTRUCTOR (pattern);
7377 TYPE_HAS_NEW_OPERATOR (type) = TYPE_HAS_NEW_OPERATOR (pattern);
7378 TYPE_HAS_ARRAY_NEW_OPERATOR (type) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern);
7379 TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern);
7380 TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern);
7381 TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern);
7382 TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern);
7383 TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern);
7384 TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern);
7385 TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern);
7386 TYPE_PACKED (type) = TYPE_PACKED (pattern);
7387 TYPE_ALIGN (type) = TYPE_ALIGN (pattern);
7388 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);
7389 TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */
7390 if (ANON_AGGR_TYPE_P (pattern))
7391 SET_ANON_AGGR_TYPE_P (type);
7392 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern))
7394 CLASSTYPE_VISIBILITY_SPECIFIED (type) = 1;
7395 CLASSTYPE_VISIBILITY (type) = CLASSTYPE_VISIBILITY (pattern);
7398 pbinfo = TYPE_BINFO (pattern);
7400 /* We should never instantiate a nested class before its enclosing
7401 class; we need to look up the nested class by name before we can
7402 instantiate it, and that lookup should instantiate the enclosing
7404 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))
7405 || COMPLETE_TYPE_P (TYPE_CONTEXT (type))
7406 || TYPE_BEING_DEFINED (TYPE_CONTEXT (type)));
7408 base_list = NULL_TREE;
7409 if (BINFO_N_BASE_BINFOS (pbinfo))
7412 tree context = TYPE_CONTEXT (type);
7416 /* We must enter the scope containing the type, as that is where
7417 the accessibility of types named in dependent bases are
7419 pushed_scope = push_scope (context ? context : global_namespace);
7421 /* Substitute into each of the bases to determine the actual
7423 for (i = 0; BINFO_BASE_ITERATE (pbinfo, i, pbase_binfo); i++)
7426 tree access = BINFO_BASE_ACCESS (pbinfo, i);
7427 tree expanded_bases = NULL_TREE;
7430 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo)))
7433 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo),
7434 args, tf_error, NULL_TREE);
7435 if (expanded_bases == error_mark_node)
7438 len = TREE_VEC_LENGTH (expanded_bases);
7441 for (idx = 0; idx < len; idx++)
7444 /* Extract the already-expanded base class. */
7445 base = TREE_VEC_ELT (expanded_bases, idx);
7447 /* Substitute to figure out the base class. */
7448 base = tsubst (BINFO_TYPE (pbase_binfo), args, tf_error,
7451 if (base == error_mark_node)
7454 base_list = tree_cons (access, base, base_list);
7455 if (BINFO_VIRTUAL_P (pbase_binfo))
7456 TREE_TYPE (base_list) = integer_type_node;
7460 /* The list is now in reverse order; correct that. */
7461 base_list = nreverse (base_list);
7464 pop_scope (pushed_scope);
7466 /* Now call xref_basetypes to set up all the base-class
7468 xref_basetypes (type, base_list);
7470 apply_late_template_attributes (&type, TYPE_ATTRIBUTES (pattern),
7471 (int) ATTR_FLAG_TYPE_IN_PLACE,
7472 args, tf_error, NULL_TREE);
7474 /* Now that our base classes are set up, enter the scope of the
7475 class, so that name lookups into base classes, etc. will work
7476 correctly. This is precisely analogous to what we do in
7477 begin_class_definition when defining an ordinary non-template
7478 class, except we also need to push the enclosing classes. */
7479 push_nested_class (type);
7481 /* Now members are processed in the order of declaration. */
7482 for (member = CLASSTYPE_DECL_LIST (pattern);
7483 member; member = TREE_CHAIN (member))
7485 tree t = TREE_VALUE (member);
7487 if (TREE_PURPOSE (member))
7491 /* Build new CLASSTYPE_NESTED_UTDS. */
7494 bool class_template_p;
7496 class_template_p = (TREE_CODE (t) != ENUMERAL_TYPE
7497 && TYPE_LANG_SPECIFIC (t)
7498 && CLASSTYPE_IS_TEMPLATE (t));
7499 /* If the member is a class template, then -- even after
7500 substitution -- there may be dependent types in the
7501 template argument list for the class. We increment
7502 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
7503 that function will assume that no types are dependent
7504 when outside of a template. */
7505 if (class_template_p)
7506 ++processing_template_decl;
7507 newtag = tsubst (t, args, tf_error, NULL_TREE);
7508 if (class_template_p)
7509 --processing_template_decl;
7510 if (newtag == error_mark_node)
7513 if (TREE_CODE (newtag) != ENUMERAL_TYPE)
7515 tree name = TYPE_IDENTIFIER (t);
7517 if (class_template_p)
7518 /* Unfortunately, lookup_template_class sets
7519 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
7520 instantiation (i.e., for the type of a member
7521 template class nested within a template class.)
7522 This behavior is required for
7523 maybe_process_partial_specialization to work
7524 correctly, but is not accurate in this case;
7525 the TAG is not an instantiation of anything.
7526 (The corresponding TEMPLATE_DECL is an
7527 instantiation, but the TYPE is not.) */
7528 CLASSTYPE_USE_TEMPLATE (newtag) = 0;
7530 /* Now, we call pushtag to put this NEWTAG into the scope of
7531 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
7532 pushtag calling push_template_decl. We don't have to do
7533 this for enums because it will already have been done in
7536 SET_IDENTIFIER_TYPE_VALUE (name, newtag);
7537 pushtag (name, newtag, /*tag_scope=*/ts_current);
7540 else if (TREE_CODE (t) == FUNCTION_DECL
7541 || DECL_FUNCTION_TEMPLATE_P (t))
7543 /* Build new TYPE_METHODS. */
7546 if (TREE_CODE (t) == TEMPLATE_DECL)
7547 ++processing_template_decl;
7548 r = tsubst (t, args, tf_error, NULL_TREE);
7549 if (TREE_CODE (t) == TEMPLATE_DECL)
7550 --processing_template_decl;
7551 set_current_access_from_decl (r);
7552 finish_member_declaration (r);
7556 /* Build new TYPE_FIELDS. */
7557 if (TREE_CODE (t) == STATIC_ASSERT)
7560 tsubst_expr (STATIC_ASSERT_CONDITION (t), args,
7561 tf_warning_or_error, NULL_TREE,
7562 /*integral_constant_expression_p=*/true);
7563 finish_static_assert (condition,
7564 STATIC_ASSERT_MESSAGE (t),
7565 STATIC_ASSERT_SOURCE_LOCATION (t),
7568 else if (TREE_CODE (t) != CONST_DECL)
7572 /* The file and line for this declaration, to
7573 assist in error message reporting. Since we
7574 called push_tinst_level above, we don't need to
7576 input_location = DECL_SOURCE_LOCATION (t);
7578 if (TREE_CODE (t) == TEMPLATE_DECL)
7579 ++processing_template_decl;
7580 r = tsubst (t, args, tf_warning_or_error, NULL_TREE);
7581 if (TREE_CODE (t) == TEMPLATE_DECL)
7582 --processing_template_decl;
7583 if (TREE_CODE (r) == VAR_DECL)
7587 [t]he initialization (and any associated
7588 side-effects) of a static data member does
7589 not occur unless the static data member is
7590 itself used in a way that requires the
7591 definition of the static data member to
7594 Therefore, we do not substitute into the
7595 initialized for the static data member here. */
7596 finish_static_data_member_decl
7599 /*init_const_expr_p=*/false,
7600 /*asmspec_tree=*/NULL_TREE,
7602 if (DECL_INITIALIZED_IN_CLASS_P (r))
7603 check_static_variable_definition (r, TREE_TYPE (r));
7605 else if (TREE_CODE (r) == FIELD_DECL)
7607 /* Determine whether R has a valid type and can be
7608 completed later. If R is invalid, then it is
7609 replaced by error_mark_node so that it will not be
7610 added to TYPE_FIELDS. */
7611 tree rtype = TREE_TYPE (r);
7612 if (can_complete_type_without_circularity (rtype))
7613 complete_type (rtype);
7615 if (!COMPLETE_TYPE_P (rtype))
7617 cxx_incomplete_type_error (r, rtype);
7618 r = error_mark_node;
7622 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
7623 such a thing will already have been added to the field
7624 list by tsubst_enum in finish_member_declaration in the
7625 CLASSTYPE_NESTED_UTDS case above. */
7626 if (!(TREE_CODE (r) == TYPE_DECL
7627 && TREE_CODE (TREE_TYPE (r)) == ENUMERAL_TYPE
7628 && DECL_ARTIFICIAL (r)))
7630 set_current_access_from_decl (r);
7631 finish_member_declaration (r);
7638 if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t))
7640 /* Build new CLASSTYPE_FRIEND_CLASSES. */
7642 tree friend_type = t;
7643 bool adjust_processing_template_decl = false;
7645 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
7647 /* template <class T> friend class C; */
7648 friend_type = tsubst_friend_class (friend_type, args);
7649 adjust_processing_template_decl = true;
7651 else if (TREE_CODE (friend_type) == UNBOUND_CLASS_TEMPLATE)
7653 /* template <class T> friend class C::D; */
7654 friend_type = tsubst (friend_type, args,
7655 tf_warning_or_error, NULL_TREE);
7656 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
7657 friend_type = TREE_TYPE (friend_type);
7658 adjust_processing_template_decl = true;
7660 else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
7662 /* This could be either
7666 when dependent_type_p is false or
7668 template <class U> friend class T::C;
7671 friend_type = tsubst (friend_type, args,
7672 tf_warning_or_error, NULL_TREE);
7673 /* Bump processing_template_decl for correct
7674 dependent_type_p calculation. */
7675 ++processing_template_decl;
7676 if (dependent_type_p (friend_type))
7677 adjust_processing_template_decl = true;
7678 --processing_template_decl;
7680 else if (!CLASSTYPE_USE_TEMPLATE (friend_type)
7681 && hidden_name_p (TYPE_NAME (friend_type)))
7685 where C hasn't been declared yet. Let's lookup name
7686 from namespace scope directly, bypassing any name that
7687 come from dependent base class. */
7688 tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type));
7690 /* The call to xref_tag_from_type does injection for friend
7692 push_nested_namespace (ns);
7694 xref_tag_from_type (friend_type, NULL_TREE,
7695 /*tag_scope=*/ts_current);
7696 pop_nested_namespace (ns);
7698 else if (uses_template_parms (friend_type))
7699 /* friend class C<T>; */
7700 friend_type = tsubst (friend_type, args,
7701 tf_warning_or_error, NULL_TREE);
7706 where C is already declared or
7708 friend class C<int>;
7710 We don't have to do anything in these cases. */
7712 if (adjust_processing_template_decl)
7713 /* Trick make_friend_class into realizing that the friend
7714 we're adding is a template, not an ordinary class. It's
7715 important that we use make_friend_class since it will
7716 perform some error-checking and output cross-reference
7718 ++processing_template_decl;
7720 if (friend_type != error_mark_node)
7721 make_friend_class (type, friend_type, /*complain=*/false);
7723 if (adjust_processing_template_decl)
7724 --processing_template_decl;
7728 /* Build new DECL_FRIENDLIST. */
7731 /* The file and line for this declaration, to
7732 assist in error message reporting. Since we
7733 called push_tinst_level above, we don't need to
7735 input_location = DECL_SOURCE_LOCATION (t);
7737 if (TREE_CODE (t) == TEMPLATE_DECL)
7739 ++processing_template_decl;
7740 push_deferring_access_checks (dk_no_check);
7743 r = tsubst_friend_function (t, args);
7744 add_friend (type, r, /*complain=*/false);
7745 if (TREE_CODE (t) == TEMPLATE_DECL)
7747 pop_deferring_access_checks ();
7748 --processing_template_decl;
7754 /* Set the file and line number information to whatever is given for
7755 the class itself. This puts error messages involving generated
7756 implicit functions at a predictable point, and the same point
7757 that would be used for non-template classes. */
7758 input_location = DECL_SOURCE_LOCATION (typedecl);
7760 unreverse_member_declarations (type);
7761 finish_struct_1 (type);
7762 TYPE_BEING_DEFINED (type) = 0;
7764 /* Now that the class is complete, instantiate default arguments for
7765 any member functions. We don't do this earlier because the
7766 default arguments may reference members of the class. */
7767 if (!PRIMARY_TEMPLATE_P (templ))
7768 for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t))
7769 if (TREE_CODE (t) == FUNCTION_DECL
7770 /* Implicitly generated member functions will not have template
7771 information; they are not instantiations, but instead are
7772 created "fresh" for each instantiation. */
7773 && DECL_TEMPLATE_INFO (t))
7774 tsubst_default_arguments (t);
7776 /* Some typedefs referenced from within the template code need to be access
7777 checked at template instantiation time, i.e now. These types were
7778 added to the template at parsing time. Let's get those and perform
7779 the access checks then. */
7780 perform_typedefs_access_check (pattern, args);
7781 perform_deferred_access_checks ();
7782 pop_nested_class ();
7783 pop_from_top_level ();
7784 pop_deferring_access_checks ();
7787 /* The vtable for a template class can be emitted in any translation
7788 unit in which the class is instantiated. When there is no key
7789 method, however, finish_struct_1 will already have added TYPE to
7790 the keyed_classes list. */
7791 if (TYPE_CONTAINS_VPTR_P (type) && CLASSTYPE_KEY_METHOD (type))
7792 keyed_classes = tree_cons (NULL_TREE, type, keyed_classes);
7798 tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl)
7804 else if (TYPE_P (t))
7805 r = tsubst (t, args, complain, in_decl);
7808 r = tsubst_expr (t, args, complain, in_decl,
7809 /*integral_constant_expression_p=*/true);
7810 r = fold_non_dependent_expr (r);
7815 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
7816 NONTYPE_ARGUMENT_PACK. */
7819 make_fnparm_pack (tree spec_parm)
7821 /* Collect all of the extra "packed" parameters into an
7825 tree argpack = make_node (NONTYPE_ARGUMENT_PACK);
7826 tree argtypepack = cxx_make_type (TYPE_ARGUMENT_PACK);
7827 int i, len = list_length (spec_parm);
7829 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
7830 parmvec = make_tree_vec (len);
7831 parmtypevec = make_tree_vec (len);
7832 for (i = 0; i < len; i++, spec_parm = TREE_CHAIN (spec_parm))
7834 TREE_VEC_ELT (parmvec, i) = spec_parm;
7835 TREE_VEC_ELT (parmtypevec, i) = TREE_TYPE (spec_parm);
7838 /* Build the argument packs. */
7839 SET_ARGUMENT_PACK_ARGS (argpack, parmvec);
7840 SET_ARGUMENT_PACK_ARGS (argtypepack, parmtypevec);
7841 TREE_TYPE (argpack) = argtypepack;
7846 /* Substitute ARGS into T, which is an pack expansion
7847 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
7848 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
7849 (if only a partial substitution could be performed) or
7850 ERROR_MARK_NODE if there was an error. */
7852 tsubst_pack_expansion (tree t, tree args, tsubst_flags_t complain,
7856 tree pack, packs = NULL_TREE, unsubstituted_packs = NULL_TREE;
7857 tree first_arg_pack; int i, len = -1;
7860 bool very_local_specializations = false;
7862 gcc_assert (PACK_EXPANSION_P (t));
7863 pattern = PACK_EXPANSION_PATTERN (t);
7865 /* Determine the argument packs that will instantiate the parameter
7866 packs used in the expansion expression. While we're at it,
7867 compute the number of arguments to be expanded and make sure it
7869 for (pack = PACK_EXPANSION_PARAMETER_PACKS (t); pack;
7870 pack = TREE_CHAIN (pack))
7872 tree parm_pack = TREE_VALUE (pack);
7873 tree arg_pack = NULL_TREE;
7874 tree orig_arg = NULL_TREE;
7876 if (TREE_CODE (parm_pack) == PARM_DECL)
7878 arg_pack = retrieve_local_specialization (parm_pack);
7879 if (arg_pack == NULL_TREE)
7881 /* This can happen for a parameter name used later in a function
7882 declaration (such as in a late-specified return type). Just
7883 make a dummy decl, since it's only used for its type. */
7884 gcc_assert (cp_unevaluated_operand != 0);
7885 arg_pack = tsubst_decl (parm_pack, args, complain);
7886 arg_pack = make_fnparm_pack (arg_pack);
7891 int level, idx, levels;
7892 template_parm_level_and_index (parm_pack, &level, &idx);
7894 levels = TMPL_ARGS_DEPTH (args);
7895 if (level <= levels)
7896 arg_pack = TMPL_ARG (args, level, idx);
7899 orig_arg = arg_pack;
7900 if (arg_pack && TREE_CODE (arg_pack) == ARGUMENT_PACK_SELECT)
7901 arg_pack = ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack);
7903 if (arg_pack && !ARGUMENT_PACK_P (arg_pack))
7904 /* This can only happen if we forget to expand an argument
7905 pack somewhere else. Just return an error, silently. */
7907 result = make_tree_vec (1);
7908 TREE_VEC_ELT (result, 0) = error_mark_node;
7913 && TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack)) == 1
7914 && PACK_EXPANSION_P (TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg_pack), 0)))
7916 tree expansion = TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg_pack), 0);
7917 tree pattern = PACK_EXPANSION_PATTERN (expansion);
7918 if ((TYPE_P (pattern) && same_type_p (pattern, parm_pack))
7919 || (!TYPE_P (pattern) && cp_tree_equal (parm_pack, pattern)))
7920 /* The argument pack that the parameter maps to is just an
7921 expansion of the parameter itself, such as one would
7922 find in the implicit typedef of a class inside the
7923 class itself. Consider this parameter "unsubstituted",
7924 so that we will maintain the outer pack expansion. */
7925 arg_pack = NULL_TREE;
7931 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack));
7933 /* It's all-or-nothing with incomplete argument packs. */
7934 if (incomplete && !ARGUMENT_PACK_INCOMPLETE_P (arg_pack))
7935 return error_mark_node;
7937 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack))
7943 first_arg_pack = arg_pack;
7945 else if (len != my_len)
7947 if (TREE_CODE (t) == TYPE_PACK_EXPANSION)
7948 error ("mismatched argument pack lengths while expanding "
7952 error ("mismatched argument pack lengths while expanding "
7955 return error_mark_node;
7958 /* Keep track of the parameter packs and their corresponding
7960 packs = tree_cons (parm_pack, arg_pack, packs);
7961 TREE_TYPE (packs) = orig_arg;
7964 /* We can't substitute for this parameter pack. */
7965 unsubstituted_packs = tree_cons (TREE_PURPOSE (pack),
7967 unsubstituted_packs);
7970 /* We cannot expand this expansion expression, because we don't have
7971 all of the argument packs we need. Substitute into the pattern
7972 and return a PACK_EXPANSION_*. The caller will need to deal with
7974 if (unsubstituted_packs)
7977 if (TREE_CODE (t) == EXPR_PACK_EXPANSION)
7978 new_pat = tsubst_expr (pattern, args, complain, in_decl,
7979 /*integral_constant_expression_p=*/false);
7981 new_pat = tsubst (pattern, args, complain, in_decl);
7982 return make_pack_expansion (new_pat);
7985 /* We could not find any argument packs that work. */
7987 return error_mark_node;
7989 if (!local_specializations)
7991 /* We're in a late-specified return type, so we don't have a local
7992 specializations table. Create one for doing this expansion. */
7993 very_local_specializations = true;
7994 local_specializations = htab_create (37,
7995 hash_local_specialization,
7996 eq_local_specializations,
8000 /* For each argument in each argument pack, substitute into the
8002 result = make_tree_vec (len + incomplete);
8003 for (i = 0; i < len + incomplete; ++i)
8005 /* For parameter pack, change the substitution of the parameter
8006 pack to the ith argument in its argument pack, then expand
8008 for (pack = packs; pack; pack = TREE_CHAIN (pack))
8010 tree parm = TREE_PURPOSE (pack);
8012 if (TREE_CODE (parm) == PARM_DECL)
8014 /* Select the Ith argument from the pack. */
8015 tree arg = make_node (ARGUMENT_PACK_SELECT);
8016 ARGUMENT_PACK_SELECT_FROM_PACK (arg) = TREE_VALUE (pack);
8017 ARGUMENT_PACK_SELECT_INDEX (arg) = i;
8019 register_local_specialization (arg, parm);
8025 template_parm_level_and_index (parm, &level, &idx);
8029 /* Select the Ith argument from the pack. */
8030 value = make_node (ARGUMENT_PACK_SELECT);
8031 ARGUMENT_PACK_SELECT_FROM_PACK (value) = TREE_VALUE (pack);
8032 ARGUMENT_PACK_SELECT_INDEX (value) = i;
8035 /* Update the corresponding argument. */
8036 TMPL_ARG (args, level, idx) = value;
8040 /* Substitute into the PATTERN with the altered arguments. */
8041 if (TREE_CODE (t) == EXPR_PACK_EXPANSION)
8042 TREE_VEC_ELT (result, i) =
8043 tsubst_expr (pattern, args, complain, in_decl,
8044 /*integral_constant_expression_p=*/false);
8046 TREE_VEC_ELT (result, i) = tsubst (pattern, args, complain, in_decl);
8049 /* When we have incomplete argument packs, the last "expanded"
8050 result is itself a pack expansion, which allows us
8051 to deduce more arguments. */
8052 TREE_VEC_ELT (result, i) =
8053 make_pack_expansion (TREE_VEC_ELT (result, i));
8055 if (TREE_VEC_ELT (result, i) == error_mark_node)
8057 result = error_mark_node;
8062 /* Update ARGS to restore the substitution from parameter packs to
8063 their argument packs. */
8064 for (pack = packs; pack; pack = TREE_CHAIN (pack))
8066 tree parm = TREE_PURPOSE (pack);
8068 if (TREE_CODE (parm) == PARM_DECL)
8069 register_local_specialization (TREE_TYPE (pack), parm);
8073 template_parm_level_and_index (parm, &level, &idx);
8075 /* Update the corresponding argument. */
8076 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
8077 TREE_VEC_ELT (TREE_VEC_ELT (args, level -1 ), idx) =
8080 TREE_VEC_ELT (args, idx) = TREE_TYPE (pack);
8084 if (very_local_specializations)
8086 htab_delete (local_specializations);
8087 local_specializations = NULL;
8093 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
8094 TMPL. We do this using DECL_PARM_INDEX, which should work even with
8095 parameter packs; all parms generated from a function parameter pack will
8096 have the same DECL_PARM_INDEX. */
8099 get_pattern_parm (tree parm, tree tmpl)
8101 tree pattern = DECL_TEMPLATE_RESULT (tmpl);
8104 if (DECL_ARTIFICIAL (parm))
8106 for (patparm = DECL_ARGUMENTS (pattern);
8107 patparm; patparm = TREE_CHAIN (patparm))
8108 if (DECL_ARTIFICIAL (patparm)
8109 && DECL_NAME (parm) == DECL_NAME (patparm))
8114 patparm = FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl));
8115 patparm = chain_index (DECL_PARM_INDEX (parm)-1, patparm);
8116 gcc_assert (DECL_PARM_INDEX (patparm)
8117 == DECL_PARM_INDEX (parm));
8123 /* Substitute ARGS into the vector or list of template arguments T. */
8126 tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl)
8129 int len = TREE_VEC_LENGTH (t);
8130 int need_new = 0, i, expanded_len_adjust = 0, out;
8131 tree *elts = (tree *) alloca (len * sizeof (tree));
8133 for (i = 0; i < len; i++)
8135 tree orig_arg = TREE_VEC_ELT (t, i);
8138 if (TREE_CODE (orig_arg) == TREE_VEC)
8139 new_arg = tsubst_template_args (orig_arg, args, complain, in_decl);
8140 else if (PACK_EXPANSION_P (orig_arg))
8142 /* Substitute into an expansion expression. */
8143 new_arg = tsubst_pack_expansion (orig_arg, args, complain, in_decl);
8145 if (TREE_CODE (new_arg) == TREE_VEC)
8146 /* Add to the expanded length adjustment the number of
8147 expanded arguments. We subtract one from this
8148 measurement, because the argument pack expression
8149 itself is already counted as 1 in
8150 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
8151 the argument pack is empty. */
8152 expanded_len_adjust += TREE_VEC_LENGTH (new_arg) - 1;
8154 else if (ARGUMENT_PACK_P (orig_arg))
8156 /* Substitute into each of the arguments. */
8157 new_arg = TYPE_P (orig_arg)
8158 ? cxx_make_type (TREE_CODE (orig_arg))
8159 : make_node (TREE_CODE (orig_arg));
8161 SET_ARGUMENT_PACK_ARGS (
8163 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg),
8164 args, complain, in_decl));
8166 if (ARGUMENT_PACK_ARGS (new_arg) == error_mark_node)
8167 new_arg = error_mark_node;
8169 if (TREE_CODE (new_arg) == NONTYPE_ARGUMENT_PACK) {
8170 TREE_TYPE (new_arg) = tsubst (TREE_TYPE (orig_arg), args,
8172 TREE_CONSTANT (new_arg) = TREE_CONSTANT (orig_arg);
8174 if (TREE_TYPE (new_arg) == error_mark_node)
8175 new_arg = error_mark_node;
8179 new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl);
8181 if (new_arg == error_mark_node)
8182 return error_mark_node;
8185 if (new_arg != orig_arg)
8192 /* Make space for the expanded arguments coming from template
8194 t = make_tree_vec (len + expanded_len_adjust);
8195 for (i = 0, out = 0; i < len; i++)
8197 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t, i))
8198 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t, i)))
8199 && TREE_CODE (elts[i]) == TREE_VEC)
8203 /* Now expand the template argument pack "in place". */
8204 for (idx = 0; idx < TREE_VEC_LENGTH (elts[i]); idx++, out++)
8205 TREE_VEC_ELT (t, out) = TREE_VEC_ELT (elts[i], idx);
8209 TREE_VEC_ELT (t, out) = elts[i];
8217 /* Return the result of substituting ARGS into the template parameters
8218 given by PARMS. If there are m levels of ARGS and m + n levels of
8219 PARMS, then the result will contain n levels of PARMS. For
8220 example, if PARMS is `template <class T> template <class U>
8221 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
8222 result will be `template <int*, double, class V>'. */
8225 tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain)
8230 /* When substituting into a template, we must set
8231 PROCESSING_TEMPLATE_DECL as the template parameters may be
8232 dependent if they are based on one-another, and the dependency
8233 predicates are short-circuit outside of templates. */
8234 ++processing_template_decl;
8236 for (new_parms = &r;
8237 TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args);
8238 new_parms = &(TREE_CHAIN (*new_parms)),
8239 parms = TREE_CHAIN (parms))
8242 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms)));
8245 for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i)
8251 if (parms == error_mark_node)
8254 tuple = TREE_VEC_ELT (TREE_VALUE (parms), i);
8256 if (tuple == error_mark_node)
8259 default_value = TREE_PURPOSE (tuple);
8260 parm_decl = TREE_VALUE (tuple);
8262 parm_decl = tsubst (parm_decl, args, complain, NULL_TREE);
8263 if (TREE_CODE (parm_decl) == PARM_DECL
8264 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl), complain))
8265 parm_decl = error_mark_node;
8266 default_value = tsubst_template_arg (default_value, args,
8267 complain, NULL_TREE);
8269 tuple = build_tree_list (default_value, parm_decl);
8270 TREE_VEC_ELT (new_vec, i) = tuple;
8274 tree_cons (size_int (TMPL_PARMS_DEPTH (parms)
8275 - TMPL_ARGS_DEPTH (args)),
8276 new_vec, NULL_TREE);
8279 --processing_template_decl;
8284 /* Substitute the ARGS into the indicated aggregate (or enumeration)
8285 type T. If T is not an aggregate or enumeration type, it is
8286 handled as if by tsubst. IN_DECL is as for tsubst. If
8287 ENTERING_SCOPE is nonzero, T is the context for a template which
8288 we are presently tsubst'ing. Return the substituted value. */
8291 tsubst_aggr_type (tree t,
8293 tsubst_flags_t complain,
8300 switch (TREE_CODE (t))
8303 if (TYPE_PTRMEMFUNC_P (t))
8304 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl);
8306 /* Else fall through. */
8309 if (TYPE_TEMPLATE_INFO (t) && uses_template_parms (t))
8314 int saved_unevaluated_operand;
8315 int saved_inhibit_evaluation_warnings;
8317 /* In "sizeof(X<I>)" we need to evaluate "I". */
8318 saved_unevaluated_operand = cp_unevaluated_operand;
8319 cp_unevaluated_operand = 0;
8320 saved_inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
8321 c_inhibit_evaluation_warnings = 0;
8323 /* First, determine the context for the type we are looking
8325 context = TYPE_CONTEXT (t);
8328 context = tsubst_aggr_type (context, args, complain,
8329 in_decl, /*entering_scope=*/1);
8330 /* If context is a nested class inside a class template,
8331 it may still need to be instantiated (c++/33959). */
8332 if (TYPE_P (context))
8333 context = complete_type (context);
8336 /* Then, figure out what arguments are appropriate for the
8337 type we are trying to find. For example, given:
8339 template <class T> struct S;
8340 template <class T, class U> void f(T, U) { S<U> su; }
8342 and supposing that we are instantiating f<int, double>,
8343 then our ARGS will be {int, double}, but, when looking up
8344 S we only want {double}. */
8345 argvec = tsubst_template_args (TYPE_TI_ARGS (t), args,
8347 if (argvec == error_mark_node)
8348 r = error_mark_node;
8351 r = lookup_template_class (t, argvec, in_decl, context,
8352 entering_scope, complain);
8353 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
8356 cp_unevaluated_operand = saved_unevaluated_operand;
8357 c_inhibit_evaluation_warnings = saved_inhibit_evaluation_warnings;
8362 /* This is not a template type, so there's nothing to do. */
8366 return tsubst (t, args, complain, in_decl);
8370 /* Substitute into the default argument ARG (a default argument for
8371 FN), which has the indicated TYPE. */
8374 tsubst_default_argument (tree fn, tree type, tree arg)
8376 tree saved_class_ptr = NULL_TREE;
8377 tree saved_class_ref = NULL_TREE;
8379 /* This default argument came from a template. Instantiate the
8380 default argument here, not in tsubst. In the case of
8389 we must be careful to do name lookup in the scope of S<T>,
8390 rather than in the current class. */
8391 push_access_scope (fn);
8392 /* The "this" pointer is not valid in a default argument. */
8395 saved_class_ptr = current_class_ptr;
8396 cp_function_chain->x_current_class_ptr = NULL_TREE;
8397 saved_class_ref = current_class_ref;
8398 cp_function_chain->x_current_class_ref = NULL_TREE;
8401 push_deferring_access_checks(dk_no_deferred);
8402 /* The default argument expression may cause implicitly defined
8403 member functions to be synthesized, which will result in garbage
8404 collection. We must treat this situation as if we were within
8405 the body of function so as to avoid collecting live data on the
8408 arg = tsubst_expr (arg, DECL_TI_ARGS (fn),
8409 tf_warning_or_error, NULL_TREE,
8410 /*integral_constant_expression_p=*/false);
8412 pop_deferring_access_checks();
8414 /* Restore the "this" pointer. */
8417 cp_function_chain->x_current_class_ptr = saved_class_ptr;
8418 cp_function_chain->x_current_class_ref = saved_class_ref;
8421 /* Make sure the default argument is reasonable. */
8422 arg = check_default_argument (type, arg);
8424 pop_access_scope (fn);
8429 /* Substitute into all the default arguments for FN. */
8432 tsubst_default_arguments (tree fn)
8437 tmpl_args = DECL_TI_ARGS (fn);
8439 /* If this function is not yet instantiated, we certainly don't need
8440 its default arguments. */
8441 if (uses_template_parms (tmpl_args))
8444 for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
8446 arg = TREE_CHAIN (arg))
8447 if (TREE_PURPOSE (arg))
8448 TREE_PURPOSE (arg) = tsubst_default_argument (fn,
8450 TREE_PURPOSE (arg));
8453 /* Substitute the ARGS into the T, which is a _DECL. Return the
8454 result of the substitution. Issue error and warning messages under
8455 control of COMPLAIN. */
8458 tsubst_decl (tree t, tree args, tsubst_flags_t complain)
8460 location_t saved_loc;
8465 /* Set the filename and linenumber to improve error-reporting. */
8466 saved_loc = input_location;
8467 input_location = DECL_SOURCE_LOCATION (t);
8469 switch (TREE_CODE (t))
8473 /* We can get here when processing a member function template,
8474 member class template, or template template parameter. */
8475 tree decl = DECL_TEMPLATE_RESULT (t);
8480 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
8482 /* Template template parameter is treated here. */
8483 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8484 if (new_type == error_mark_node)
8485 return error_mark_node;
8488 TREE_CHAIN (r) = NULL_TREE;
8489 TREE_TYPE (r) = new_type;
8490 DECL_TEMPLATE_RESULT (r)
8491 = build_decl (DECL_SOURCE_LOCATION (decl),
8492 TYPE_DECL, DECL_NAME (decl), new_type);
8493 DECL_TEMPLATE_PARMS (r)
8494 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
8496 TYPE_NAME (new_type) = r;
8500 /* We might already have an instance of this template.
8501 The ARGS are for the surrounding class type, so the
8502 full args contain the tsubst'd args for the context,
8503 plus the innermost args from the template decl. */
8504 tmpl_args = DECL_CLASS_TEMPLATE_P (t)
8505 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t))
8506 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t));
8507 /* Because this is a template, the arguments will still be
8508 dependent, even after substitution. If
8509 PROCESSING_TEMPLATE_DECL is not set, the dependency
8510 predicates will short-circuit. */
8511 ++processing_template_decl;
8512 full_args = tsubst_template_args (tmpl_args, args,
8514 --processing_template_decl;
8515 if (full_args == error_mark_node)
8516 return error_mark_node;
8518 /* If this is a default template template argument,
8519 tsubst might not have changed anything. */
8520 if (full_args == tmpl_args)
8523 hash = hash_tmpl_and_args (t, full_args);
8524 spec = retrieve_specialization (t, full_args, hash);
8525 if (spec != NULL_TREE)
8531 /* Make a new template decl. It will be similar to the
8532 original, but will record the current template arguments.
8533 We also create a new function declaration, which is just
8534 like the old one, but points to this new template, rather
8535 than the old one. */
8537 gcc_assert (DECL_LANG_SPECIFIC (r) != 0);
8538 TREE_CHAIN (r) = NULL_TREE;
8540 DECL_TEMPLATE_INFO (r) = build_tree_list (t, args);
8542 if (TREE_CODE (decl) == TYPE_DECL)
8545 ++processing_template_decl;
8546 new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8547 --processing_template_decl;
8548 if (new_type == error_mark_node)
8549 return error_mark_node;
8551 TREE_TYPE (r) = new_type;
8552 CLASSTYPE_TI_TEMPLATE (new_type) = r;
8553 DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type);
8554 DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type);
8555 DECL_CONTEXT (r) = TYPE_CONTEXT (new_type);
8560 ++processing_template_decl;
8561 new_decl = tsubst (decl, args, complain, in_decl);
8562 --processing_template_decl;
8563 if (new_decl == error_mark_node)
8564 return error_mark_node;
8566 DECL_TEMPLATE_RESULT (r) = new_decl;
8567 DECL_TI_TEMPLATE (new_decl) = r;
8568 TREE_TYPE (r) = TREE_TYPE (new_decl);
8569 DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl);
8570 DECL_CONTEXT (r) = DECL_CONTEXT (new_decl);
8573 SET_DECL_IMPLICIT_INSTANTIATION (r);
8574 DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE;
8575 DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE;
8577 /* The template parameters for this new template are all the
8578 template parameters for the old template, except the
8579 outermost level of parameters. */
8580 DECL_TEMPLATE_PARMS (r)
8581 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
8584 if (PRIMARY_TEMPLATE_P (t))
8585 DECL_PRIMARY_TEMPLATE (r) = r;
8587 if (TREE_CODE (decl) != TYPE_DECL)
8588 /* Record this non-type partial instantiation. */
8589 register_specialization (r, t,
8590 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r)),
8598 tree argvec = NULL_TREE;
8606 /* Nobody should be tsubst'ing into non-template functions. */
8607 gcc_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE);
8609 if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL)
8614 /* If T is not dependent, just return it. We have to
8615 increment PROCESSING_TEMPLATE_DECL because
8616 value_dependent_expression_p assumes that nothing is
8617 dependent when PROCESSING_TEMPLATE_DECL is zero. */
8618 ++processing_template_decl;
8619 dependent_p = value_dependent_expression_p (t);
8620 --processing_template_decl;
8624 /* Calculate the most general template of which R is a
8625 specialization, and the complete set of arguments used to
8627 gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
8628 argvec = tsubst_template_args (DECL_TI_ARGS
8629 (DECL_TEMPLATE_RESULT (gen_tmpl)),
8630 args, complain, in_decl);
8632 /* Check to see if we already have this specialization. */
8633 hash = hash_tmpl_and_args (gen_tmpl, argvec);
8634 spec = retrieve_specialization (gen_tmpl, argvec, hash);
8642 /* We can see more levels of arguments than parameters if
8643 there was a specialization of a member template, like
8646 template <class T> struct S { template <class U> void f(); }
8647 template <> template <class U> void S<int>::f(U);
8649 Here, we'll be substituting into the specialization,
8650 because that's where we can find the code we actually
8651 want to generate, but we'll have enough arguments for
8652 the most general template.
8654 We also deal with the peculiar case:
8656 template <class T> struct S {
8657 template <class U> friend void f();
8659 template <class U> void f() {}
8661 template void f<double>();
8663 Here, the ARGS for the instantiation of will be {int,
8664 double}. But, we only need as many ARGS as there are
8665 levels of template parameters in CODE_PATTERN. We are
8666 careful not to get fooled into reducing the ARGS in
8669 template <class T> struct S { template <class U> void f(U); }
8670 template <class T> template <> void S<T>::f(int) {}
8672 which we can spot because the pattern will be a
8673 specialization in this case. */
8674 args_depth = TMPL_ARGS_DEPTH (args);
8676 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t)));
8677 if (args_depth > parms_depth
8678 && !DECL_TEMPLATE_SPECIALIZATION (t))
8679 args = get_innermost_template_args (args, parms_depth);
8683 /* This special case arises when we have something like this:
8685 template <class T> struct S {
8686 friend void f<int>(int, double);
8689 Here, the DECL_TI_TEMPLATE for the friend declaration
8690 will be an IDENTIFIER_NODE. We are being called from
8691 tsubst_friend_function, and we want only to create a
8692 new decl (R) with appropriate types so that we can call
8693 determine_specialization. */
8694 gen_tmpl = NULL_TREE;
8697 if (DECL_CLASS_SCOPE_P (t))
8699 if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t)))
8703 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
8704 complain, t, /*entering_scope=*/1);
8709 ctx = DECL_CONTEXT (t);
8711 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8712 if (type == error_mark_node)
8713 return error_mark_node;
8715 /* We do NOT check for matching decls pushed separately at this
8716 point, as they may not represent instantiations of this
8717 template, and in any case are considered separate under the
8720 DECL_USE_TEMPLATE (r) = 0;
8721 TREE_TYPE (r) = type;
8722 /* Clear out the mangled name and RTL for the instantiation. */
8723 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
8724 SET_DECL_RTL (r, NULL_RTX);
8725 /* Leave DECL_INITIAL set on deleted instantiations. */
8726 if (!DECL_DELETED_FN (r))
8727 DECL_INITIAL (r) = NULL_TREE;
8728 DECL_CONTEXT (r) = ctx;
8730 if (member && DECL_CONV_FN_P (r))
8731 /* Type-conversion operator. Reconstruct the name, in
8732 case it's the name of one of the template's parameters. */
8733 DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type));
8735 DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args,
8737 DECL_RESULT (r) = NULL_TREE;
8739 TREE_STATIC (r) = 0;
8740 TREE_PUBLIC (r) = TREE_PUBLIC (t);
8741 DECL_EXTERNAL (r) = 1;
8742 /* If this is an instantiation of a function with internal
8743 linkage, we already know what object file linkage will be
8744 assigned to the instantiation. */
8745 DECL_INTERFACE_KNOWN (r) = !TREE_PUBLIC (r);
8746 DECL_DEFER_OUTPUT (r) = 0;
8747 TREE_CHAIN (r) = NULL_TREE;
8748 DECL_PENDING_INLINE_INFO (r) = 0;
8749 DECL_PENDING_INLINE_P (r) = 0;
8750 DECL_SAVED_TREE (r) = NULL_TREE;
8751 DECL_STRUCT_FUNCTION (r) = NULL;
8753 /* We'll re-clone as appropriate in instantiate_template. */
8754 DECL_CLONED_FUNCTION (r) = NULL_TREE;
8756 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
8757 this in the special friend case mentioned above where
8758 GEN_TMPL is NULL. */
8761 DECL_TEMPLATE_INFO (r)
8762 = tree_cons (gen_tmpl, argvec, NULL_TREE);
8763 SET_DECL_IMPLICIT_INSTANTIATION (r);
8764 register_specialization (r, gen_tmpl, argvec, false, hash);
8766 /* We're not supposed to instantiate default arguments
8767 until they are called, for a template. But, for a
8770 template <class T> void f ()
8771 { extern void g(int i = T()); }
8773 we should do the substitution when the template is
8774 instantiated. We handle the member function case in
8775 instantiate_class_template since the default arguments
8776 might refer to other members of the class. */
8778 && !PRIMARY_TEMPLATE_P (gen_tmpl)
8779 && !uses_template_parms (argvec))
8780 tsubst_default_arguments (r);
8783 DECL_TEMPLATE_INFO (r) = NULL_TREE;
8785 /* Copy the list of befriending classes. */
8786 for (friends = &DECL_BEFRIENDING_CLASSES (r);
8788 friends = &TREE_CHAIN (*friends))
8790 *friends = copy_node (*friends);
8791 TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends),
8796 if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r))
8798 maybe_retrofit_in_chrg (r);
8799 if (DECL_CONSTRUCTOR_P (r))
8800 grok_ctor_properties (ctx, r);
8801 /* If this is an instantiation of a member template, clone it.
8802 If it isn't, that'll be handled by
8803 clone_constructors_and_destructors. */
8804 if (PRIMARY_TEMPLATE_P (gen_tmpl))
8805 clone_function_decl (r, /*update_method_vec_p=*/0);
8807 else if (IDENTIFIER_OPNAME_P (DECL_NAME (r))
8808 && !grok_op_properties (r, (complain & tf_error) != 0))
8809 return error_mark_node;
8811 if (DECL_FRIEND_P (t) && DECL_FRIEND_CONTEXT (t))
8812 SET_DECL_FRIEND_CONTEXT (r,
8813 tsubst (DECL_FRIEND_CONTEXT (t),
8814 args, complain, in_decl));
8816 /* Possibly limit visibility based on template args. */
8817 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
8818 if (DECL_VISIBILITY_SPECIFIED (t))
8820 DECL_VISIBILITY_SPECIFIED (r) = 0;
8822 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
8824 determine_visibility (r);
8826 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
8827 args, complain, in_decl);
8833 tree type = NULL_TREE;
8835 tree expanded_types = NULL_TREE;
8836 tree prev_r = NULL_TREE;
8837 tree first_r = NULL_TREE;
8839 if (FUNCTION_PARAMETER_PACK_P (t))
8841 /* If there is a local specialization that isn't a
8842 parameter pack, it means that we're doing a "simple"
8843 substitution from inside tsubst_pack_expansion. Just
8844 return the local specialization (which will be a single
8846 tree spec = retrieve_local_specialization (t);
8848 && TREE_CODE (spec) == PARM_DECL
8849 && TREE_CODE (TREE_TYPE (spec)) != TYPE_PACK_EXPANSION)
8852 /* Expand the TYPE_PACK_EXPANSION that provides the types for
8853 the parameters in this function parameter pack. */
8854 expanded_types = tsubst_pack_expansion (TREE_TYPE (t), args,
8856 if (TREE_CODE (expanded_types) == TREE_VEC)
8858 len = TREE_VEC_LENGTH (expanded_types);
8860 /* Zero-length parameter packs are boring. Just substitute
8863 return tsubst (TREE_CHAIN (t), args, complain,
8868 /* All we did was update the type. Make a note of that. */
8869 type = expanded_types;
8870 expanded_types = NULL_TREE;
8874 /* Loop through all of the parameter's we'll build. When T is
8875 a function parameter pack, LEN is the number of expanded
8876 types in EXPANDED_TYPES; otherwise, LEN is 1. */
8878 for (i = 0; i < len; ++i)
8882 if (DECL_TEMPLATE_PARM_P (t))
8883 SET_DECL_TEMPLATE_PARM_P (r);
8885 /* An argument of a function parameter pack is not a parameter
8887 FUNCTION_PARAMETER_PACK_P (r) = false;
8890 /* We're on the Ith parameter of the function parameter
8893 /* Get the Ith type. */
8894 type = TREE_VEC_ELT (expanded_types, i);
8897 /* Rename the parameter to include the index. */
8899 make_ith_pack_parameter_name (DECL_NAME (r), i);
8902 /* We're dealing with a normal parameter. */
8903 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8905 type = type_decays_to (type);
8906 TREE_TYPE (r) = type;
8907 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
8909 if (DECL_INITIAL (r))
8911 if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
8912 DECL_INITIAL (r) = TREE_TYPE (r);
8914 DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
8918 DECL_CONTEXT (r) = NULL_TREE;
8920 if (!DECL_TEMPLATE_PARM_P (r))
8921 DECL_ARG_TYPE (r) = type_passed_as (type);
8923 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
8924 args, complain, in_decl);
8926 /* Keep track of the first new parameter we
8927 generate. That's what will be returned to the
8932 /* Build a proper chain of parameters when substituting
8933 into a function parameter pack. */
8935 TREE_CHAIN (prev_r) = r;
8939 TREE_CHAIN (r) = tsubst (TREE_CHAIN (t), args,
8940 complain, TREE_CHAIN (t));
8942 /* FIRST_R contains the start of the chain we've built. */
8952 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
8953 if (type == error_mark_node)
8954 return error_mark_node;
8955 TREE_TYPE (r) = type;
8956 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
8958 /* DECL_INITIAL gives the number of bits in a bit-field. */
8960 = tsubst_expr (DECL_INITIAL (t), args,
8962 /*integral_constant_expression_p=*/true);
8963 /* We don't have to set DECL_CONTEXT here; it is set by
8964 finish_member_declaration. */
8965 TREE_CHAIN (r) = NULL_TREE;
8966 if (VOID_TYPE_P (type))
8967 error ("instantiation of %q+D as type %qT", r, type);
8969 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
8970 args, complain, in_decl);
8975 /* We reach here only for member using decls. */
8976 if (DECL_DEPENDENT_P (t))
8978 r = do_class_using_decl
8979 (tsubst_copy (USING_DECL_SCOPE (t), args, complain, in_decl),
8980 tsubst_copy (DECL_NAME (t), args, complain, in_decl));
8982 r = error_mark_node;
8985 TREE_PROTECTED (r) = TREE_PROTECTED (t);
8986 TREE_PRIVATE (r) = TREE_PRIVATE (t);
8992 TREE_CHAIN (r) = NULL_TREE;
8999 tree argvec = NULL_TREE;
9000 tree gen_tmpl = NULL_TREE;
9002 tree tmpl = NULL_TREE;
9004 tree type = NULL_TREE;
9007 if (TREE_CODE (t) == TYPE_DECL
9008 && t == TYPE_MAIN_DECL (TREE_TYPE (t)))
9010 /* If this is the canonical decl, we don't have to
9011 mess with instantiations, and often we can't (for
9012 typename, template type parms and such). Note that
9013 TYPE_NAME is not correct for the above test if
9014 we've copied the type for a typedef. */
9015 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
9016 if (type == error_mark_node)
9017 return error_mark_node;
9018 r = TYPE_NAME (type);
9022 /* Check to see if we already have the specialization we
9025 if (DECL_CLASS_SCOPE_P (t) || DECL_NAMESPACE_SCOPE_P (t))
9027 /* T is a static data member or namespace-scope entity.
9028 We have to substitute into namespace-scope variables
9029 (even though such entities are never templates) because
9032 template <class T> void f() { extern T t; }
9034 where the entity referenced is not known until
9035 instantiation time. */
9037 ctx = DECL_CONTEXT (t);
9038 if (DECL_CLASS_SCOPE_P (t))
9040 ctx = tsubst_aggr_type (ctx, args,
9042 in_decl, /*entering_scope=*/1);
9043 /* If CTX is unchanged, then T is in fact the
9044 specialization we want. That situation occurs when
9045 referencing a static data member within in its own
9046 class. We can use pointer equality, rather than
9047 same_type_p, because DECL_CONTEXT is always
9049 if (ctx == DECL_CONTEXT (t))
9055 tmpl = DECL_TI_TEMPLATE (t);
9056 gen_tmpl = most_general_template (tmpl);
9057 argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl);
9058 hash = hash_tmpl_and_args (gen_tmpl, argvec);
9059 spec = retrieve_specialization (gen_tmpl, argvec, hash);
9064 /* A local variable. */
9066 /* Subsequent calls to pushdecl will fill this in. */
9068 spec = retrieve_local_specialization (t);
9070 /* If we already have the specialization we need, there is
9071 nothing more to do. */
9078 /* Create a new node for the specialization we need. */
9080 if (type == NULL_TREE)
9081 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
9082 if (TREE_CODE (r) == VAR_DECL)
9084 /* Even if the original location is out of scope, the
9085 newly substituted one is not. */
9086 DECL_DEAD_FOR_LOCAL (r) = 0;
9087 DECL_INITIALIZED_P (r) = 0;
9088 DECL_TEMPLATE_INSTANTIATED (r) = 0;
9089 if (type == error_mark_node)
9090 return error_mark_node;
9091 if (TREE_CODE (type) == FUNCTION_TYPE)
9093 /* It may seem that this case cannot occur, since:
9098 declares a function, not a variable. However:
9101 template <typename T> void g() { T t; }
9102 template void g<f>();
9104 is an attempt to declare a variable with function
9106 error ("variable %qD has function type",
9107 /* R is not yet sufficiently initialized, so we
9108 just use its name. */
9110 return error_mark_node;
9112 type = complete_type (type);
9113 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
9114 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t);
9115 type = check_var_type (DECL_NAME (r), type);
9117 if (DECL_HAS_VALUE_EXPR_P (t))
9119 tree ve = DECL_VALUE_EXPR (t);
9120 ve = tsubst_expr (ve, args, complain, in_decl,
9121 /*constant_expression_p=*/false);
9122 SET_DECL_VALUE_EXPR (r, ve);
9125 else if (DECL_SELF_REFERENCE_P (t))
9126 SET_DECL_SELF_REFERENCE_P (r);
9127 TREE_TYPE (r) = type;
9128 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
9129 DECL_CONTEXT (r) = ctx;
9130 /* Clear out the mangled name and RTL for the instantiation. */
9131 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
9132 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
9133 SET_DECL_RTL (r, NULL_RTX);
9134 /* The initializer must not be expanded until it is required;
9136 DECL_INITIAL (r) = NULL_TREE;
9137 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
9138 SET_DECL_RTL (r, NULL_RTX);
9139 DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0;
9140 if (TREE_CODE (r) == VAR_DECL)
9142 /* Possibly limit visibility based on template args. */
9143 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
9144 if (DECL_VISIBILITY_SPECIFIED (t))
9146 DECL_VISIBILITY_SPECIFIED (r) = 0;
9148 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
9150 determine_visibility (r);
9152 /* Preserve a typedef that names a type. */
9153 else if (TREE_CODE (r) == TYPE_DECL
9154 && DECL_ORIGINAL_TYPE (t)
9155 && type != error_mark_node)
9157 DECL_ORIGINAL_TYPE (r) = tsubst (DECL_ORIGINAL_TYPE (t),
9158 args, complain, in_decl);
9159 TREE_TYPE (r) = type = build_variant_type_copy (type);
9160 TYPE_NAME (type) = r;
9165 /* A static data member declaration is always marked
9166 external when it is declared in-class, even if an
9167 initializer is present. We mimic the non-template
9169 DECL_EXTERNAL (r) = 1;
9171 register_specialization (r, gen_tmpl, argvec, false, hash);
9172 DECL_TEMPLATE_INFO (r) = tree_cons (tmpl, argvec, NULL_TREE);
9173 SET_DECL_IMPLICIT_INSTANTIATION (r);
9175 else if (cp_unevaluated_operand)
9177 /* We're substituting this var in a decltype outside of its
9178 scope, such as for a lambda return type. Don't add it to
9179 local_specializations, do perform auto deduction. */
9180 tree auto_node = type_uses_auto (type);
9182 = tsubst_expr (DECL_INITIAL (t), args, complain, in_decl,
9183 /*constant_expression_p=*/false);
9185 if (auto_node && init && describable_type (init))
9187 type = do_auto_deduction (type, init, auto_node);
9188 TREE_TYPE (r) = type;
9192 register_local_specialization (r, t);
9194 TREE_CHAIN (r) = NULL_TREE;
9196 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r),
9197 (int) ATTR_FLAG_TYPE_IN_PLACE,
9198 args, complain, in_decl);
9207 /* Restore the file and line information. */
9208 input_location = saved_loc;
9213 /* Substitute into the ARG_TYPES of a function type. */
9216 tsubst_arg_types (tree arg_types,
9218 tsubst_flags_t complain,
9221 tree remaining_arg_types;
9222 tree type = NULL_TREE;
9224 tree expanded_args = NULL_TREE;
9227 if (!arg_types || arg_types == void_list_node)
9230 remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types),
9231 args, complain, in_decl);
9232 if (remaining_arg_types == error_mark_node)
9233 return error_mark_node;
9235 if (PACK_EXPANSION_P (TREE_VALUE (arg_types)))
9237 /* For a pack expansion, perform substitution on the
9238 entire expression. Later on, we'll handle the arguments
9240 expanded_args = tsubst_pack_expansion (TREE_VALUE (arg_types),
9241 args, complain, in_decl);
9243 if (TREE_CODE (expanded_args) == TREE_VEC)
9244 /* So that we'll spin through the parameters, one by one. */
9245 i = TREE_VEC_LENGTH (expanded_args);
9248 /* We only partially substituted into the parameter
9249 pack. Our type is TYPE_PACK_EXPANSION. */
9250 type = expanded_args;
9251 expanded_args = NULL_TREE;
9259 type = TREE_VEC_ELT (expanded_args, i);
9261 type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
9263 if (type == error_mark_node)
9264 return error_mark_node;
9265 if (VOID_TYPE_P (type))
9267 if (complain & tf_error)
9269 error ("invalid parameter type %qT", type);
9271 error ("in declaration %q+D", in_decl);
9273 return error_mark_node;
9276 /* Do array-to-pointer, function-to-pointer conversion, and ignore
9277 top-level qualifiers as required. */
9278 type = TYPE_MAIN_VARIANT (type_decays_to (type));
9280 /* We do not substitute into default arguments here. The standard
9281 mandates that they be instantiated only when needed, which is
9282 done in build_over_call. */
9283 default_arg = TREE_PURPOSE (arg_types);
9285 if (default_arg && TREE_CODE (default_arg) == DEFAULT_ARG)
9287 /* We've instantiated a template before its default arguments
9288 have been parsed. This can happen for a nested template
9289 class, and is not an error unless we require the default
9290 argument in a call of this function. */
9291 remaining_arg_types =
9292 tree_cons (default_arg, type, remaining_arg_types);
9293 VEC_safe_push (tree, gc, DEFARG_INSTANTIATIONS (default_arg),
9294 remaining_arg_types);
9297 remaining_arg_types =
9298 hash_tree_cons (default_arg, type, remaining_arg_types);
9301 return remaining_arg_types;
9304 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
9305 *not* handle the exception-specification for FNTYPE, because the
9306 initial substitution of explicitly provided template parameters
9307 during argument deduction forbids substitution into the
9308 exception-specification:
9312 All references in the function type of the function template to the
9313 corresponding template parameters are replaced by the specified tem-
9314 plate argument values. If a substitution in a template parameter or
9315 in the function type of the function template results in an invalid
9316 type, type deduction fails. [Note: The equivalent substitution in
9317 exception specifications is done only when the function is instanti-
9318 ated, at which point a program is ill-formed if the substitution
9319 results in an invalid type.] */
9322 tsubst_function_type (tree t,
9324 tsubst_flags_t complain,
9331 /* The TYPE_CONTEXT is not used for function/method types. */
9332 gcc_assert (TYPE_CONTEXT (t) == NULL_TREE);
9334 /* Substitute the return type. */
9335 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
9336 if (return_type == error_mark_node)
9337 return error_mark_node;
9338 /* The standard does not presently indicate that creation of a
9339 function type with an invalid return type is a deduction failure.
9340 However, that is clearly analogous to creating an array of "void"
9341 or a reference to a reference. This is core issue #486. */
9342 if (TREE_CODE (return_type) == ARRAY_TYPE
9343 || TREE_CODE (return_type) == FUNCTION_TYPE)
9345 if (complain & tf_error)
9347 if (TREE_CODE (return_type) == ARRAY_TYPE)
9348 error ("function returning an array");
9350 error ("function returning a function");
9352 return error_mark_node;
9355 /* Substitute the argument types. */
9356 arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args,
9358 if (arg_types == error_mark_node)
9359 return error_mark_node;
9361 /* Construct a new type node and return it. */
9362 if (TREE_CODE (t) == FUNCTION_TYPE)
9363 fntype = build_function_type (return_type, arg_types);
9366 tree r = TREE_TYPE (TREE_VALUE (arg_types));
9367 if (! MAYBE_CLASS_TYPE_P (r))
9371 Type deduction may fail for any of the following
9374 -- Attempting to create "pointer to member of T" when T
9375 is not a class type. */
9376 if (complain & tf_error)
9377 error ("creating pointer to member function of non-class type %qT",
9379 return error_mark_node;
9382 fntype = build_method_type_directly (r, return_type,
9383 TREE_CHAIN (arg_types));
9385 fntype = cp_build_qualified_type_real (fntype, TYPE_QUALS (t), complain);
9386 fntype = cp_build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t));
9391 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
9392 ARGS into that specification, and return the substituted
9393 specification. If there is no specification, return NULL_TREE. */
9396 tsubst_exception_specification (tree fntype,
9398 tsubst_flags_t complain,
9404 specs = TYPE_RAISES_EXCEPTIONS (fntype);
9405 new_specs = NULL_TREE;
9408 if (! TREE_VALUE (specs))
9415 tree expanded_specs = NULL_TREE;
9417 if (PACK_EXPANSION_P (TREE_VALUE (specs)))
9419 /* Expand the pack expansion type. */
9420 expanded_specs = tsubst_pack_expansion (TREE_VALUE (specs),
9424 if (expanded_specs == error_mark_node)
9425 return error_mark_node;
9426 else if (TREE_CODE (expanded_specs) == TREE_VEC)
9427 len = TREE_VEC_LENGTH (expanded_specs);
9430 /* We're substituting into a member template, so
9431 we got a TYPE_PACK_EXPANSION back. Add that
9432 expansion and move on. */
9433 gcc_assert (TREE_CODE (expanded_specs)
9434 == TYPE_PACK_EXPANSION);
9435 new_specs = add_exception_specifier (new_specs,
9438 specs = TREE_CHAIN (specs);
9443 for (i = 0; i < len; ++i)
9446 spec = TREE_VEC_ELT (expanded_specs, i);
9448 spec = tsubst (TREE_VALUE (specs), args, complain, in_decl);
9449 if (spec == error_mark_node)
9451 new_specs = add_exception_specifier (new_specs, spec,
9455 specs = TREE_CHAIN (specs);
9461 /* Take the tree structure T and replace template parameters used
9462 therein with the argument vector ARGS. IN_DECL is an associated
9463 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
9464 Issue error and warning messages under control of COMPLAIN. Note
9465 that we must be relatively non-tolerant of extensions here, in
9466 order to preserve conformance; if we allow substitutions that
9467 should not be allowed, we may allow argument deductions that should
9468 not succeed, and therefore report ambiguous overload situations
9469 where there are none. In theory, we could allow the substitution,
9470 but indicate that it should have failed, and allow our caller to
9471 make sure that the right thing happens, but we don't try to do this
9474 This function is used for dealing with types, decls and the like;
9475 for expressions, use tsubst_expr or tsubst_copy. */
9478 tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
9482 if (t == NULL_TREE || t == error_mark_node
9483 || t == integer_type_node
9484 || t == void_type_node
9485 || t == char_type_node
9486 || t == unknown_type_node
9487 || TREE_CODE (t) == NAMESPACE_DECL)
9491 return tsubst_decl (t, args, complain);
9493 if (args == NULL_TREE)
9496 if (TREE_CODE (t) == IDENTIFIER_NODE)
9497 type = IDENTIFIER_TYPE_VALUE (t);
9499 type = TREE_TYPE (t);
9501 gcc_assert (type != unknown_type_node);
9503 /* Reuse typedefs. We need to do this to handle dependent attributes,
9504 such as attribute aligned. */
9507 && TYPE_NAME (t) != TYPE_MAIN_DECL (t))
9509 tree decl = TYPE_NAME (t);
9511 if (DECL_CLASS_SCOPE_P (decl)
9512 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl))
9513 && uses_template_parms (DECL_CONTEXT (decl)))
9515 tree tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
9516 tree gen_args = tsubst (DECL_TI_ARGS (decl), args, complain, in_decl);
9517 r = retrieve_specialization (tmpl, gen_args, 0);
9519 else if (DECL_FUNCTION_SCOPE_P (decl)
9520 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl))
9521 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl))))
9522 r = retrieve_local_specialization (decl);
9524 /* The typedef is from a non-template context. */
9530 r = cp_build_qualified_type_real
9531 (r, cp_type_quals (t) | cp_type_quals (r),
9532 complain | tf_ignore_bad_quals);
9535 /* Else we must be instantiating the typedef, so fall through. */
9539 && TREE_CODE (t) != TYPENAME_TYPE
9540 && TREE_CODE (t) != IDENTIFIER_NODE
9541 && TREE_CODE (t) != FUNCTION_TYPE
9542 && TREE_CODE (t) != METHOD_TYPE)
9543 type = tsubst (type, args, complain, in_decl);
9544 if (type == error_mark_node)
9545 return error_mark_node;
9547 switch (TREE_CODE (t))
9552 return tsubst_aggr_type (t, args, complain, in_decl,
9553 /*entering_scope=*/0);
9556 case IDENTIFIER_NODE:
9568 if (t == integer_type_node)
9571 if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
9572 && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
9576 tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);
9578 max = tsubst_expr (omax, args, complain, in_decl,
9579 /*integral_constant_expression_p=*/false);
9581 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
9583 if (TREE_CODE (max) == NOP_EXPR
9584 && TREE_SIDE_EFFECTS (omax)
9585 && !TREE_TYPE (max))
9586 TREE_TYPE (max) = TREE_TYPE (TREE_OPERAND (max, 0));
9588 max = fold_decl_constant_value (max);
9590 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
9591 with TREE_SIDE_EFFECTS that indicates this is not an integral
9592 constant expression. */
9593 if (processing_template_decl
9594 && TREE_SIDE_EFFECTS (omax) && TREE_CODE (omax) == NOP_EXPR)
9596 gcc_assert (TREE_CODE (max) == NOP_EXPR);
9597 TREE_SIDE_EFFECTS (max) = 1;
9600 if (TREE_CODE (max) != INTEGER_CST
9601 && !at_function_scope_p ()
9602 && !TREE_SIDE_EFFECTS (max)
9603 && !value_dependent_expression_p (max))
9605 if (complain & tf_error)
9606 error ("array bound is not an integer constant");
9607 return error_mark_node;
9612 Type deduction may fail for any of the following
9615 Attempting to create an array with a size that is
9616 zero or negative. */
9617 if (integer_zerop (max) && !(complain & tf_error))
9618 /* We must fail if performing argument deduction (as
9619 indicated by the state of complain), so that
9620 another substitution can be found. */
9621 return error_mark_node;
9622 else if (TREE_CODE (max) == INTEGER_CST
9623 && INT_CST_LT (max, integer_zero_node))
9625 if (complain & tf_error)
9626 error ("creating array with negative size (%qE)", max);
9628 return error_mark_node;
9631 return compute_array_index_type (NULL_TREE, max);
9634 case TEMPLATE_TYPE_PARM:
9635 case TEMPLATE_TEMPLATE_PARM:
9636 case BOUND_TEMPLATE_TEMPLATE_PARM:
9637 case TEMPLATE_PARM_INDEX:
9642 tree arg = NULL_TREE;
9646 gcc_assert (TREE_VEC_LENGTH (args) > 0);
9647 template_parm_level_and_index (t, &level, &idx);
9649 levels = TMPL_ARGS_DEPTH (args);
9650 if (level <= levels)
9652 arg = TMPL_ARG (args, level, idx);
9654 if (arg && TREE_CODE (arg) == ARGUMENT_PACK_SELECT)
9655 /* See through ARGUMENT_PACK_SELECT arguments. */
9656 arg = ARGUMENT_PACK_SELECT_ARG (arg);
9659 if (arg == error_mark_node)
9660 return error_mark_node;
9661 else if (arg != NULL_TREE)
9663 if (ARGUMENT_PACK_P (arg))
9664 /* If ARG is an argument pack, we don't actually want to
9665 perform a substitution here, because substitutions
9666 for argument packs are only done
9667 element-by-element. We can get to this point when
9668 substituting the type of a non-type template
9669 parameter pack, when that type actually contains
9670 template parameter packs from an outer template, e.g.,
9672 template<typename... Types> struct A {
9673 template<Types... Values> struct B { };
9677 if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
9680 gcc_assert (TYPE_P (arg));
9682 /* cv-quals from the template are discarded when
9683 substituting in a function or reference type. */
9684 if (TREE_CODE (arg) == FUNCTION_TYPE
9685 || TREE_CODE (arg) == METHOD_TYPE
9686 || TREE_CODE (arg) == REFERENCE_TYPE)
9687 quals = cp_type_quals (arg);
9689 quals = cp_type_quals (arg) | cp_type_quals (t);
9691 return cp_build_qualified_type_real
9692 (arg, quals, complain | tf_ignore_bad_quals);
9694 else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
9696 /* We are processing a type constructed from a
9697 template template parameter. */
9698 tree argvec = tsubst (TYPE_TI_ARGS (t),
9699 args, complain, in_decl);
9700 if (argvec == error_mark_node)
9701 return error_mark_node;
9703 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
9704 are resolving nested-types in the signature of a
9705 member function templates. Otherwise ARG is a
9706 TEMPLATE_DECL and is the real template to be
9708 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
9709 arg = TYPE_NAME (arg);
9711 r = lookup_template_class (arg,
9714 /*entering_scope=*/0,
9716 return cp_build_qualified_type_real
9717 (r, TYPE_QUALS (t), complain);
9720 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
9725 /* This can happen during the attempted tsubst'ing in
9726 unify. This means that we don't yet have any information
9727 about the template parameter in question. */
9730 /* If we get here, we must have been looking at a parm for a
9731 more deeply nested template. Make a new version of this
9732 template parameter, but with a lower level. */
9733 switch (TREE_CODE (t))
9735 case TEMPLATE_TYPE_PARM:
9736 case TEMPLATE_TEMPLATE_PARM:
9737 case BOUND_TEMPLATE_TEMPLATE_PARM:
9738 if (cp_type_quals (t))
9740 r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
9741 r = cp_build_qualified_type_real
9742 (r, cp_type_quals (t),
9743 complain | (TREE_CODE (t) == TEMPLATE_TYPE_PARM
9744 ? tf_ignore_bad_quals : 0));
9749 TEMPLATE_TYPE_PARM_INDEX (r)
9750 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t),
9751 r, levels, args, complain);
9752 TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r);
9753 TYPE_MAIN_VARIANT (r) = r;
9754 TYPE_POINTER_TO (r) = NULL_TREE;
9755 TYPE_REFERENCE_TO (r) = NULL_TREE;
9757 if (TREE_CODE (r) == TEMPLATE_TEMPLATE_PARM)
9758 /* We have reduced the level of the template
9759 template parameter, but not the levels of its
9760 template parameters, so canonical_type_parameter
9761 will not be able to find the canonical template
9762 template parameter for this level. Thus, we
9763 require structural equality checking to compare
9764 TEMPLATE_TEMPLATE_PARMs. */
9765 SET_TYPE_STRUCTURAL_EQUALITY (r);
9766 else if (TYPE_STRUCTURAL_EQUALITY_P (t))
9767 SET_TYPE_STRUCTURAL_EQUALITY (r);
9769 TYPE_CANONICAL (r) = canonical_type_parameter (r);
9771 if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
9773 tree argvec = tsubst (TYPE_TI_ARGS (t), args,
9775 if (argvec == error_mark_node)
9776 return error_mark_node;
9778 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r)
9779 = tree_cons (TYPE_TI_TEMPLATE (t), argvec, NULL_TREE);
9784 case TEMPLATE_PARM_INDEX:
9785 r = reduce_template_parm_level (t, type, levels, args, complain);
9797 tree purpose, value, chain;
9799 if (t == void_list_node)
9802 purpose = TREE_PURPOSE (t);
9805 purpose = tsubst (purpose, args, complain, in_decl);
9806 if (purpose == error_mark_node)
9807 return error_mark_node;
9809 value = TREE_VALUE (t);
9812 value = tsubst (value, args, complain, in_decl);
9813 if (value == error_mark_node)
9814 return error_mark_node;
9816 chain = TREE_CHAIN (t);
9817 if (chain && chain != void_type_node)
9819 chain = tsubst (chain, args, complain, in_decl);
9820 if (chain == error_mark_node)
9821 return error_mark_node;
9823 if (purpose == TREE_PURPOSE (t)
9824 && value == TREE_VALUE (t)
9825 && chain == TREE_CHAIN (t))
9827 return hash_tree_cons (purpose, value, chain);
9831 /* We should never be tsubsting a binfo. */
9835 /* A vector of template arguments. */
9837 return tsubst_template_args (t, args, complain, in_decl);
9840 case REFERENCE_TYPE:
9842 enum tree_code code;
9844 if (type == TREE_TYPE (t) && TREE_CODE (type) != METHOD_TYPE)
9847 code = TREE_CODE (t);
9852 Type deduction may fail for any of the following
9855 -- Attempting to create a pointer to reference type.
9856 -- Attempting to create a reference to a reference type or
9857 a reference to void.
9859 Core issue 106 says that creating a reference to a reference
9860 during instantiation is no longer a cause for failure. We
9861 only enforce this check in strict C++98 mode. */
9862 if ((TREE_CODE (type) == REFERENCE_TYPE
9863 && (((cxx_dialect == cxx98) && flag_iso) || code != REFERENCE_TYPE))
9864 || (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE))
9866 static location_t last_loc;
9868 /* We keep track of the last time we issued this error
9869 message to avoid spewing a ton of messages during a
9870 single bad template instantiation. */
9871 if (complain & tf_error
9872 && last_loc != input_location)
9874 if (TREE_CODE (type) == VOID_TYPE)
9875 error ("forming reference to void");
9877 error ("forming %s to reference type %qT",
9878 (code == POINTER_TYPE) ? "pointer" : "reference",
9880 last_loc = input_location;
9883 return error_mark_node;
9885 else if (code == POINTER_TYPE)
9887 r = build_pointer_type (type);
9888 if (TREE_CODE (type) == METHOD_TYPE)
9889 r = build_ptrmemfunc_type (r);
9891 else if (TREE_CODE (type) == REFERENCE_TYPE)
9892 /* In C++0x, during template argument substitution, when there is an
9893 attempt to create a reference to a reference type, reference
9894 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
9896 "If a template-argument for a template-parameter T names a type
9897 that is a reference to a type A, an attempt to create the type
9898 'lvalue reference to cv T' creates the type 'lvalue reference to
9899 A,' while an attempt to create the type type rvalue reference to
9900 cv T' creates the type T"
9902 r = cp_build_reference_type
9904 TYPE_REF_IS_RVALUE (t) && TYPE_REF_IS_RVALUE (type));
9906 r = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
9907 r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
9909 if (r != error_mark_node)
9910 /* Will this ever be needed for TYPE_..._TO values? */
9917 r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
9918 if (r == error_mark_node || !MAYBE_CLASS_TYPE_P (r))
9922 Type deduction may fail for any of the following
9925 -- Attempting to create "pointer to member of T" when T
9926 is not a class type. */
9927 if (complain & tf_error)
9928 error ("creating pointer to member of non-class type %qT", r);
9929 return error_mark_node;
9931 if (TREE_CODE (type) == REFERENCE_TYPE)
9933 if (complain & tf_error)
9934 error ("creating pointer to member reference type %qT", type);
9935 return error_mark_node;
9937 if (TREE_CODE (type) == VOID_TYPE)
9939 if (complain & tf_error)
9940 error ("creating pointer to member of type void");
9941 return error_mark_node;
9943 gcc_assert (TREE_CODE (type) != METHOD_TYPE);
9944 if (TREE_CODE (type) == FUNCTION_TYPE)
9946 /* The type of the implicit object parameter gets its
9947 cv-qualifiers from the FUNCTION_TYPE. */
9949 tree this_type = cp_build_qualified_type (TYPE_MAIN_VARIANT (r),
9950 cp_type_quals (type));
9952 method_type = build_method_type_directly (this_type,
9954 TYPE_ARG_TYPES (type));
9955 memptr = build_ptrmemfunc_type (build_pointer_type (method_type));
9956 return cp_build_qualified_type_real (memptr, cp_type_quals (t),
9960 return cp_build_qualified_type_real (build_ptrmem_type (r, type),
9969 fntype = tsubst_function_type (t, args, complain, in_decl);
9970 if (fntype == error_mark_node)
9971 return error_mark_node;
9973 /* Substitute the exception specification. */
9974 specs = tsubst_exception_specification (t, args, complain,
9976 if (specs == error_mark_node)
9977 return error_mark_node;
9979 fntype = build_exception_variant (fntype, specs);
9984 tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
9985 if (domain == error_mark_node)
9986 return error_mark_node;
9988 /* As an optimization, we avoid regenerating the array type if
9989 it will obviously be the same as T. */
9990 if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
9993 /* These checks should match the ones in grokdeclarator.
9997 The deduction may fail for any of the following reasons:
9999 -- Attempting to create an array with an element type that
10000 is void, a function type, or a reference type, or [DR337]
10001 an abstract class type. */
10002 if (TREE_CODE (type) == VOID_TYPE
10003 || TREE_CODE (type) == FUNCTION_TYPE
10004 || TREE_CODE (type) == REFERENCE_TYPE)
10006 if (complain & tf_error)
10007 error ("creating array of %qT", type);
10008 return error_mark_node;
10010 if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
10012 if (complain & tf_error)
10013 error ("creating array of %qT, which is an abstract class type",
10015 return error_mark_node;
10018 r = build_cplus_array_type (type, domain);
10020 if (TYPE_USER_ALIGN (t))
10022 TYPE_ALIGN (r) = TYPE_ALIGN (t);
10023 TYPE_USER_ALIGN (r) = 1;
10032 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
10033 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
10035 if (e1 == error_mark_node || e2 == error_mark_node)
10036 return error_mark_node;
10038 return fold_build2_loc (input_location,
10039 TREE_CODE (t), TREE_TYPE (t), e1, e2);
10045 tree e = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
10046 if (e == error_mark_node)
10047 return error_mark_node;
10049 return fold_build1_loc (input_location, TREE_CODE (t), TREE_TYPE (t), e);
10052 case TYPENAME_TYPE:
10054 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
10055 in_decl, /*entering_scope=*/1);
10056 tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
10057 complain, in_decl);
10059 if (ctx == error_mark_node || f == error_mark_node)
10060 return error_mark_node;
10062 if (!MAYBE_CLASS_TYPE_P (ctx))
10064 if (complain & tf_error)
10065 error ("%qT is not a class, struct, or union type", ctx);
10066 return error_mark_node;
10068 else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
10070 /* Normally, make_typename_type does not require that the CTX
10071 have complete type in order to allow things like:
10073 template <class T> struct S { typename S<T>::X Y; };
10075 But, such constructs have already been resolved by this
10076 point, so here CTX really should have complete type, unless
10077 it's a partial instantiation. */
10078 if (!(complain & tf_no_class_instantiations))
10079 ctx = complete_type (ctx);
10080 if (!COMPLETE_TYPE_P (ctx))
10082 if (complain & tf_error)
10083 cxx_incomplete_type_error (NULL_TREE, ctx);
10084 return error_mark_node;
10088 f = make_typename_type (ctx, f, typename_type,
10089 (complain & tf_error) | tf_keep_type_decl);
10090 if (f == error_mark_node)
10092 if (TREE_CODE (f) == TYPE_DECL)
10094 complain |= tf_ignore_bad_quals;
10098 if (TREE_CODE (f) != TYPENAME_TYPE)
10100 if (TYPENAME_IS_ENUM_P (t) && TREE_CODE (f) != ENUMERAL_TYPE)
10101 error ("%qT resolves to %qT, which is not an enumeration type",
10103 else if (TYPENAME_IS_CLASS_P (t) && !CLASS_TYPE_P (f))
10104 error ("%qT resolves to %qT, which is is not a class type",
10108 return cp_build_qualified_type_real
10109 (f, cp_type_quals (f) | cp_type_quals (t), complain);
10112 case UNBOUND_CLASS_TEMPLATE:
10114 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
10115 in_decl, /*entering_scope=*/1);
10116 tree name = TYPE_IDENTIFIER (t);
10117 tree parm_list = DECL_TEMPLATE_PARMS (TYPE_NAME (t));
10119 if (ctx == error_mark_node || name == error_mark_node)
10120 return error_mark_node;
10123 parm_list = tsubst_template_parms (parm_list, args, complain);
10124 return make_unbound_class_template (ctx, name, parm_list, complain);
10130 gcc_unreachable ();
10134 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
10135 tree e2 = tsubst_expr (TREE_OPERAND (t, 1), args, complain, in_decl,
10136 /*integral_constant_expression_p=*/false);
10137 if (e1 == error_mark_node || e2 == error_mark_node)
10138 return error_mark_node;
10140 return build_nt (ARRAY_REF, e1, e2, NULL_TREE, NULL_TREE);
10145 tree e1 = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
10146 tree e2 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
10147 if (e1 == error_mark_node || e2 == error_mark_node)
10148 return error_mark_node;
10150 return build_qualified_name (/*type=*/NULL_TREE,
10151 e1, e2, QUALIFIED_NAME_IS_TEMPLATE (t));
10158 type = finish_typeof (tsubst_expr
10159 (TYPEOF_TYPE_EXPR (t), args,
10161 /*integral_constant_expression_p=*/false));
10162 return cp_build_qualified_type_real (type,
10164 | cp_type_quals (type),
10168 case DECLTYPE_TYPE:
10172 ++cp_unevaluated_operand;
10173 ++c_inhibit_evaluation_warnings;
10175 type = tsubst_expr (DECLTYPE_TYPE_EXPR (t), args,
10177 /*integral_constant_expression_p=*/false);
10179 --cp_unevaluated_operand;
10180 --c_inhibit_evaluation_warnings;
10182 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t))
10183 type = lambda_capture_field_type (type);
10184 else if (DECLTYPE_FOR_LAMBDA_RETURN (t))
10185 type = lambda_return_type (type);
10187 type = finish_decltype_type
10188 (type, DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t));
10189 return cp_build_qualified_type_real (type,
10191 | cp_type_quals (type),
10195 case TYPE_ARGUMENT_PACK:
10196 case NONTYPE_ARGUMENT_PACK:
10198 tree r = TYPE_P (t)
10199 ? cxx_make_type (TREE_CODE (t))
10200 : make_node (TREE_CODE (t));
10202 tsubst_template_args (ARGUMENT_PACK_ARGS (t),
10206 SET_ARGUMENT_PACK_ARGS (r, packed_out);
10208 /* For template nontype argument packs, also substitute into
10210 if (TREE_CODE (t) == NONTYPE_ARGUMENT_PACK)
10211 TREE_TYPE (r) = tsubst (TREE_TYPE (t), args, complain, in_decl);
10218 sorry ("use of %qs in template",
10219 tree_code_name [(int) TREE_CODE (t)]);
10220 return error_mark_node;
10224 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
10225 type of the expression on the left-hand side of the "." or "->"
10229 tsubst_baselink (tree baselink, tree object_type,
10230 tree args, tsubst_flags_t complain, tree in_decl)
10233 tree qualifying_scope;
10236 tree template_args = 0;
10237 bool template_id_p = false;
10239 /* A baselink indicates a function from a base class. Both the
10240 BASELINK_ACCESS_BINFO and the base class referenced may
10241 indicate bases of the template class, rather than the
10242 instantiated class. In addition, lookups that were not
10243 ambiguous before may be ambiguous now. Therefore, we perform
10244 the lookup again. */
10245 qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink));
10246 qualifying_scope = tsubst (qualifying_scope, args,
10247 complain, in_decl);
10248 fns = BASELINK_FUNCTIONS (baselink);
10249 optype = BASELINK_OPTYPE (baselink);
10250 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
10252 template_id_p = true;
10253 template_args = TREE_OPERAND (fns, 1);
10254 fns = TREE_OPERAND (fns, 0);
10256 template_args = tsubst_template_args (template_args, args,
10257 complain, in_decl);
10259 name = DECL_NAME (get_first_fn (fns));
10260 baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1);
10262 /* If lookup found a single function, mark it as used at this
10263 point. (If it lookup found multiple functions the one selected
10264 later by overload resolution will be marked as used at that
10266 if (BASELINK_P (baselink))
10267 fns = BASELINK_FUNCTIONS (baselink);
10268 if (!template_id_p && !really_overloaded_fn (fns))
10269 mark_used (OVL_CURRENT (fns));
10271 /* Add back the template arguments, if present. */
10272 if (BASELINK_P (baselink) && template_id_p)
10273 BASELINK_FUNCTIONS (baselink)
10274 = build_nt (TEMPLATE_ID_EXPR,
10275 BASELINK_FUNCTIONS (baselink),
10277 /* Update the conversion operator type. */
10278 BASELINK_OPTYPE (baselink)
10279 = tsubst (optype, args, complain, in_decl);
10282 object_type = current_class_type;
10283 return adjust_result_of_qualified_name_lookup (baselink,
10288 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
10289 true if the qualified-id will be a postfix-expression in-and-of
10290 itself; false if more of the postfix-expression follows the
10291 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
10295 tsubst_qualified_id (tree qualified_id, tree args,
10296 tsubst_flags_t complain, tree in_decl,
10297 bool done, bool address_p)
10303 tree template_args;
10305 gcc_assert (TREE_CODE (qualified_id) == SCOPE_REF);
10307 /* Figure out what name to look up. */
10308 name = TREE_OPERAND (qualified_id, 1);
10309 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
10311 is_template = true;
10312 template_args = TREE_OPERAND (name, 1);
10314 template_args = tsubst_template_args (template_args, args,
10315 complain, in_decl);
10316 name = TREE_OPERAND (name, 0);
10320 is_template = false;
10321 template_args = NULL_TREE;
10324 /* Substitute into the qualifying scope. When there are no ARGS, we
10325 are just trying to simplify a non-dependent expression. In that
10326 case the qualifying scope may be dependent, and, in any case,
10327 substituting will not help. */
10328 scope = TREE_OPERAND (qualified_id, 0);
10331 scope = tsubst (scope, args, complain, in_decl);
10332 expr = tsubst_copy (name, args, complain, in_decl);
10337 if (dependent_type_p (scope))
10339 tree type = NULL_TREE;
10340 if (DECL_P (expr) && !dependent_scope_p (scope))
10341 type = TREE_TYPE (expr);
10342 return build_qualified_name (type, scope, expr,
10343 QUALIFIED_NAME_IS_TEMPLATE (qualified_id));
10346 if (!BASELINK_P (name) && !DECL_P (expr))
10348 if (TREE_CODE (expr) == BIT_NOT_EXPR)
10350 /* A BIT_NOT_EXPR is used to represent a destructor. */
10351 if (!check_dtor_name (scope, TREE_OPERAND (expr, 0)))
10353 error ("qualifying type %qT does not match destructor name ~%qT",
10354 scope, TREE_OPERAND (expr, 0));
10355 expr = error_mark_node;
10358 expr = lookup_qualified_name (scope, complete_dtor_identifier,
10359 /*is_type_p=*/0, false);
10362 expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0, false);
10363 if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL
10364 ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL)
10366 if (complain & tf_error)
10368 error ("dependent-name %qE is parsed as a non-type, but "
10369 "instantiation yields a type", qualified_id);
10370 inform (input_location, "say %<typename %E%> if a type is meant", qualified_id);
10372 return error_mark_node;
10378 check_accessibility_of_qualified_id (expr, /*object_type=*/NULL_TREE,
10380 /* Remember that there was a reference to this entity. */
10384 if (expr == error_mark_node || TREE_CODE (expr) == TREE_LIST)
10386 if (complain & tf_error)
10387 qualified_name_lookup_error (scope,
10388 TREE_OPERAND (qualified_id, 1),
10389 expr, input_location);
10390 return error_mark_node;
10394 expr = lookup_template_function (expr, template_args);
10396 if (expr == error_mark_node && complain & tf_error)
10397 qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1),
10398 expr, input_location);
10399 else if (TYPE_P (scope))
10401 expr = (adjust_result_of_qualified_name_lookup
10402 (expr, scope, current_class_type));
10403 expr = (finish_qualified_id_expr
10404 (scope, expr, done, address_p,
10405 QUALIFIED_NAME_IS_TEMPLATE (qualified_id),
10406 /*template_arg_p=*/false));
10409 /* Expressions do not generally have reference type. */
10410 if (TREE_CODE (expr) != SCOPE_REF
10411 /* However, if we're about to form a pointer-to-member, we just
10412 want the referenced member referenced. */
10413 && TREE_CODE (expr) != OFFSET_REF)
10414 expr = convert_from_reference (expr);
10419 /* Like tsubst, but deals with expressions. This function just replaces
10420 template parms; to finish processing the resultant expression, use
10424 tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
10426 enum tree_code code;
10429 if (t == NULL_TREE || t == error_mark_node || args == NULL_TREE)
10432 code = TREE_CODE (t);
10437 r = retrieve_local_specialization (t);
10442 /* This can happen for a parameter name used later in a function
10443 declaration (such as in a late-specified return type). Just
10444 make a dummy decl, since it's only used for its type. */
10445 gcc_assert (cp_unevaluated_operand != 0);
10446 /* We copy T because want to tsubst the PARM_DECL only,
10447 not the following PARM_DECLs that are chained to T. */
10449 r = tsubst_decl (c, args, complain);
10450 /* Give it the template pattern as its context; its true context
10451 hasn't been instantiated yet and this is good enough for
10453 DECL_CONTEXT (r) = DECL_CONTEXT (t);
10456 if (TREE_CODE (r) == ARGUMENT_PACK_SELECT)
10457 r = ARGUMENT_PACK_SELECT_ARG (r);
10466 if (DECL_TEMPLATE_PARM_P (t))
10467 return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
10468 /* There is no need to substitute into namespace-scope
10470 if (DECL_NAMESPACE_SCOPE_P (t))
10472 /* If ARGS is NULL, then T is known to be non-dependent. */
10473 if (args == NULL_TREE)
10474 return integral_constant_value (t);
10476 /* Unfortunately, we cannot just call lookup_name here.
10479 template <int I> int f() {
10481 struct S { void g() { E e = a; } };
10484 When we instantiate f<7>::S::g(), say, lookup_name is not
10485 clever enough to find f<7>::a. */
10487 = tsubst_aggr_type (TREE_TYPE (t), args, complain, in_decl,
10488 /*entering_scope=*/0);
10490 for (v = TYPE_VALUES (enum_type);
10492 v = TREE_CHAIN (v))
10493 if (TREE_PURPOSE (v) == DECL_NAME (t))
10494 return TREE_VALUE (v);
10496 /* We didn't find the name. That should never happen; if
10497 name-lookup found it during preliminary parsing, we
10498 should find it again here during instantiation. */
10499 gcc_unreachable ();
10504 if (DECL_CONTEXT (t))
10508 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
10509 /*entering_scope=*/1);
10510 if (ctx != DECL_CONTEXT (t))
10512 tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
10515 if (complain & tf_error)
10516 error ("using invalid field %qD", t);
10517 return error_mark_node;
10526 case FUNCTION_DECL:
10527 if ((DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
10528 || local_variable_p (t))
10529 t = tsubst (t, args, complain, in_decl);
10534 return tsubst_baselink (t, current_class_type, args, complain, in_decl);
10536 case TEMPLATE_DECL:
10537 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
10538 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
10539 args, complain, in_decl);
10540 else if (DECL_FUNCTION_TEMPLATE_P (t) && DECL_MEMBER_TEMPLATE_P (t))
10541 return tsubst (t, args, complain, in_decl);
10542 else if (DECL_CLASS_SCOPE_P (t)
10543 && uses_template_parms (DECL_CONTEXT (t)))
10545 /* Template template argument like the following example need
10548 template <template <class> class TT> struct C {};
10549 template <class T> struct D {
10550 template <class U> struct E {};
10555 We are processing the template argument `E' in #1 for
10556 the template instantiation #2. Originally, `E' is a
10557 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
10558 have to substitute this with one having context `D<int>'. */
10560 tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
10561 return lookup_field (context, DECL_NAME(t), 0, false);
10564 /* Ordinary template template argument. */
10568 case REINTERPRET_CAST_EXPR:
10569 case CONST_CAST_EXPR:
10570 case STATIC_CAST_EXPR:
10571 case DYNAMIC_CAST_EXPR:
10574 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
10575 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
10578 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
10580 /* We only want to compute the number of arguments. */
10581 tree expanded = tsubst_pack_expansion (TREE_OPERAND (t, 0), args,
10582 complain, in_decl);
10585 if (TREE_CODE (expanded) == TREE_VEC)
10586 len = TREE_VEC_LENGTH (expanded);
10588 if (expanded == error_mark_node)
10589 return error_mark_node;
10590 else if (PACK_EXPANSION_P (expanded)
10591 || (TREE_CODE (expanded) == TREE_VEC
10593 && PACK_EXPANSION_P (TREE_VEC_ELT (expanded, len-1))))
10595 if (TREE_CODE (expanded) == TREE_VEC)
10596 expanded = TREE_VEC_ELT (expanded, len - 1);
10598 if (TYPE_P (expanded))
10599 return cxx_sizeof_or_alignof_type (expanded, SIZEOF_EXPR,
10600 complain & tf_error);
10602 return cxx_sizeof_or_alignof_expr (expanded, SIZEOF_EXPR,
10603 complain & tf_error);
10606 return build_int_cst (size_type_node, len);
10612 case TRUTH_NOT_EXPR:
10615 case UNARY_PLUS_EXPR: /* Unary + */
10620 case REALPART_EXPR:
10621 case IMAGPART_EXPR:
10623 (code, tsubst (TREE_TYPE (t), args, complain, in_decl),
10624 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl));
10626 case COMPONENT_REF:
10631 object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
10632 name = TREE_OPERAND (t, 1);
10633 if (TREE_CODE (name) == BIT_NOT_EXPR)
10635 name = tsubst_copy (TREE_OPERAND (name, 0), args,
10636 complain, in_decl);
10637 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
10639 else if (TREE_CODE (name) == SCOPE_REF
10640 && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
10642 tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
10643 complain, in_decl);
10644 name = TREE_OPERAND (name, 1);
10645 name = tsubst_copy (TREE_OPERAND (name, 0), args,
10646 complain, in_decl);
10647 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
10648 name = build_qualified_name (/*type=*/NULL_TREE,
10650 /*template_p=*/false);
10652 else if (TREE_CODE (name) == BASELINK)
10653 name = tsubst_baselink (name,
10654 non_reference (TREE_TYPE (object)),
10658 name = tsubst_copy (name, args, complain, in_decl);
10659 return build_nt (COMPONENT_REF, object, name, NULL_TREE);
10665 case TRUNC_DIV_EXPR:
10666 case CEIL_DIV_EXPR:
10667 case FLOOR_DIV_EXPR:
10668 case ROUND_DIV_EXPR:
10669 case EXACT_DIV_EXPR:
10673 case TRUNC_MOD_EXPR:
10674 case FLOOR_MOD_EXPR:
10675 case TRUTH_ANDIF_EXPR:
10676 case TRUTH_ORIF_EXPR:
10677 case TRUTH_AND_EXPR:
10678 case TRUTH_OR_EXPR:
10691 case COMPOUND_EXPR:
10694 case PREDECREMENT_EXPR:
10695 case PREINCREMENT_EXPR:
10696 case POSTDECREMENT_EXPR:
10697 case POSTINCREMENT_EXPR:
10699 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
10700 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
10703 return build_qualified_name (/*type=*/NULL_TREE,
10704 tsubst_copy (TREE_OPERAND (t, 0),
10705 args, complain, in_decl),
10706 tsubst_copy (TREE_OPERAND (t, 1),
10707 args, complain, in_decl),
10708 QUALIFIED_NAME_IS_TEMPLATE (t));
10713 tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
10714 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
10715 NULL_TREE, NULL_TREE);
10719 int n = VL_EXP_OPERAND_LENGTH (t);
10720 tree result = build_vl_exp (CALL_EXPR, n);
10722 for (i = 0; i < n; i++)
10723 TREE_OPERAND (t, i) = tsubst_copy (TREE_OPERAND (t, i), args,
10724 complain, in_decl);
10730 case PSEUDO_DTOR_EXPR:
10733 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
10734 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
10735 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
10736 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
10743 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
10744 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl),
10745 tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl));
10746 NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
10753 (code, tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl),
10754 tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl));
10755 DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
10756 DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
10760 case TEMPLATE_ID_EXPR:
10762 /* Substituted template arguments */
10763 tree fn = TREE_OPERAND (t, 0);
10764 tree targs = TREE_OPERAND (t, 1);
10766 fn = tsubst_copy (fn, args, complain, in_decl);
10768 targs = tsubst_template_args (targs, args, complain, in_decl);
10770 return lookup_template_function (fn, targs);
10775 tree purpose, value, chain;
10777 if (t == void_list_node)
10780 purpose = TREE_PURPOSE (t);
10782 purpose = tsubst_copy (purpose, args, complain, in_decl);
10783 value = TREE_VALUE (t);
10785 value = tsubst_copy (value, args, complain, in_decl);
10786 chain = TREE_CHAIN (t);
10787 if (chain && chain != void_type_node)
10788 chain = tsubst_copy (chain, args, complain, in_decl);
10789 if (purpose == TREE_PURPOSE (t)
10790 && value == TREE_VALUE (t)
10791 && chain == TREE_CHAIN (t))
10793 return tree_cons (purpose, value, chain);
10798 case ENUMERAL_TYPE:
10800 case TEMPLATE_TYPE_PARM:
10801 case TEMPLATE_TEMPLATE_PARM:
10802 case BOUND_TEMPLATE_TEMPLATE_PARM:
10803 case TEMPLATE_PARM_INDEX:
10805 case REFERENCE_TYPE:
10807 case FUNCTION_TYPE:
10810 case TYPENAME_TYPE:
10811 case UNBOUND_CLASS_TEMPLATE:
10813 case DECLTYPE_TYPE:
10815 return tsubst (t, args, complain, in_decl);
10817 case IDENTIFIER_NODE:
10818 if (IDENTIFIER_TYPENAME_P (t))
10820 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10821 return mangle_conv_op_name_for_type (new_type);
10827 /* This is handled by tsubst_copy_and_build. */
10828 gcc_unreachable ();
10831 return build_x_va_arg (tsubst_copy (TREE_OPERAND (t, 0), args, complain,
10833 tsubst (TREE_TYPE (t), args, complain, in_decl));
10835 case CLEANUP_POINT_EXPR:
10836 /* We shouldn't have built any of these during initial template
10837 generation. Instead, they should be built during instantiation
10838 in response to the saved STMT_IS_FULL_EXPR_P setting. */
10839 gcc_unreachable ();
10842 mark_used (TREE_OPERAND (t, 1));
10845 case EXPR_PACK_EXPANSION:
10846 error ("invalid use of pack expansion expression");
10847 return error_mark_node;
10849 case NONTYPE_ARGUMENT_PACK:
10850 error ("use %<...%> to expand argument pack");
10851 return error_mark_node;
10858 /* Like tsubst_copy, but specifically for OpenMP clauses. */
10861 tsubst_omp_clauses (tree clauses, tree args, tsubst_flags_t complain,
10864 tree new_clauses = NULL, nc, oc;
10866 for (oc = clauses; oc ; oc = OMP_CLAUSE_CHAIN (oc))
10868 nc = copy_node (oc);
10869 OMP_CLAUSE_CHAIN (nc) = new_clauses;
10872 switch (OMP_CLAUSE_CODE (nc))
10874 case OMP_CLAUSE_LASTPRIVATE:
10875 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc))
10877 OMP_CLAUSE_LASTPRIVATE_STMT (nc) = push_stmt_list ();
10878 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc), args, complain,
10879 in_decl, /*integral_constant_expression_p=*/false);
10880 OMP_CLAUSE_LASTPRIVATE_STMT (nc)
10881 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc));
10884 case OMP_CLAUSE_PRIVATE:
10885 case OMP_CLAUSE_SHARED:
10886 case OMP_CLAUSE_FIRSTPRIVATE:
10887 case OMP_CLAUSE_REDUCTION:
10888 case OMP_CLAUSE_COPYIN:
10889 case OMP_CLAUSE_COPYPRIVATE:
10890 case OMP_CLAUSE_IF:
10891 case OMP_CLAUSE_NUM_THREADS:
10892 case OMP_CLAUSE_SCHEDULE:
10893 case OMP_CLAUSE_COLLAPSE:
10894 OMP_CLAUSE_OPERAND (nc, 0)
10895 = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 0), args, complain,
10896 in_decl, /*integral_constant_expression_p=*/false);
10898 case OMP_CLAUSE_NOWAIT:
10899 case OMP_CLAUSE_ORDERED:
10900 case OMP_CLAUSE_DEFAULT:
10901 case OMP_CLAUSE_UNTIED:
10904 gcc_unreachable ();
10908 return finish_omp_clauses (nreverse (new_clauses));
10911 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
10914 tsubst_copy_asm_operands (tree t, tree args, tsubst_flags_t complain,
10917 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
10919 tree purpose, value, chain;
10924 if (TREE_CODE (t) != TREE_LIST)
10925 return tsubst_copy_and_build (t, args, complain, in_decl,
10926 /*function_p=*/false,
10927 /*integral_constant_expression_p=*/false);
10929 if (t == void_list_node)
10932 purpose = TREE_PURPOSE (t);
10934 purpose = RECUR (purpose);
10935 value = TREE_VALUE (t);
10936 if (value && TREE_CODE (value) != LABEL_DECL)
10937 value = RECUR (value);
10938 chain = TREE_CHAIN (t);
10939 if (chain && chain != void_type_node)
10940 chain = RECUR (chain);
10941 return tree_cons (purpose, value, chain);
10945 /* Substitute one OMP_FOR iterator. */
10948 tsubst_omp_for_iterator (tree t, int i, tree declv, tree initv,
10949 tree condv, tree incrv, tree *clauses,
10950 tree args, tsubst_flags_t complain, tree in_decl,
10951 bool integral_constant_expression_p)
10953 #define RECUR(NODE) \
10954 tsubst_expr ((NODE), args, complain, in_decl, \
10955 integral_constant_expression_p)
10956 tree decl, init, cond, incr, auto_node;
10958 init = TREE_VEC_ELT (OMP_FOR_INIT (t), i);
10959 gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
10960 decl = RECUR (TREE_OPERAND (init, 0));
10961 init = TREE_OPERAND (init, 1);
10962 auto_node = type_uses_auto (TREE_TYPE (decl));
10963 if (auto_node && init)
10965 tree init_expr = init;
10966 if (TREE_CODE (init_expr) == DECL_EXPR)
10967 init_expr = DECL_INITIAL (DECL_EXPR_DECL (init_expr));
10968 init_expr = RECUR (init_expr);
10970 = do_auto_deduction (TREE_TYPE (decl), init_expr, auto_node);
10972 gcc_assert (!type_dependent_expression_p (decl));
10974 if (!CLASS_TYPE_P (TREE_TYPE (decl)))
10976 cond = RECUR (TREE_VEC_ELT (OMP_FOR_COND (t), i));
10977 incr = TREE_VEC_ELT (OMP_FOR_INCR (t), i);
10978 if (TREE_CODE (incr) == MODIFY_EXPR)
10979 incr = build_x_modify_expr (RECUR (TREE_OPERAND (incr, 0)), NOP_EXPR,
10980 RECUR (TREE_OPERAND (incr, 1)),
10983 incr = RECUR (incr);
10984 TREE_VEC_ELT (declv, i) = decl;
10985 TREE_VEC_ELT (initv, i) = init;
10986 TREE_VEC_ELT (condv, i) = cond;
10987 TREE_VEC_ELT (incrv, i) = incr;
10991 if (init && TREE_CODE (init) != DECL_EXPR)
10994 for (c = *clauses; c ; c = OMP_CLAUSE_CHAIN (c))
10996 if ((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_PRIVATE
10997 || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE)
10998 && OMP_CLAUSE_DECL (c) == decl)
11000 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
11001 && OMP_CLAUSE_DECL (c) == decl)
11002 error ("iteration variable %qD should not be firstprivate", decl);
11003 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
11004 && OMP_CLAUSE_DECL (c) == decl)
11005 error ("iteration variable %qD should not be reduction", decl);
11009 c = build_omp_clause (input_location, OMP_CLAUSE_PRIVATE);
11010 OMP_CLAUSE_DECL (c) = decl;
11011 c = finish_omp_clauses (c);
11014 OMP_CLAUSE_CHAIN (c) = *clauses;
11019 cond = TREE_VEC_ELT (OMP_FOR_COND (t), i);
11020 if (COMPARISON_CLASS_P (cond))
11021 cond = build2 (TREE_CODE (cond), boolean_type_node,
11022 RECUR (TREE_OPERAND (cond, 0)),
11023 RECUR (TREE_OPERAND (cond, 1)));
11025 cond = RECUR (cond);
11026 incr = TREE_VEC_ELT (OMP_FOR_INCR (t), i);
11027 switch (TREE_CODE (incr))
11029 case PREINCREMENT_EXPR:
11030 case PREDECREMENT_EXPR:
11031 case POSTINCREMENT_EXPR:
11032 case POSTDECREMENT_EXPR:
11033 incr = build2 (TREE_CODE (incr), TREE_TYPE (decl),
11034 RECUR (TREE_OPERAND (incr, 0)), NULL_TREE);
11037 if (TREE_CODE (TREE_OPERAND (incr, 1)) == PLUS_EXPR
11038 || TREE_CODE (TREE_OPERAND (incr, 1)) == MINUS_EXPR)
11040 tree rhs = TREE_OPERAND (incr, 1);
11041 incr = build2 (MODIFY_EXPR, TREE_TYPE (decl),
11042 RECUR (TREE_OPERAND (incr, 0)),
11043 build2 (TREE_CODE (rhs), TREE_TYPE (decl),
11044 RECUR (TREE_OPERAND (rhs, 0)),
11045 RECUR (TREE_OPERAND (rhs, 1))));
11048 incr = RECUR (incr);
11051 if (TREE_CODE (TREE_OPERAND (incr, 1)) == PLUS_EXPR
11052 || TREE_CODE (TREE_OPERAND (incr, 1)) == MINUS_EXPR)
11054 tree lhs = RECUR (TREE_OPERAND (incr, 0));
11055 incr = build2 (MODIFY_EXPR, TREE_TYPE (decl), lhs,
11056 build2 (TREE_CODE (TREE_OPERAND (incr, 1)),
11057 TREE_TYPE (decl), lhs,
11058 RECUR (TREE_OPERAND (incr, 2))));
11060 else if (TREE_CODE (TREE_OPERAND (incr, 1)) == NOP_EXPR
11061 && (TREE_CODE (TREE_OPERAND (incr, 2)) == PLUS_EXPR
11062 || (TREE_CODE (TREE_OPERAND (incr, 2)) == MINUS_EXPR)))
11064 tree rhs = TREE_OPERAND (incr, 2);
11065 incr = build2 (MODIFY_EXPR, TREE_TYPE (decl),
11066 RECUR (TREE_OPERAND (incr, 0)),
11067 build2 (TREE_CODE (rhs), TREE_TYPE (decl),
11068 RECUR (TREE_OPERAND (rhs, 0)),
11069 RECUR (TREE_OPERAND (rhs, 1))));
11072 incr = RECUR (incr);
11075 incr = RECUR (incr);
11079 TREE_VEC_ELT (declv, i) = decl;
11080 TREE_VEC_ELT (initv, i) = init;
11081 TREE_VEC_ELT (condv, i) = cond;
11082 TREE_VEC_ELT (incrv, i) = incr;
11086 /* Like tsubst_copy for expressions, etc. but also does semantic
11090 tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl,
11091 bool integral_constant_expression_p)
11093 #define RECUR(NODE) \
11094 tsubst_expr ((NODE), args, complain, in_decl, \
11095 integral_constant_expression_p)
11099 if (t == NULL_TREE || t == error_mark_node)
11102 if (EXPR_HAS_LOCATION (t))
11103 input_location = EXPR_LOCATION (t);
11104 if (STATEMENT_CODE_P (TREE_CODE (t)))
11105 current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
11107 switch (TREE_CODE (t))
11109 case STATEMENT_LIST:
11111 tree_stmt_iterator i;
11112 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
11113 RECUR (tsi_stmt (i));
11117 case CTOR_INITIALIZER:
11118 finish_mem_initializers (tsubst_initializer_list
11119 (TREE_OPERAND (t, 0), args));
11123 finish_return_stmt (RECUR (TREE_OPERAND (t, 0)));
11127 tmp = RECUR (EXPR_STMT_EXPR (t));
11128 if (EXPR_STMT_STMT_EXPR_RESULT (t))
11129 finish_stmt_expr_expr (tmp, cur_stmt_expr);
11131 finish_expr_stmt (tmp);
11135 do_using_directive (RECUR (USING_STMT_NAMESPACE (t)));
11143 decl = DECL_EXPR_DECL (t);
11144 if (TREE_CODE (decl) == LABEL_DECL)
11145 finish_label_decl (DECL_NAME (decl));
11146 else if (TREE_CODE (decl) == USING_DECL)
11148 tree scope = USING_DECL_SCOPE (decl);
11149 tree name = DECL_NAME (decl);
11152 scope = RECUR (scope);
11153 decl = lookup_qualified_name (scope, name,
11154 /*is_type_p=*/false,
11155 /*complain=*/false);
11156 if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
11157 qualified_name_lookup_error (scope, name, decl, input_location);
11159 do_local_using_decl (decl, scope, name);
11163 init = DECL_INITIAL (decl);
11164 decl = tsubst (decl, args, complain, in_decl);
11165 if (decl != error_mark_node)
11167 /* By marking the declaration as instantiated, we avoid
11168 trying to instantiate it. Since instantiate_decl can't
11169 handle local variables, and since we've already done
11170 all that needs to be done, that's the right thing to
11172 if (TREE_CODE (decl) == VAR_DECL)
11173 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
11174 if (TREE_CODE (decl) == VAR_DECL
11175 && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
11176 /* Anonymous aggregates are a special case. */
11177 finish_anon_union (decl);
11180 maybe_push_decl (decl);
11181 if (TREE_CODE (decl) == VAR_DECL
11182 && DECL_PRETTY_FUNCTION_P (decl))
11184 /* For __PRETTY_FUNCTION__ we have to adjust the
11186 const char *const name
11187 = cxx_printable_name (current_function_decl, 2);
11188 init = cp_fname_init (name, &TREE_TYPE (decl));
11192 tree t = RECUR (init);
11195 /* If we had an initializer but it
11196 instantiated to nothing,
11197 value-initialize the object. This will
11198 only occur when the initializer was a
11199 pack expansion where the parameter packs
11200 used in that expansion were of length
11202 init = build_value_init (TREE_TYPE (decl));
11207 cp_finish_decl (decl, init, false, NULL_TREE, 0);
11212 /* A DECL_EXPR can also be used as an expression, in the condition
11213 clause of an if/for/while construct. */
11218 stmt = begin_for_stmt ();
11219 RECUR (FOR_INIT_STMT (t));
11220 finish_for_init_stmt (stmt);
11221 tmp = RECUR (FOR_COND (t));
11222 finish_for_cond (tmp, stmt);
11223 tmp = RECUR (FOR_EXPR (t));
11224 finish_for_expr (tmp, stmt);
11225 RECUR (FOR_BODY (t));
11226 finish_for_stmt (stmt);
11230 stmt = begin_while_stmt ();
11231 tmp = RECUR (WHILE_COND (t));
11232 finish_while_stmt_cond (tmp, stmt);
11233 RECUR (WHILE_BODY (t));
11234 finish_while_stmt (stmt);
11238 stmt = begin_do_stmt ();
11239 RECUR (DO_BODY (t));
11240 finish_do_body (stmt);
11241 tmp = RECUR (DO_COND (t));
11242 finish_do_stmt (tmp, stmt);
11246 stmt = begin_if_stmt ();
11247 tmp = RECUR (IF_COND (t));
11248 finish_if_stmt_cond (tmp, stmt);
11249 RECUR (THEN_CLAUSE (t));
11250 finish_then_clause (stmt);
11252 if (ELSE_CLAUSE (t))
11254 begin_else_clause (stmt);
11255 RECUR (ELSE_CLAUSE (t));
11256 finish_else_clause (stmt);
11259 finish_if_stmt (stmt);
11263 if (BIND_EXPR_BODY_BLOCK (t))
11264 stmt = begin_function_body ();
11266 stmt = begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t)
11267 ? BCS_TRY_BLOCK : 0);
11269 RECUR (BIND_EXPR_BODY (t));
11271 if (BIND_EXPR_BODY_BLOCK (t))
11272 finish_function_body (stmt);
11274 finish_compound_stmt (stmt);
11278 finish_break_stmt ();
11281 case CONTINUE_STMT:
11282 finish_continue_stmt ();
11286 stmt = begin_switch_stmt ();
11287 tmp = RECUR (SWITCH_STMT_COND (t));
11288 finish_switch_cond (tmp, stmt);
11289 RECUR (SWITCH_STMT_BODY (t));
11290 finish_switch_stmt (stmt);
11293 case CASE_LABEL_EXPR:
11294 finish_case_label (EXPR_LOCATION (t),
11295 RECUR (CASE_LOW (t)),
11296 RECUR (CASE_HIGH (t)));
11301 tree decl = LABEL_EXPR_LABEL (t);
11304 label = finish_label_stmt (DECL_NAME (decl));
11305 if (DECL_ATTRIBUTES (decl) != NULL_TREE)
11306 cplus_decl_attributes (&label, DECL_ATTRIBUTES (decl), 0);
11311 tmp = GOTO_DESTINATION (t);
11312 if (TREE_CODE (tmp) != LABEL_DECL)
11313 /* Computed goto's must be tsubst'd into. On the other hand,
11314 non-computed gotos must not be; the identifier in question
11315 will have no binding. */
11318 tmp = DECL_NAME (tmp);
11319 finish_goto_stmt (tmp);
11323 tmp = finish_asm_stmt
11324 (ASM_VOLATILE_P (t),
11325 RECUR (ASM_STRING (t)),
11326 tsubst_copy_asm_operands (ASM_OUTPUTS (t), args, complain, in_decl),
11327 tsubst_copy_asm_operands (ASM_INPUTS (t), args, complain, in_decl),
11328 tsubst_copy_asm_operands (ASM_CLOBBERS (t), args, complain, in_decl),
11329 tsubst_copy_asm_operands (ASM_LABELS (t), args, complain, in_decl));
11331 tree asm_expr = tmp;
11332 if (TREE_CODE (asm_expr) == CLEANUP_POINT_EXPR)
11333 asm_expr = TREE_OPERAND (asm_expr, 0);
11334 ASM_INPUT_P (asm_expr) = ASM_INPUT_P (t);
11341 stmt = begin_try_block ();
11342 RECUR (TRY_STMTS (t));
11343 finish_cleanup_try_block (stmt);
11344 finish_cleanup (RECUR (TRY_HANDLERS (t)), stmt);
11348 tree compound_stmt = NULL_TREE;
11350 if (FN_TRY_BLOCK_P (t))
11351 stmt = begin_function_try_block (&compound_stmt);
11353 stmt = begin_try_block ();
11355 RECUR (TRY_STMTS (t));
11357 if (FN_TRY_BLOCK_P (t))
11358 finish_function_try_block (stmt);
11360 finish_try_block (stmt);
11362 RECUR (TRY_HANDLERS (t));
11363 if (FN_TRY_BLOCK_P (t))
11364 finish_function_handler_sequence (stmt, compound_stmt);
11366 finish_handler_sequence (stmt);
11372 tree decl = HANDLER_PARMS (t);
11376 decl = tsubst (decl, args, complain, in_decl);
11377 /* Prevent instantiate_decl from trying to instantiate
11378 this variable. We've already done all that needs to be
11380 if (decl != error_mark_node)
11381 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
11383 stmt = begin_handler ();
11384 finish_handler_parms (decl, stmt);
11385 RECUR (HANDLER_BODY (t));
11386 finish_handler (stmt);
11391 tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
11394 case STATIC_ASSERT:
11397 tsubst_expr (STATIC_ASSERT_CONDITION (t),
11400 /*integral_constant_expression_p=*/true);
11401 finish_static_assert (condition,
11402 STATIC_ASSERT_MESSAGE (t),
11403 STATIC_ASSERT_SOURCE_LOCATION (t),
11404 /*member_p=*/false);
11409 tmp = tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t),
11410 args, complain, in_decl);
11411 stmt = begin_omp_parallel ();
11412 RECUR (OMP_PARALLEL_BODY (t));
11413 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp, stmt))
11414 = OMP_PARALLEL_COMBINED (t);
11418 tmp = tsubst_omp_clauses (OMP_TASK_CLAUSES (t),
11419 args, complain, in_decl);
11420 stmt = begin_omp_task ();
11421 RECUR (OMP_TASK_BODY (t));
11422 finish_omp_task (tmp, stmt);
11427 tree clauses, body, pre_body;
11428 tree declv, initv, condv, incrv;
11431 clauses = tsubst_omp_clauses (OMP_FOR_CLAUSES (t),
11432 args, complain, in_decl);
11433 declv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
11434 initv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
11435 condv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
11436 incrv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
11438 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (t)); i++)
11439 tsubst_omp_for_iterator (t, i, declv, initv, condv, incrv,
11440 &clauses, args, complain, in_decl,
11441 integral_constant_expression_p);
11443 stmt = begin_omp_structured_block ();
11445 for (i = 0; i < TREE_VEC_LENGTH (initv); i++)
11446 if (TREE_VEC_ELT (initv, i) == NULL
11447 || TREE_CODE (TREE_VEC_ELT (initv, i)) != DECL_EXPR)
11448 TREE_VEC_ELT (initv, i) = RECUR (TREE_VEC_ELT (initv, i));
11449 else if (CLASS_TYPE_P (TREE_TYPE (TREE_VEC_ELT (initv, i))))
11451 tree init = RECUR (TREE_VEC_ELT (initv, i));
11452 gcc_assert (init == TREE_VEC_ELT (declv, i));
11453 TREE_VEC_ELT (initv, i) = NULL_TREE;
11457 tree decl_expr = TREE_VEC_ELT (initv, i);
11458 tree init = DECL_INITIAL (DECL_EXPR_DECL (decl_expr));
11459 gcc_assert (init != NULL);
11460 TREE_VEC_ELT (initv, i) = RECUR (init);
11461 DECL_INITIAL (DECL_EXPR_DECL (decl_expr)) = NULL;
11463 DECL_INITIAL (DECL_EXPR_DECL (decl_expr)) = init;
11466 pre_body = push_stmt_list ();
11467 RECUR (OMP_FOR_PRE_BODY (t));
11468 pre_body = pop_stmt_list (pre_body);
11470 body = push_stmt_list ();
11471 RECUR (OMP_FOR_BODY (t));
11472 body = pop_stmt_list (body);
11474 t = finish_omp_for (EXPR_LOCATION (t), declv, initv, condv, incrv,
11475 body, pre_body, clauses);
11477 add_stmt (finish_omp_structured_block (stmt));
11483 tmp = tsubst_omp_clauses (OMP_CLAUSES (t), args, complain, in_decl);
11484 stmt = push_stmt_list ();
11485 RECUR (OMP_BODY (t));
11486 stmt = pop_stmt_list (stmt);
11489 OMP_BODY (t) = stmt;
11490 OMP_CLAUSES (t) = tmp;
11498 stmt = push_stmt_list ();
11499 RECUR (OMP_BODY (t));
11500 stmt = pop_stmt_list (stmt);
11503 OMP_BODY (t) = stmt;
11508 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t));
11510 tree op1 = TREE_OPERAND (t, 1);
11511 tree lhs = RECUR (TREE_OPERAND (op1, 0));
11512 tree rhs = RECUR (TREE_OPERAND (op1, 1));
11513 finish_omp_atomic (TREE_CODE (op1), lhs, rhs);
11517 case EXPR_PACK_EXPANSION:
11518 error ("invalid use of pack expansion expression");
11519 return error_mark_node;
11521 case NONTYPE_ARGUMENT_PACK:
11522 error ("use %<...%> to expand argument pack");
11523 return error_mark_node;
11526 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t)));
11528 return tsubst_copy_and_build (t, args, complain, in_decl,
11529 /*function_p=*/false,
11530 integral_constant_expression_p);
11537 /* T is a postfix-expression that is not being used in a function
11538 call. Return the substituted version of T. */
11541 tsubst_non_call_postfix_expression (tree t, tree args,
11542 tsubst_flags_t complain,
11545 if (TREE_CODE (t) == SCOPE_REF)
11546 t = tsubst_qualified_id (t, args, complain, in_decl,
11547 /*done=*/false, /*address_p=*/false);
11549 t = tsubst_copy_and_build (t, args, complain, in_decl,
11550 /*function_p=*/false,
11551 /*integral_constant_expression_p=*/false);
11556 /* Like tsubst but deals with expressions and performs semantic
11557 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
11560 tsubst_copy_and_build (tree t,
11562 tsubst_flags_t complain,
11565 bool integral_constant_expression_p)
11567 #define RECUR(NODE) \
11568 tsubst_copy_and_build (NODE, args, complain, in_decl, \
11569 /*function_p=*/false, \
11570 integral_constant_expression_p)
11574 if (t == NULL_TREE || t == error_mark_node)
11577 switch (TREE_CODE (t))
11581 /* Fall through. */
11582 case IDENTIFIER_NODE:
11586 bool non_integral_constant_expression_p;
11587 const char *error_msg;
11589 if (IDENTIFIER_TYPENAME_P (t))
11591 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
11592 t = mangle_conv_op_name_for_type (new_type);
11595 /* Look up the name. */
11596 decl = lookup_name (t);
11598 /* By convention, expressions use ERROR_MARK_NODE to indicate
11599 failure, not NULL_TREE. */
11600 if (decl == NULL_TREE)
11601 decl = error_mark_node;
11603 decl = finish_id_expression (t, decl, NULL_TREE,
11605 integral_constant_expression_p,
11606 /*allow_non_integral_constant_expression_p=*/false,
11607 &non_integral_constant_expression_p,
11608 /*template_p=*/false,
11610 /*address_p=*/false,
11611 /*template_arg_p=*/false,
11616 if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE)
11617 decl = unqualified_name_lookup_error (decl);
11621 case TEMPLATE_ID_EXPR:
11624 tree templ = RECUR (TREE_OPERAND (t, 0));
11625 tree targs = TREE_OPERAND (t, 1);
11628 targs = tsubst_template_args (targs, args, complain, in_decl);
11630 if (TREE_CODE (templ) == COMPONENT_REF)
11632 object = TREE_OPERAND (templ, 0);
11633 templ = TREE_OPERAND (templ, 1);
11636 object = NULL_TREE;
11637 templ = lookup_template_function (templ, targs);
11640 return build3 (COMPONENT_REF, TREE_TYPE (templ),
11641 object, templ, NULL_TREE);
11643 return baselink_for_fns (templ);
11648 tree r = RECUR (TREE_OPERAND (t, 0));
11650 if (REFERENCE_REF_P (t))
11652 /* A type conversion to reference type will be enclosed in
11653 such an indirect ref, but the substitution of the cast
11654 will have also added such an indirect ref. */
11655 if (TREE_CODE (TREE_TYPE (r)) == REFERENCE_TYPE)
11656 r = convert_from_reference (r);
11659 r = build_x_indirect_ref (r, "unary *", complain);
11665 (tsubst (TREE_TYPE (t), args, complain, in_decl),
11666 RECUR (TREE_OPERAND (t, 0)));
11669 case REINTERPRET_CAST_EXPR:
11670 case CONST_CAST_EXPR:
11671 case DYNAMIC_CAST_EXPR:
11672 case STATIC_CAST_EXPR:
11677 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
11678 if (integral_constant_expression_p
11679 && !cast_valid_in_integral_constant_expression_p (type))
11681 if (complain & tf_error)
11682 error ("a cast to a type other than an integral or "
11683 "enumeration type cannot appear in a constant-expression");
11684 return error_mark_node;
11687 op = RECUR (TREE_OPERAND (t, 0));
11689 switch (TREE_CODE (t))
11692 return build_functional_cast (type, op, complain);
11693 case REINTERPRET_CAST_EXPR:
11694 return build_reinterpret_cast (type, op, complain);
11695 case CONST_CAST_EXPR:
11696 return build_const_cast (type, op, complain);
11697 case DYNAMIC_CAST_EXPR:
11698 return build_dynamic_cast (type, op, complain);
11699 case STATIC_CAST_EXPR:
11700 return build_static_cast (type, op, complain);
11702 gcc_unreachable ();
11706 case POSTDECREMENT_EXPR:
11707 case POSTINCREMENT_EXPR:
11708 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
11709 args, complain, in_decl);
11710 return build_x_unary_op (TREE_CODE (t), op1, complain);
11712 case PREDECREMENT_EXPR:
11713 case PREINCREMENT_EXPR:
11717 case TRUTH_NOT_EXPR:
11718 case UNARY_PLUS_EXPR: /* Unary + */
11719 case REALPART_EXPR:
11720 case IMAGPART_EXPR:
11721 return build_x_unary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0)),
11725 op1 = TREE_OPERAND (t, 0);
11726 if (TREE_CODE (op1) == SCOPE_REF)
11727 op1 = tsubst_qualified_id (op1, args, complain, in_decl,
11728 /*done=*/true, /*address_p=*/true);
11730 op1 = tsubst_non_call_postfix_expression (op1, args, complain,
11732 if (TREE_CODE (op1) == LABEL_DECL)
11733 return finish_label_address_expr (DECL_NAME (op1),
11734 EXPR_LOCATION (op1));
11735 return build_x_unary_op (ADDR_EXPR, op1, complain);
11740 case TRUNC_DIV_EXPR:
11741 case CEIL_DIV_EXPR:
11742 case FLOOR_DIV_EXPR:
11743 case ROUND_DIV_EXPR:
11744 case EXACT_DIV_EXPR:
11748 case TRUNC_MOD_EXPR:
11749 case FLOOR_MOD_EXPR:
11750 case TRUTH_ANDIF_EXPR:
11751 case TRUTH_ORIF_EXPR:
11752 case TRUTH_AND_EXPR:
11753 case TRUTH_OR_EXPR:
11768 return build_x_binary_op
11770 RECUR (TREE_OPERAND (t, 0)),
11771 (TREE_NO_WARNING (TREE_OPERAND (t, 0))
11773 : TREE_CODE (TREE_OPERAND (t, 0))),
11774 RECUR (TREE_OPERAND (t, 1)),
11775 (TREE_NO_WARNING (TREE_OPERAND (t, 1))
11777 : TREE_CODE (TREE_OPERAND (t, 1))),
11778 /*overloaded_p=*/NULL,
11782 return tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
11783 /*address_p=*/false);
11785 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
11786 args, complain, in_decl);
11787 return build_x_array_ref (op1, RECUR (TREE_OPERAND (t, 1)), complain);
11790 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
11791 return tsubst_copy (t, args, complain, in_decl);
11795 op1 = TREE_OPERAND (t, 0);
11798 /* When there are no ARGS, we are trying to evaluate a
11799 non-dependent expression from the parser. Trying to do
11800 the substitutions may not work. */
11802 op1 = TREE_TYPE (op1);
11806 ++cp_unevaluated_operand;
11807 ++c_inhibit_evaluation_warnings;
11808 op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
11809 /*function_p=*/false,
11810 /*integral_constant_expression_p=*/false);
11811 --cp_unevaluated_operand;
11812 --c_inhibit_evaluation_warnings;
11815 return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t),
11816 complain & tf_error);
11818 return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t),
11819 complain & tf_error);
11823 tree r = build_x_modify_expr
11824 (RECUR (TREE_OPERAND (t, 0)),
11825 TREE_CODE (TREE_OPERAND (t, 1)),
11826 RECUR (TREE_OPERAND (t, 2)),
11828 /* TREE_NO_WARNING must be set if either the expression was
11829 parenthesized or it uses an operator such as >>= rather
11830 than plain assignment. In the former case, it was already
11831 set and must be copied. In the latter case,
11832 build_x_modify_expr sets it and it must not be reset
11834 if (TREE_NO_WARNING (t))
11835 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
11840 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
11841 args, complain, in_decl);
11842 /* Remember that there was a reference to this entity. */
11845 return build_x_arrow (op1);
11849 tree placement = RECUR (TREE_OPERAND (t, 0));
11850 tree init = RECUR (TREE_OPERAND (t, 3));
11851 VEC(tree,gc) *placement_vec;
11852 VEC(tree,gc) *init_vec;
11855 if (placement == NULL_TREE)
11856 placement_vec = NULL;
11859 placement_vec = make_tree_vector ();
11860 for (; placement != NULL_TREE; placement = TREE_CHAIN (placement))
11861 VEC_safe_push (tree, gc, placement_vec, TREE_VALUE (placement));
11864 /* If there was an initializer in the original tree, but it
11865 instantiated to an empty list, then we should pass a
11866 non-NULL empty vector to tell build_new that it was an
11867 empty initializer() rather than no initializer. This can
11868 only happen when the initializer is a pack expansion whose
11869 parameter packs are of length zero. */
11870 if (init == NULL_TREE && TREE_OPERAND (t, 3) == NULL_TREE)
11874 init_vec = make_tree_vector ();
11875 if (init == void_zero_node)
11876 gcc_assert (init_vec != NULL);
11879 for (; init != NULL_TREE; init = TREE_CHAIN (init))
11880 VEC_safe_push (tree, gc, init_vec, TREE_VALUE (init));
11884 ret = build_new (&placement_vec,
11885 RECUR (TREE_OPERAND (t, 1)),
11886 RECUR (TREE_OPERAND (t, 2)),
11888 NEW_EXPR_USE_GLOBAL (t),
11891 if (placement_vec != NULL)
11892 release_tree_vector (placement_vec);
11893 if (init_vec != NULL)
11894 release_tree_vector (init_vec);
11900 return delete_sanity
11901 (RECUR (TREE_OPERAND (t, 0)),
11902 RECUR (TREE_OPERAND (t, 1)),
11903 DELETE_EXPR_USE_VEC (t),
11904 DELETE_EXPR_USE_GLOBAL (t));
11906 case COMPOUND_EXPR:
11907 return build_x_compound_expr (RECUR (TREE_OPERAND (t, 0)),
11908 RECUR (TREE_OPERAND (t, 1)),
11914 VEC(tree,gc) *call_args;
11915 unsigned int nargs, i;
11920 function = CALL_EXPR_FN (t);
11921 /* When we parsed the expression, we determined whether or
11922 not Koenig lookup should be performed. */
11923 koenig_p = KOENIG_LOOKUP_P (t);
11924 if (TREE_CODE (function) == SCOPE_REF)
11926 qualified_p = true;
11927 function = tsubst_qualified_id (function, args, complain, in_decl,
11929 /*address_p=*/false);
11933 if (TREE_CODE (function) == COMPONENT_REF)
11935 tree op = TREE_OPERAND (function, 1);
11937 qualified_p = (TREE_CODE (op) == SCOPE_REF
11938 || (BASELINK_P (op)
11939 && BASELINK_QUALIFIED_P (op)));
11942 qualified_p = false;
11944 function = tsubst_copy_and_build (function, args, complain,
11947 integral_constant_expression_p);
11949 if (BASELINK_P (function))
11950 qualified_p = true;
11953 nargs = call_expr_nargs (t);
11954 call_args = make_tree_vector ();
11955 for (i = 0; i < nargs; ++i)
11957 tree arg = CALL_EXPR_ARG (t, i);
11959 if (!PACK_EXPANSION_P (arg))
11960 VEC_safe_push (tree, gc, call_args,
11961 RECUR (CALL_EXPR_ARG (t, i)));
11964 /* Expand the pack expansion and push each entry onto
11966 arg = tsubst_pack_expansion (arg, args, complain, in_decl);
11967 if (TREE_CODE (arg) == TREE_VEC)
11969 unsigned int len, j;
11971 len = TREE_VEC_LENGTH (arg);
11972 for (j = 0; j < len; ++j)
11974 tree value = TREE_VEC_ELT (arg, j);
11975 if (value != NULL_TREE)
11976 value = convert_from_reference (value);
11977 VEC_safe_push (tree, gc, call_args, value);
11982 /* A partial substitution. Add one entry. */
11983 VEC_safe_push (tree, gc, call_args, arg);
11988 /* We do not perform argument-dependent lookup if normal
11989 lookup finds a non-function, in accordance with the
11990 expected resolution of DR 218. */
11992 && ((is_overloaded_fn (function)
11993 /* If lookup found a member function, the Koenig lookup is
11994 not appropriate, even if an unqualified-name was used
11995 to denote the function. */
11996 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function)))
11997 || TREE_CODE (function) == IDENTIFIER_NODE)
11998 /* Only do this when substitution turns a dependent call
11999 into a non-dependent call. */
12000 && type_dependent_expression_p_push (t)
12001 && !any_type_dependent_arguments_p (call_args))
12002 function = perform_koenig_lookup (function, call_args);
12004 if (TREE_CODE (function) == IDENTIFIER_NODE)
12006 unqualified_name_lookup_error (function);
12007 release_tree_vector (call_args);
12008 return error_mark_node;
12011 /* Remember that there was a reference to this entity. */
12012 if (DECL_P (function))
12013 mark_used (function);
12015 if (TREE_CODE (function) == OFFSET_REF)
12016 ret = build_offset_ref_call_from_tree (function, &call_args);
12017 else if (TREE_CODE (function) == COMPONENT_REF)
12019 if (!BASELINK_P (TREE_OPERAND (function, 1)))
12020 ret = finish_call_expr (function, &call_args,
12021 /*disallow_virtual=*/false,
12022 /*koenig_p=*/false,
12025 ret = (build_new_method_call
12026 (TREE_OPERAND (function, 0),
12027 TREE_OPERAND (function, 1),
12028 &call_args, NULL_TREE,
12029 qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL,
12034 ret = finish_call_expr (function, &call_args,
12035 /*disallow_virtual=*/qualified_p,
12039 release_tree_vector (call_args);
12045 return build_x_conditional_expr
12046 (RECUR (TREE_OPERAND (t, 0)),
12047 RECUR (TREE_OPERAND (t, 1)),
12048 RECUR (TREE_OPERAND (t, 2)),
12051 case PSEUDO_DTOR_EXPR:
12052 return finish_pseudo_destructor_expr
12053 (RECUR (TREE_OPERAND (t, 0)),
12054 RECUR (TREE_OPERAND (t, 1)),
12055 RECUR (TREE_OPERAND (t, 2)));
12059 tree purpose, value, chain;
12061 if (t == void_list_node)
12064 if ((TREE_PURPOSE (t) && PACK_EXPANSION_P (TREE_PURPOSE (t)))
12065 || (TREE_VALUE (t) && PACK_EXPANSION_P (TREE_VALUE (t))))
12067 /* We have pack expansions, so expand those and
12068 create a new list out of it. */
12069 tree purposevec = NULL_TREE;
12070 tree valuevec = NULL_TREE;
12074 /* Expand the argument expressions. */
12075 if (TREE_PURPOSE (t))
12076 purposevec = tsubst_pack_expansion (TREE_PURPOSE (t), args,
12077 complain, in_decl);
12078 if (TREE_VALUE (t))
12079 valuevec = tsubst_pack_expansion (TREE_VALUE (t), args,
12080 complain, in_decl);
12082 /* Build the rest of the list. */
12083 chain = TREE_CHAIN (t);
12084 if (chain && chain != void_type_node)
12085 chain = RECUR (chain);
12087 /* Determine the number of arguments. */
12088 if (purposevec && TREE_CODE (purposevec) == TREE_VEC)
12090 len = TREE_VEC_LENGTH (purposevec);
12091 gcc_assert (!valuevec || len == TREE_VEC_LENGTH (valuevec));
12093 else if (TREE_CODE (valuevec) == TREE_VEC)
12094 len = TREE_VEC_LENGTH (valuevec);
12097 /* Since we only performed a partial substitution into
12098 the argument pack, we only return a single list
12100 if (purposevec == TREE_PURPOSE (t)
12101 && valuevec == TREE_VALUE (t)
12102 && chain == TREE_CHAIN (t))
12105 return tree_cons (purposevec, valuevec, chain);
12108 /* Convert the argument vectors into a TREE_LIST */
12112 /* Grab the Ith values. */
12114 purpose = purposevec ? TREE_VEC_ELT (purposevec, i)
12117 = valuevec ? convert_from_reference (TREE_VEC_ELT (valuevec, i))
12120 /* Build the list (backwards). */
12121 chain = tree_cons (purpose, value, chain);
12127 purpose = TREE_PURPOSE (t);
12129 purpose = RECUR (purpose);
12130 value = TREE_VALUE (t);
12132 value = RECUR (value);
12133 chain = TREE_CHAIN (t);
12134 if (chain && chain != void_type_node)
12135 chain = RECUR (chain);
12136 if (purpose == TREE_PURPOSE (t)
12137 && value == TREE_VALUE (t)
12138 && chain == TREE_CHAIN (t))
12140 return tree_cons (purpose, value, chain);
12143 case COMPONENT_REF:
12149 object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
12150 args, complain, in_decl);
12151 /* Remember that there was a reference to this entity. */
12152 if (DECL_P (object))
12153 mark_used (object);
12154 object_type = TREE_TYPE (object);
12156 member = TREE_OPERAND (t, 1);
12157 if (BASELINK_P (member))
12158 member = tsubst_baselink (member,
12159 non_reference (TREE_TYPE (object)),
12160 args, complain, in_decl);
12162 member = tsubst_copy (member, args, complain, in_decl);
12163 if (member == error_mark_node)
12164 return error_mark_node;
12166 if (object_type && !CLASS_TYPE_P (object_type))
12168 if (SCALAR_TYPE_P (object_type))
12170 tree s = NULL_TREE;
12171 tree dtor = member;
12173 if (TREE_CODE (dtor) == SCOPE_REF)
12175 s = TREE_OPERAND (dtor, 0);
12176 dtor = TREE_OPERAND (dtor, 1);
12178 if (TREE_CODE (dtor) == BIT_NOT_EXPR)
12180 dtor = TREE_OPERAND (dtor, 0);
12182 return finish_pseudo_destructor_expr (object, s, dtor);
12186 else if (TREE_CODE (member) == SCOPE_REF
12187 && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
12192 /* Lookup the template functions now that we know what the
12194 tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
12195 args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
12196 member = lookup_qualified_name (TREE_OPERAND (member, 0), tmpl,
12197 /*is_type_p=*/false,
12198 /*complain=*/false);
12199 if (BASELINK_P (member))
12201 BASELINK_FUNCTIONS (member)
12202 = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
12204 member = (adjust_result_of_qualified_name_lookup
12205 (member, BINFO_TYPE (BASELINK_BINFO (member)),
12210 qualified_name_lookup_error (object_type, tmpl, member,
12212 return error_mark_node;
12215 else if (TREE_CODE (member) == SCOPE_REF
12216 && !CLASS_TYPE_P (TREE_OPERAND (member, 0))
12217 && TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL)
12219 if (complain & tf_error)
12221 if (TYPE_P (TREE_OPERAND (member, 0)))
12222 error ("%qT is not a class or namespace",
12223 TREE_OPERAND (member, 0));
12225 error ("%qD is not a class or namespace",
12226 TREE_OPERAND (member, 0));
12228 return error_mark_node;
12230 else if (TREE_CODE (member) == FIELD_DECL)
12231 return finish_non_static_data_member (member, object, NULL_TREE);
12233 return finish_class_member_access_expr (object, member,
12234 /*template_p=*/false,
12240 (RECUR (TREE_OPERAND (t, 0)));
12244 VEC(constructor_elt,gc) *n;
12245 constructor_elt *ce;
12246 unsigned HOST_WIDE_INT idx;
12247 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
12248 bool process_index_p;
12250 bool need_copy_p = false;
12253 if (type == error_mark_node)
12254 return error_mark_node;
12256 /* digest_init will do the wrong thing if we let it. */
12257 if (type && TYPE_PTRMEMFUNC_P (type))
12260 /* We do not want to process the index of aggregate
12261 initializers as they are identifier nodes which will be
12262 looked up by digest_init. */
12263 process_index_p = !(type && MAYBE_CLASS_TYPE_P (type));
12265 n = VEC_copy (constructor_elt, gc, CONSTRUCTOR_ELTS (t));
12266 newlen = VEC_length (constructor_elt, n);
12267 for (idx = 0; VEC_iterate (constructor_elt, n, idx, ce); idx++)
12269 if (ce->index && process_index_p)
12270 ce->index = RECUR (ce->index);
12272 if (PACK_EXPANSION_P (ce->value))
12274 /* Substitute into the pack expansion. */
12275 ce->value = tsubst_pack_expansion (ce->value, args, complain,
12278 if (ce->value == error_mark_node)
12280 else if (TREE_VEC_LENGTH (ce->value) == 1)
12281 /* Just move the argument into place. */
12282 ce->value = TREE_VEC_ELT (ce->value, 0);
12285 /* Update the length of the final CONSTRUCTOR
12286 arguments vector, and note that we will need to
12288 newlen = newlen + TREE_VEC_LENGTH (ce->value) - 1;
12289 need_copy_p = true;
12293 ce->value = RECUR (ce->value);
12298 VEC(constructor_elt,gc) *old_n = n;
12300 n = VEC_alloc (constructor_elt, gc, newlen);
12301 for (idx = 0; VEC_iterate (constructor_elt, old_n, idx, ce);
12304 if (TREE_CODE (ce->value) == TREE_VEC)
12306 int i, len = TREE_VEC_LENGTH (ce->value);
12307 for (i = 0; i < len; ++i)
12308 CONSTRUCTOR_APPEND_ELT (n, 0,
12309 TREE_VEC_ELT (ce->value, i));
12312 CONSTRUCTOR_APPEND_ELT (n, 0, ce->value);
12316 r = build_constructor (init_list_type_node, n);
12317 CONSTRUCTOR_IS_DIRECT_INIT (r) = CONSTRUCTOR_IS_DIRECT_INIT (t);
12319 if (TREE_HAS_CONSTRUCTOR (t))
12320 return finish_compound_literal (type, r);
12327 tree operand_0 = RECUR (TREE_OPERAND (t, 0));
12328 if (TYPE_P (operand_0))
12329 return get_typeid (operand_0);
12330 return build_typeid (operand_0);
12340 tree r = tsubst_copy (t, args, complain, in_decl);
12342 if (TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
12343 /* If the original type was a reference, we'll be wrapped in
12344 the appropriate INDIRECT_REF. */
12345 r = convert_from_reference (r);
12350 return build_x_va_arg (RECUR (TREE_OPERAND (t, 0)),
12351 tsubst_copy (TREE_TYPE (t), args, complain,
12354 case OFFSETOF_EXPR:
12355 return finish_offsetof (RECUR (TREE_OPERAND (t, 0)));
12359 tree type1 = tsubst_copy (TRAIT_EXPR_TYPE1 (t), args,
12360 complain, in_decl);
12362 tree type2 = TRAIT_EXPR_TYPE2 (t);
12364 type2 = tsubst_copy (type2, args, complain, in_decl);
12366 return finish_trait_expr (TRAIT_EXPR_KIND (t), type1, type2);
12371 tree old_stmt_expr = cur_stmt_expr;
12372 tree stmt_expr = begin_stmt_expr ();
12374 cur_stmt_expr = stmt_expr;
12375 tsubst_expr (STMT_EXPR_STMT (t), args, complain, in_decl,
12376 integral_constant_expression_p);
12377 stmt_expr = finish_stmt_expr (stmt_expr, false);
12378 cur_stmt_expr = old_stmt_expr;
12384 t = tsubst_copy (t, args, complain, in_decl);
12385 /* As in finish_id_expression, we resolve enumeration constants
12386 to their underlying values. */
12387 if (TREE_CODE (t) == CONST_DECL)
12389 used_types_insert (TREE_TYPE (t));
12390 return DECL_INITIAL (t);
12396 tree r = build_lambda_expr ();
12398 tree type = tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
12399 TREE_TYPE (r) = type;
12400 CLASSTYPE_LAMBDA_EXPR (type) = r;
12402 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r)
12403 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t);
12404 LAMBDA_EXPR_MUTABLE_P (r) = LAMBDA_EXPR_MUTABLE_P (t);
12405 LAMBDA_EXPR_DISCRIMINATOR (r)
12406 = (LAMBDA_EXPR_DISCRIMINATOR (t));
12407 LAMBDA_EXPR_CAPTURE_LIST (r)
12408 = RECUR (LAMBDA_EXPR_CAPTURE_LIST (t));
12409 LAMBDA_EXPR_THIS_CAPTURE (r)
12410 = RECUR (LAMBDA_EXPR_THIS_CAPTURE (t));
12411 LAMBDA_EXPR_EXTRA_SCOPE (r)
12412 = RECUR (LAMBDA_EXPR_EXTRA_SCOPE (t));
12414 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
12415 determine_visibility (TYPE_NAME (type));
12416 /* Now that we know visibility, instantiate the type so we have a
12417 declaration of the op() for later calls to lambda_function. */
12418 complete_type (type);
12420 type = tsubst (LAMBDA_EXPR_RETURN_TYPE (t), args, complain, in_decl);
12422 apply_lambda_return_type (r, type);
12424 return build_lambda_object (r);
12428 /* Handle Objective-C++ constructs, if appropriate. */
12431 = objcp_tsubst_copy_and_build (t, args, complain,
12432 in_decl, /*function_p=*/false);
12436 return tsubst_copy (t, args, complain, in_decl);
12442 /* Verify that the instantiated ARGS are valid. For type arguments,
12443 make sure that the type is not variably modified. For non-type arguments,
12444 make sure they are constants if they are integral or enumerations.
12445 Emit an error under control of COMPLAIN, and return TRUE on error. */
12448 check_instantiated_arg (tree tmpl, tree t, tsubst_flags_t complain)
12450 if (ARGUMENT_PACK_P (t))
12452 tree vec = ARGUMENT_PACK_ARGS (t);
12453 int len = TREE_VEC_LENGTH (vec);
12454 bool result = false;
12457 for (i = 0; i < len; ++i)
12458 if (check_instantiated_arg (tmpl, TREE_VEC_ELT (vec, i), complain))
12462 else if (TYPE_P (t))
12464 if (variably_modified_type_p (t, NULL_TREE))
12466 if (complain & tf_error)
12467 error ("%qT is a variably modified type", t);
12471 /* A non-type argument of integral or enumerated type must be a
12473 else if (TREE_TYPE (t)
12474 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t))
12475 && !TREE_CONSTANT (t))
12477 if (complain & tf_error)
12478 error ("integral expression %qE is not constant", t);
12485 check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain)
12487 int ix, len = DECL_NTPARMS (tmpl);
12488 bool result = false;
12490 for (ix = 0; ix != len; ix++)
12492 if (check_instantiated_arg (tmpl, TREE_VEC_ELT (args, ix), complain))
12495 if (result && (complain & tf_error))
12496 error (" trying to instantiate %qD", tmpl);
12500 /* Instantiate the indicated variable or function template TMPL with
12501 the template arguments in TARG_PTR. */
12504 instantiate_template (tree tmpl, tree orig_args, tsubst_flags_t complain)
12506 tree targ_ptr = orig_args;
12510 HOST_WIDE_INT saved_processing_template_decl;
12512 if (tmpl == error_mark_node)
12513 return error_mark_node;
12515 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
12517 /* If this function is a clone, handle it specially. */
12518 if (DECL_CLONED_FUNCTION_P (tmpl))
12523 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
12524 DECL_CLONED_FUNCTION. */
12525 spec = instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl),
12526 targ_ptr, complain);
12527 if (spec == error_mark_node)
12528 return error_mark_node;
12530 /* Look for the clone. */
12531 FOR_EACH_CLONE (clone, spec)
12532 if (DECL_NAME (clone) == DECL_NAME (tmpl))
12534 /* We should always have found the clone by now. */
12535 gcc_unreachable ();
12539 /* Check to see if we already have this specialization. */
12540 gen_tmpl = most_general_template (tmpl);
12541 if (tmpl != gen_tmpl)
12542 /* The TMPL is a partial instantiation. To get a full set of
12543 arguments we must add the arguments used to perform the
12544 partial instantiation. */
12545 targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl),
12548 /* It would be nice to avoid hashing here and then again in tsubst_decl,
12549 but it doesn't seem to be on the hot path. */
12550 spec = retrieve_specialization (gen_tmpl, targ_ptr, 0);
12552 gcc_assert (tmpl == gen_tmpl
12553 || ((fndecl = retrieve_specialization (tmpl, orig_args, 0))
12555 || fndecl == NULL_TREE);
12557 if (spec != NULL_TREE)
12560 if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr),
12562 return error_mark_node;
12564 /* We are building a FUNCTION_DECL, during which the access of its
12565 parameters and return types have to be checked. However this
12566 FUNCTION_DECL which is the desired context for access checking
12567 is not built yet. We solve this chicken-and-egg problem by
12568 deferring all checks until we have the FUNCTION_DECL. */
12569 push_deferring_access_checks (dk_deferred);
12571 /* Although PROCESSING_TEMPLATE_DECL may be true at this point
12572 (because, for example, we have encountered a non-dependent
12573 function call in the body of a template function and must now
12574 determine which of several overloaded functions will be called),
12575 within the instantiation itself we are not processing a
12577 saved_processing_template_decl = processing_template_decl;
12578 processing_template_decl = 0;
12579 /* Substitute template parameters to obtain the specialization. */
12580 fndecl = tsubst (DECL_TEMPLATE_RESULT (gen_tmpl),
12581 targ_ptr, complain, gen_tmpl);
12582 processing_template_decl = saved_processing_template_decl;
12583 if (fndecl == error_mark_node)
12584 return error_mark_node;
12586 /* Now we know the specialization, compute access previously
12588 push_access_scope (fndecl);
12590 /* Some typedefs referenced from within the template code need to be access
12591 checked at template instantiation time, i.e now. These types were
12592 added to the template at parsing time. Let's get those and perfom
12593 the acces checks then. */
12594 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (tmpl), targ_ptr);
12595 perform_deferred_access_checks ();
12596 pop_access_scope (fndecl);
12597 pop_deferring_access_checks ();
12599 /* The DECL_TI_TEMPLATE should always be the immediate parent
12600 template, not the most general template. */
12601 DECL_TI_TEMPLATE (fndecl) = tmpl;
12603 /* If we've just instantiated the main entry point for a function,
12604 instantiate all the alternate entry points as well. We do this
12605 by cloning the instantiation of the main entry point, not by
12606 instantiating the template clones. */
12607 if (TREE_CHAIN (gen_tmpl) && DECL_CLONED_FUNCTION_P (TREE_CHAIN (gen_tmpl)))
12608 clone_function_decl (fndecl, /*update_method_vec_p=*/0);
12613 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
12614 NARGS elements of the arguments that are being used when calling
12615 it. TARGS is a vector into which the deduced template arguments
12618 Return zero for success, 2 for an incomplete match that doesn't resolve
12619 all the types, and 1 for complete failure. An error message will be
12620 printed only for an incomplete match.
12622 If FN is a conversion operator, or we are trying to produce a specific
12623 specialization, RETURN_TYPE is the return type desired.
12625 The EXPLICIT_TARGS are explicit template arguments provided via a
12628 The parameter STRICT is one of:
12631 We are deducing arguments for a function call, as in
12632 [temp.deduct.call].
12635 We are deducing arguments for a conversion function, as in
12636 [temp.deduct.conv].
12639 We are deducing arguments when doing an explicit instantiation
12640 as in [temp.explicit], when determining an explicit specialization
12641 as in [temp.expl.spec], or when taking the address of a function
12642 template, as in [temp.deduct.funcaddr]. */
12645 fn_type_unification (tree fn,
12646 tree explicit_targs,
12649 unsigned int nargs,
12651 unification_kind_t strict,
12657 bool incomplete_argument_packs_p = false;
12659 gcc_assert (TREE_CODE (fn) == TEMPLATE_DECL);
12661 fntype = TREE_TYPE (fn);
12662 if (explicit_targs)
12666 The specified template arguments must match the template
12667 parameters in kind (i.e., type, nontype, template), and there
12668 must not be more arguments than there are parameters;
12669 otherwise type deduction fails.
12671 Nontype arguments must match the types of the corresponding
12672 nontype template parameters, or must be convertible to the
12673 types of the corresponding nontype parameters as specified in
12674 _temp.arg.nontype_, otherwise type deduction fails.
12676 All references in the function type of the function template
12677 to the corresponding template parameters are replaced by the
12678 specified template argument values. If a substitution in a
12679 template parameter or in the function type of the function
12680 template results in an invalid type, type deduction fails. */
12681 tree tparms = DECL_INNERMOST_TEMPLATE_PARMS (fn);
12682 int i, len = TREE_VEC_LENGTH (tparms);
12683 tree converted_args;
12684 bool incomplete = false;
12686 if (explicit_targs == error_mark_node)
12690 = (coerce_template_parms (tparms, explicit_targs, NULL_TREE, tf_none,
12691 /*require_all_args=*/false,
12692 /*use_default_args=*/false));
12693 if (converted_args == error_mark_node)
12696 /* Substitute the explicit args into the function type. This is
12697 necessary so that, for instance, explicitly declared function
12698 arguments can match null pointed constants. If we were given
12699 an incomplete set of explicit args, we must not do semantic
12700 processing during substitution as we could create partial
12702 for (i = 0; i < len; i++)
12704 tree parm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
12705 bool parameter_pack = false;
12707 /* Dig out the actual parm. */
12708 if (TREE_CODE (parm) == TYPE_DECL
12709 || TREE_CODE (parm) == TEMPLATE_DECL)
12711 parm = TREE_TYPE (parm);
12712 parameter_pack = TEMPLATE_TYPE_PARAMETER_PACK (parm);
12714 else if (TREE_CODE (parm) == PARM_DECL)
12716 parm = DECL_INITIAL (parm);
12717 parameter_pack = TEMPLATE_PARM_PARAMETER_PACK (parm);
12720 if (parameter_pack)
12724 template_parm_level_and_index (parm, &level, &idx);
12726 /* Mark the argument pack as "incomplete". We could
12727 still deduce more arguments during unification. */
12728 targ = TMPL_ARG (converted_args, level, idx);
12731 ARGUMENT_PACK_INCOMPLETE_P(targ) = 1;
12732 ARGUMENT_PACK_EXPLICIT_ARGS (targ)
12733 = ARGUMENT_PACK_ARGS (targ);
12736 /* We have some incomplete argument packs. */
12737 incomplete_argument_packs_p = true;
12741 if (incomplete_argument_packs_p)
12742 /* Any substitution is guaranteed to be incomplete if there
12743 are incomplete argument packs, because we can still deduce
12747 incomplete = NUM_TMPL_ARGS (explicit_targs) != NUM_TMPL_ARGS (targs);
12749 processing_template_decl += incomplete;
12750 fntype = tsubst (fntype, converted_args, tf_none, NULL_TREE);
12751 processing_template_decl -= incomplete;
12753 if (fntype == error_mark_node)
12756 /* Place the explicitly specified arguments in TARGS. */
12757 for (i = NUM_TMPL_ARGS (converted_args); i--;)
12758 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (converted_args, i);
12761 /* Never do unification on the 'this' parameter. */
12762 parms = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (fntype));
12768 parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms);
12769 new_args = XALLOCAVEC (tree, nargs + 1);
12770 new_args[0] = return_type;
12771 memcpy (new_args + 1, args, nargs * sizeof (tree));
12776 /* We allow incomplete unification without an error message here
12777 because the standard doesn't seem to explicitly prohibit it. Our
12778 callers must be ready to deal with unification failures in any
12780 result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
12781 targs, parms, args, nargs, /*subr=*/0,
12784 if (result == 0 && incomplete_argument_packs_p)
12786 int i, len = NUM_TMPL_ARGS (targs);
12788 /* Clear the "incomplete" flags on all argument packs. */
12789 for (i = 0; i < len; i++)
12791 tree arg = TREE_VEC_ELT (targs, i);
12792 if (ARGUMENT_PACK_P (arg))
12794 ARGUMENT_PACK_INCOMPLETE_P (arg) = 0;
12795 ARGUMENT_PACK_EXPLICIT_ARGS (arg) = NULL_TREE;
12800 /* Now that we have bindings for all of the template arguments,
12801 ensure that the arguments deduced for the template template
12802 parameters have compatible template parameter lists. We cannot
12803 check this property before we have deduced all template
12804 arguments, because the template parameter types of a template
12805 template parameter might depend on prior template parameters
12806 deduced after the template template parameter. The following
12807 ill-formed example illustrates this issue:
12809 template<typename T, template<T> class C> void f(C<5>, T);
12811 template<int N> struct X {};
12814 f(X<5>(), 5l); // error: template argument deduction fails
12817 The template parameter list of 'C' depends on the template type
12818 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
12819 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
12820 time that we deduce 'C'. */
12822 && !template_template_parm_bindings_ok_p
12823 (DECL_INNERMOST_TEMPLATE_PARMS (fn), targs))
12827 /* All is well so far. Now, check:
12831 When all template arguments have been deduced, all uses of
12832 template parameters in nondeduced contexts are replaced with
12833 the corresponding deduced argument values. If the
12834 substitution results in an invalid type, as described above,
12835 type deduction fails. */
12837 tree substed = tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE);
12838 if (substed == error_mark_node)
12841 /* If we're looking for an exact match, check that what we got
12842 is indeed an exact match. It might not be if some template
12843 parameters are used in non-deduced contexts. */
12844 if (strict == DEDUCE_EXACT)
12849 = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (substed));
12851 sarg = tree_cons (NULL_TREE, TREE_TYPE (substed), sarg);
12852 for (i = 0; i < nargs && sarg; ++i, sarg = TREE_CHAIN (sarg))
12853 if (!same_type_p (args[i], TREE_VALUE (sarg)))
12861 /* Adjust types before performing type deduction, as described in
12862 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
12863 sections are symmetric. PARM is the type of a function parameter
12864 or the return type of the conversion function. ARG is the type of
12865 the argument passed to the call, or the type of the value
12866 initialized with the result of the conversion function.
12867 ARG_EXPR is the original argument expression, which may be null. */
12870 maybe_adjust_types_for_deduction (unification_kind_t strict,
12884 /* Swap PARM and ARG throughout the remainder of this
12885 function; the handling is precisely symmetric since PARM
12886 will initialize ARG rather than vice versa. */
12894 /* There is nothing to do in this case. */
12898 gcc_unreachable ();
12901 if (TREE_CODE (*parm) != REFERENCE_TYPE)
12903 /* [temp.deduct.call]
12905 If P is not a reference type:
12907 --If A is an array type, the pointer type produced by the
12908 array-to-pointer standard conversion (_conv.array_) is
12909 used in place of A for type deduction; otherwise,
12911 --If A is a function type, the pointer type produced by
12912 the function-to-pointer standard conversion
12913 (_conv.func_) is used in place of A for type deduction;
12916 --If A is a cv-qualified type, the top level
12917 cv-qualifiers of A's type are ignored for type
12919 if (TREE_CODE (*arg) == ARRAY_TYPE)
12920 *arg = build_pointer_type (TREE_TYPE (*arg));
12921 else if (TREE_CODE (*arg) == FUNCTION_TYPE)
12922 *arg = build_pointer_type (*arg);
12924 *arg = TYPE_MAIN_VARIANT (*arg);
12927 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
12928 of the form T&&, where T is a template parameter, and the argument
12929 is an lvalue, T is deduced as A& */
12930 if (TREE_CODE (*parm) == REFERENCE_TYPE
12931 && TYPE_REF_IS_RVALUE (*parm)
12932 && TREE_CODE (TREE_TYPE (*parm)) == TEMPLATE_TYPE_PARM
12933 && cp_type_quals (TREE_TYPE (*parm)) == TYPE_UNQUALIFIED
12934 && arg_expr && real_lvalue_p (arg_expr))
12935 *arg = build_reference_type (*arg);
12937 /* [temp.deduct.call]
12939 If P is a cv-qualified type, the top level cv-qualifiers
12940 of P's type are ignored for type deduction. If P is a
12941 reference type, the type referred to by P is used for
12943 *parm = TYPE_MAIN_VARIANT (*parm);
12944 if (TREE_CODE (*parm) == REFERENCE_TYPE)
12946 *parm = TREE_TYPE (*parm);
12947 result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
12950 /* DR 322. For conversion deduction, remove a reference type on parm
12951 too (which has been swapped into ARG). */
12952 if (strict == DEDUCE_CONV && TREE_CODE (*arg) == REFERENCE_TYPE)
12953 *arg = TREE_TYPE (*arg);
12958 /* Most parms like fn_type_unification.
12960 If SUBR is 1, we're being called recursively (to unify the
12961 arguments of a function or method parameter of a function
12965 type_unification_real (tree tparms,
12969 unsigned int xnargs,
12971 unification_kind_t strict,
12974 tree parm, arg, arg_expr;
12976 int ntparms = TREE_VEC_LENGTH (tparms);
12978 int saw_undeduced = 0;
12981 unsigned int nargs;
12984 gcc_assert (TREE_CODE (tparms) == TREE_VEC);
12985 gcc_assert (xparms == NULL_TREE || TREE_CODE (xparms) == TREE_LIST);
12986 gcc_assert (ntparms > 0);
12991 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL | UNIFY_ALLOW_MORE_CV_QUAL
12992 | UNIFY_ALLOW_DERIVED);
12996 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
13000 sub_strict = UNIFY_ALLOW_NONE;
13004 gcc_unreachable ();
13013 while (parms && parms != void_list_node
13016 if (TREE_CODE (TREE_VALUE (parms)) == TYPE_PACK_EXPANSION)
13019 parm = TREE_VALUE (parms);
13020 parms = TREE_CHAIN (parms);
13025 if (arg == error_mark_node)
13027 if (arg == unknown_type_node)
13028 /* We can't deduce anything from this, but we might get all the
13029 template args from other function args. */
13032 /* Conversions will be performed on a function argument that
13033 corresponds with a function parameter that contains only
13034 non-deducible template parameters and explicitly specified
13035 template parameters. */
13036 if (!uses_template_parms (parm))
13041 type = TREE_TYPE (arg);
13045 if (same_type_p (parm, type))
13047 if (strict != DEDUCE_EXACT
13048 && can_convert_arg (parm, type, TYPE_P (arg) ? NULL_TREE : arg,
13057 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
13058 if (type_unknown_p (arg))
13060 /* [temp.deduct.type]
13062 A template-argument can be deduced from a pointer to
13063 function or pointer to member function argument if
13064 the set of overloaded functions does not contain
13065 function templates and at most one of a set of
13066 overloaded functions provides a unique match. */
13067 if (resolve_overloaded_unification
13068 (tparms, targs, parm, arg, strict, sub_strict))
13074 arg = unlowered_expr_type (arg);
13075 if (arg == error_mark_node)
13080 int arg_strict = sub_strict;
13083 arg_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg,
13086 if (arg == init_list_type_node && arg_expr)
13088 if (unify (tparms, targs, parm, arg, arg_strict))
13095 && parms != void_list_node
13096 && TREE_CODE (TREE_VALUE (parms)) == TYPE_PACK_EXPANSION)
13098 /* Unify the remaining arguments with the pack expansion type. */
13100 tree parmvec = make_tree_vec (1);
13102 /* Allocate a TREE_VEC and copy in all of the arguments */
13103 argvec = make_tree_vec (nargs - ia);
13104 for (i = 0; ia < nargs; ++ia, ++i)
13105 TREE_VEC_ELT (argvec, i) = args[ia];
13107 /* Copy the parameter into parmvec. */
13108 TREE_VEC_ELT (parmvec, 0) = TREE_VALUE (parms);
13109 if (unify_pack_expansion (tparms, targs, parmvec, argvec, strict,
13110 /*call_args_p=*/true, /*subr=*/subr))
13113 /* Advance to the end of the list of parameters. */
13114 parms = TREE_CHAIN (parms);
13117 /* Fail if we've reached the end of the parm list, and more args
13118 are present, and the parm list isn't variadic. */
13119 if (ia < nargs && parms == void_list_node)
13121 /* Fail if parms are left and they don't have default values. */
13122 if (parms && parms != void_list_node
13123 && TREE_PURPOSE (parms) == NULL_TREE)
13127 for (i = 0; i < ntparms; i++)
13128 if (!TREE_VEC_ELT (targs, i))
13132 if (TREE_VEC_ELT (tparms, i) == error_mark_node)
13135 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
13137 /* If this is an undeduced nontype parameter that depends on
13138 a type parameter, try another pass; its type may have been
13139 deduced from a later argument than the one from which
13140 this parameter can be deduced. */
13141 if (TREE_CODE (tparm) == PARM_DECL
13142 && uses_template_parms (TREE_TYPE (tparm))
13143 && !saw_undeduced++)
13146 /* Core issue #226 (C++0x) [temp.deduct]:
13148 If a template argument has not been deduced, its
13149 default template argument, if any, is used.
13151 When we are in C++98 mode, TREE_PURPOSE will either
13152 be NULL_TREE or ERROR_MARK_NODE, so we do not need
13153 to explicitly check cxx_dialect here. */
13154 if (TREE_PURPOSE (TREE_VEC_ELT (tparms, i)))
13156 tree arg = tsubst_template_arg
13157 (TREE_PURPOSE (TREE_VEC_ELT (tparms, i)),
13158 targs, tf_none, NULL_TREE);
13159 if (arg == error_mark_node)
13163 TREE_VEC_ELT (targs, i) = arg;
13168 /* If the type parameter is a parameter pack, then it will
13169 be deduced to an empty parameter pack. */
13170 if (template_parameter_pack_p (tparm))
13174 if (TREE_CODE (tparm) == TEMPLATE_PARM_INDEX)
13176 arg = make_node (NONTYPE_ARGUMENT_PACK);
13177 TREE_TYPE (arg) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm));
13178 TREE_CONSTANT (arg) = 1;
13181 arg = cxx_make_type (TYPE_ARGUMENT_PACK);
13183 SET_ARGUMENT_PACK_ARGS (arg, make_tree_vec (0));
13185 TREE_VEC_ELT (targs, i) = arg;
13195 /* Subroutine of type_unification_real. Args are like the variables
13196 at the call site. ARG is an overloaded function (or template-id);
13197 we try deducing template args from each of the overloads, and if
13198 only one succeeds, we go with that. Modifies TARGS and returns
13199 true on success. */
13202 resolve_overloaded_unification (tree tparms,
13206 unification_kind_t strict,
13209 tree tempargs = copy_node (targs);
13211 tree goodfn = NULL_TREE;
13214 if (TREE_CODE (arg) == ADDR_EXPR)
13216 arg = TREE_OPERAND (arg, 0);
13222 if (TREE_CODE (arg) == COMPONENT_REF)
13223 /* Handle `&x' where `x' is some static or non-static member
13225 arg = TREE_OPERAND (arg, 1);
13227 if (TREE_CODE (arg) == OFFSET_REF)
13228 arg = TREE_OPERAND (arg, 1);
13230 /* Strip baselink information. */
13231 if (BASELINK_P (arg))
13232 arg = BASELINK_FUNCTIONS (arg);
13234 if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
13236 /* If we got some explicit template args, we need to plug them into
13237 the affected templates before we try to unify, in case the
13238 explicit args will completely resolve the templates in question. */
13240 tree expl_subargs = TREE_OPERAND (arg, 1);
13241 arg = TREE_OPERAND (arg, 0);
13243 for (; arg; arg = OVL_NEXT (arg))
13245 tree fn = OVL_CURRENT (arg);
13246 tree subargs, elem;
13248 if (TREE_CODE (fn) != TEMPLATE_DECL)
13251 ++processing_template_decl;
13252 subargs = get_bindings (fn, DECL_TEMPLATE_RESULT (fn),
13253 expl_subargs, /*check_ret=*/false);
13256 elem = tsubst (TREE_TYPE (fn), subargs, tf_none, NULL_TREE);
13257 if (try_one_overload (tparms, targs, tempargs, parm,
13258 elem, strict, sub_strict, addr_p)
13259 && (!goodfn || !decls_match (goodfn, elem)))
13265 --processing_template_decl;
13268 else if (TREE_CODE (arg) != OVERLOAD
13269 && TREE_CODE (arg) != FUNCTION_DECL)
13270 /* If ARG is, for example, "(0, &f)" then its type will be unknown
13271 -- but the deduction does not succeed because the expression is
13272 not just the function on its own. */
13275 for (; arg; arg = OVL_NEXT (arg))
13276 if (try_one_overload (tparms, targs, tempargs, parm,
13277 TREE_TYPE (OVL_CURRENT (arg)),
13278 strict, sub_strict, addr_p)
13279 && (!goodfn || !decls_match (goodfn, OVL_CURRENT (arg))))
13281 goodfn = OVL_CURRENT (arg);
13285 /* [temp.deduct.type] A template-argument can be deduced from a pointer
13286 to function or pointer to member function argument if the set of
13287 overloaded functions does not contain function templates and at most
13288 one of a set of overloaded functions provides a unique match.
13290 So if we found multiple possibilities, we return success but don't
13291 deduce anything. */
13295 int i = TREE_VEC_LENGTH (targs);
13297 if (TREE_VEC_ELT (tempargs, i))
13298 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (tempargs, i);
13306 /* Subroutine of resolve_overloaded_unification; does deduction for a single
13307 overload. Fills TARGS with any deduced arguments, or error_mark_node if
13308 different overloads deduce different arguments for a given parm.
13309 ADDR_P is true if the expression for which deduction is being
13310 performed was of the form "& fn" rather than simply "fn".
13312 Returns 1 on success. */
13315 try_one_overload (tree tparms,
13320 unification_kind_t strict,
13328 /* [temp.deduct.type] A template-argument can be deduced from a pointer
13329 to function or pointer to member function argument if the set of
13330 overloaded functions does not contain function templates and at most
13331 one of a set of overloaded functions provides a unique match.
13333 So if this is a template, just return success. */
13335 if (uses_template_parms (arg))
13338 if (TREE_CODE (arg) == METHOD_TYPE)
13339 arg = build_ptrmemfunc_type (build_pointer_type (arg));
13341 arg = build_pointer_type (arg);
13343 sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg, NULL);
13345 /* We don't copy orig_targs for this because if we have already deduced
13346 some template args from previous args, unify would complain when we
13347 try to deduce a template parameter for the same argument, even though
13348 there isn't really a conflict. */
13349 nargs = TREE_VEC_LENGTH (targs);
13350 tempargs = make_tree_vec (nargs);
13352 if (unify (tparms, tempargs, parm, arg, sub_strict) != 0)
13355 /* First make sure we didn't deduce anything that conflicts with
13356 explicitly specified args. */
13357 for (i = nargs; i--; )
13359 tree elt = TREE_VEC_ELT (tempargs, i);
13360 tree oldelt = TREE_VEC_ELT (orig_targs, i);
13364 else if (uses_template_parms (elt))
13365 /* Since we're unifying against ourselves, we will fill in
13366 template args used in the function parm list with our own
13367 template parms. Discard them. */
13368 TREE_VEC_ELT (tempargs, i) = NULL_TREE;
13369 else if (oldelt && !template_args_equal (oldelt, elt))
13373 for (i = nargs; i--; )
13375 tree elt = TREE_VEC_ELT (tempargs, i);
13378 TREE_VEC_ELT (targs, i) = elt;
13384 /* PARM is a template class (perhaps with unbound template
13385 parameters). ARG is a fully instantiated type. If ARG can be
13386 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
13387 TARGS are as for unify. */
13390 try_class_unification (tree tparms, tree targs, tree parm, tree arg)
13392 tree copy_of_targs;
13394 if (!CLASSTYPE_TEMPLATE_INFO (arg)
13395 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg))
13396 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm))))
13399 /* We need to make a new template argument vector for the call to
13400 unify. If we used TARGS, we'd clutter it up with the result of
13401 the attempted unification, even if this class didn't work out.
13402 We also don't want to commit ourselves to all the unifications
13403 we've already done, since unification is supposed to be done on
13404 an argument-by-argument basis. In other words, consider the
13405 following pathological case:
13407 template <int I, int J, int K>
13410 template <int I, int J>
13411 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
13413 template <int I, int J, int K>
13414 void f(S<I, J, K>, S<I, I, I>);
13423 Now, by the time we consider the unification involving `s2', we
13424 already know that we must have `f<0, 0, 0>'. But, even though
13425 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
13426 because there are two ways to unify base classes of S<0, 1, 2>
13427 with S<I, I, I>. If we kept the already deduced knowledge, we
13428 would reject the possibility I=1. */
13429 copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs));
13431 /* If unification failed, we're done. */
13432 if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm),
13433 CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE))
13439 /* Given a template type PARM and a class type ARG, find the unique
13440 base type in ARG that is an instance of PARM. We do not examine
13441 ARG itself; only its base-classes. If there is not exactly one
13442 appropriate base class, return NULL_TREE. PARM may be the type of
13443 a partial specialization, as well as a plain template type. Used
13447 get_template_base (tree tparms, tree targs, tree parm, tree arg)
13449 tree rval = NULL_TREE;
13452 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg)));
13454 binfo = TYPE_BINFO (complete_type (arg));
13456 /* The type could not be completed. */
13459 /* Walk in inheritance graph order. The search order is not
13460 important, and this avoids multiple walks of virtual bases. */
13461 for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo))
13463 tree r = try_class_unification (tparms, targs, parm, BINFO_TYPE (binfo));
13467 /* If there is more than one satisfactory baseclass, then:
13471 If they yield more than one possible deduced A, the type
13475 if (rval && !same_type_p (r, rval))
13485 /* Returns the level of DECL, which declares a template parameter. */
13488 template_decl_level (tree decl)
13490 switch (TREE_CODE (decl))
13493 case TEMPLATE_DECL:
13494 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl));
13497 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
13500 gcc_unreachable ();
13505 /* Decide whether ARG can be unified with PARM, considering only the
13506 cv-qualifiers of each type, given STRICT as documented for unify.
13507 Returns nonzero iff the unification is OK on that basis. */
13510 check_cv_quals_for_unify (int strict, tree arg, tree parm)
13512 int arg_quals = cp_type_quals (arg);
13513 int parm_quals = cp_type_quals (parm);
13515 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
13516 && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
13518 /* Although a CVR qualifier is ignored when being applied to a
13519 substituted template parameter ([8.3.2]/1 for example), that
13520 does not apply during deduction [14.8.2.4]/1, (even though
13521 that is not explicitly mentioned, [14.8.2.4]/9 indicates
13522 this). Except when we're allowing additional CV qualifiers
13523 at the outer level [14.8.2.1]/3,1st bullet. */
13524 if ((TREE_CODE (arg) == REFERENCE_TYPE
13525 || TREE_CODE (arg) == FUNCTION_TYPE
13526 || TREE_CODE (arg) == METHOD_TYPE)
13527 && (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)))
13530 if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
13531 && (parm_quals & TYPE_QUAL_RESTRICT))
13535 if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
13536 && (arg_quals & parm_quals) != parm_quals)
13539 if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL))
13540 && (parm_quals & arg_quals) != arg_quals)
13546 /* Determines the LEVEL and INDEX for the template parameter PARM. */
13548 template_parm_level_and_index (tree parm, int* level, int* index)
13550 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
13551 || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
13552 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
13554 *index = TEMPLATE_TYPE_IDX (parm);
13555 *level = TEMPLATE_TYPE_LEVEL (parm);
13559 *index = TEMPLATE_PARM_IDX (parm);
13560 *level = TEMPLATE_PARM_LEVEL (parm);
13564 /* Unifies the remaining arguments in PACKED_ARGS with the pack
13565 expansion at the end of PACKED_PARMS. Returns 0 if the type
13566 deduction succeeds, 1 otherwise. STRICT is the same as in
13567 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
13568 call argument list. We'll need to adjust the arguments to make them
13569 types. SUBR tells us if this is from a recursive call to
13570 type_unification_real. */
13572 unify_pack_expansion (tree tparms, tree targs, tree packed_parms,
13573 tree packed_args, int strict, bool call_args_p,
13577 = TREE_VEC_ELT (packed_parms, TREE_VEC_LENGTH (packed_parms) - 1);
13578 tree pattern = PACK_EXPANSION_PATTERN (parm);
13579 tree pack, packs = NULL_TREE;
13580 int i, start = TREE_VEC_LENGTH (packed_parms) - 1;
13581 int len = TREE_VEC_LENGTH (packed_args);
13583 /* Determine the parameter packs we will be deducing from the
13584 pattern, and record their current deductions. */
13585 for (pack = PACK_EXPANSION_PARAMETER_PACKS (parm);
13586 pack; pack = TREE_CHAIN (pack))
13588 tree parm_pack = TREE_VALUE (pack);
13591 /* Determine the index and level of this parameter pack. */
13592 template_parm_level_and_index (parm_pack, &level, &idx);
13594 /* Keep track of the parameter packs and their corresponding
13596 packs = tree_cons (parm_pack, TMPL_ARG (targs, level, idx), packs);
13597 TREE_TYPE (packs) = make_tree_vec (len - start);
13600 /* Loop through all of the arguments that have not yet been
13601 unified and unify each with the pattern. */
13602 for (i = start; i < len; i++)
13604 tree parm = pattern;
13606 /* For each parameter pack, clear out the deduced value so that
13607 we can deduce it again. */
13608 for (pack = packs; pack; pack = TREE_CHAIN (pack))
13611 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
13613 TMPL_ARG (targs, level, idx) = NULL_TREE;
13616 /* Unify the pattern with the current argument. */
13618 tree arg = TREE_VEC_ELT (packed_args, i);
13619 tree arg_expr = NULL_TREE;
13620 int arg_strict = strict;
13621 bool skip_arg_p = false;
13627 /* This mirrors what we do in type_unification_real. */
13631 sub_strict = (UNIFY_ALLOW_OUTER_LEVEL
13632 | UNIFY_ALLOW_MORE_CV_QUAL
13633 | UNIFY_ALLOW_DERIVED);
13637 sub_strict = UNIFY_ALLOW_LESS_CV_QUAL;
13641 sub_strict = UNIFY_ALLOW_NONE;
13645 gcc_unreachable ();
13650 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
13651 if (type_unknown_p (arg))
13653 /* [temp.deduct.type] A template-argument can be
13654 deduced from a pointer to function or pointer
13655 to member function argument if the set of
13656 overloaded functions does not contain function
13657 templates and at most one of a set of
13658 overloaded functions provides a unique
13661 if (resolve_overloaded_unification
13662 (tparms, targs, parm, arg,
13663 (unification_kind_t) strict,
13673 arg = unlowered_expr_type (arg);
13674 if (arg == error_mark_node)
13679 arg_strict = sub_strict;
13683 maybe_adjust_types_for_deduction ((unification_kind_t) strict,
13684 &parm, &arg, arg_expr);
13689 if (unify (tparms, targs, parm, arg, arg_strict))
13694 /* For each parameter pack, collect the deduced value. */
13695 for (pack = packs; pack; pack = TREE_CHAIN (pack))
13698 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
13700 TREE_VEC_ELT (TREE_TYPE (pack), i - start) =
13701 TMPL_ARG (targs, level, idx);
13705 /* Verify that the results of unification with the parameter packs
13706 produce results consistent with what we've seen before, and make
13707 the deduced argument packs available. */
13708 for (pack = packs; pack; pack = TREE_CHAIN (pack))
13710 tree old_pack = TREE_VALUE (pack);
13711 tree new_args = TREE_TYPE (pack);
13712 int i, len = TREE_VEC_LENGTH (new_args);
13713 bool nondeduced_p = false;
13715 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
13716 actually deduce anything. */
13717 for (i = 0; i < len && !nondeduced_p; ++i)
13718 if (TREE_VEC_ELT (new_args, i) == NULL_TREE)
13719 nondeduced_p = true;
13723 if (old_pack && ARGUMENT_PACK_INCOMPLETE_P (old_pack))
13725 /* Prepend the explicit arguments onto NEW_ARGS. */
13726 tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
13727 tree old_args = new_args;
13728 int i, explicit_len = TREE_VEC_LENGTH (explicit_args);
13729 int len = explicit_len + TREE_VEC_LENGTH (old_args);
13731 /* Copy the explicit arguments. */
13732 new_args = make_tree_vec (len);
13733 for (i = 0; i < explicit_len; i++)
13734 TREE_VEC_ELT (new_args, i) = TREE_VEC_ELT (explicit_args, i);
13736 /* Copy the deduced arguments. */
13737 for (; i < len; i++)
13738 TREE_VEC_ELT (new_args, i) =
13739 TREE_VEC_ELT (old_args, i - explicit_len);
13747 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
13749 /* Build the deduced *_ARGUMENT_PACK. */
13750 if (TREE_CODE (TREE_PURPOSE (pack)) == TEMPLATE_PARM_INDEX)
13752 result = make_node (NONTYPE_ARGUMENT_PACK);
13753 TREE_TYPE (result) =
13754 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack)));
13755 TREE_CONSTANT (result) = 1;
13758 result = cxx_make_type (TYPE_ARGUMENT_PACK);
13760 SET_ARGUMENT_PACK_ARGS (result, new_args);
13762 /* Note the deduced argument packs for this parameter
13764 TMPL_ARG (targs, level, idx) = result;
13766 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack)
13767 && (ARGUMENT_PACK_ARGS (old_pack)
13768 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack)))
13770 /* We only had the explicitly-provided arguments before, but
13771 now we have a complete set of arguments. */
13773 tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
13774 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
13776 /* Keep the original deduced argument pack. */
13777 TMPL_ARG (targs, level, idx) = old_pack;
13779 SET_ARGUMENT_PACK_ARGS (old_pack, new_args);
13780 ARGUMENT_PACK_INCOMPLETE_P (old_pack) = 1;
13781 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack) = explicit_args;
13783 else if (!comp_template_args (ARGUMENT_PACK_ARGS (old_pack),
13785 /* Inconsistent unification of this parameter pack. */
13791 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
13793 /* Keep the original deduced argument pack. */
13794 TMPL_ARG (targs, level, idx) = old_pack;
13801 /* Deduce the value of template parameters. TPARMS is the (innermost)
13802 set of template parameters to a template. TARGS is the bindings
13803 for those template parameters, as determined thus far; TARGS may
13804 include template arguments for outer levels of template parameters
13805 as well. PARM is a parameter to a template function, or a
13806 subcomponent of that parameter; ARG is the corresponding argument.
13807 This function attempts to match PARM with ARG in a manner
13808 consistent with the existing assignments in TARGS. If more values
13809 are deduced, then TARGS is updated.
13811 Returns 0 if the type deduction succeeds, 1 otherwise. The
13812 parameter STRICT is a bitwise or of the following flags:
13815 Require an exact match between PARM and ARG.
13816 UNIFY_ALLOW_MORE_CV_QUAL:
13817 Allow the deduced ARG to be more cv-qualified (by qualification
13818 conversion) than ARG.
13819 UNIFY_ALLOW_LESS_CV_QUAL:
13820 Allow the deduced ARG to be less cv-qualified than ARG.
13821 UNIFY_ALLOW_DERIVED:
13822 Allow the deduced ARG to be a template base class of ARG,
13823 or a pointer to a template base class of the type pointed to by
13825 UNIFY_ALLOW_INTEGER:
13826 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
13827 case for more information.
13828 UNIFY_ALLOW_OUTER_LEVEL:
13829 This is the outermost level of a deduction. Used to determine validity
13830 of qualification conversions. A valid qualification conversion must
13831 have const qualified pointers leading up to the inner type which
13832 requires additional CV quals, except at the outer level, where const
13833 is not required [conv.qual]. It would be normal to set this flag in
13834 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
13835 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
13836 This is the outermost level of a deduction, and PARM can be more CV
13837 qualified at this point.
13838 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
13839 This is the outermost level of a deduction, and PARM can be less CV
13840 qualified at this point. */
13843 unify (tree tparms, tree targs, tree parm, tree arg, int strict)
13848 int strict_in = strict;
13850 /* I don't think this will do the right thing with respect to types.
13851 But the only case I've seen it in so far has been array bounds, where
13852 signedness is the only information lost, and I think that will be
13854 while (TREE_CODE (parm) == NOP_EXPR)
13855 parm = TREE_OPERAND (parm, 0);
13857 if (arg == error_mark_node)
13859 if (arg == unknown_type_node
13860 || arg == init_list_type_node)
13861 /* We can't deduce anything from this, but we might get all the
13862 template args from other function args. */
13865 /* If PARM uses template parameters, then we can't bail out here,
13866 even if ARG == PARM, since we won't record unifications for the
13867 template parameters. We might need them if we're trying to
13868 figure out which of two things is more specialized. */
13869 if (arg == parm && !uses_template_parms (parm))
13872 /* Handle init lists early, so the rest of the function can assume
13873 we're dealing with a type. */
13874 if (BRACE_ENCLOSED_INITIALIZER_P (arg))
13878 tree orig_parm = parm;
13880 /* Replace T with std::initializer_list<T> for deduction. */
13881 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
13882 && flag_deduce_init_list)
13883 parm = listify (parm);
13885 if (!is_std_init_list (parm))
13886 /* We can only deduce from an initializer list argument if the
13887 parameter is std::initializer_list; otherwise this is a
13888 non-deduced context. */
13891 elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm), 0);
13893 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg), i, elt)
13895 int elt_strict = strict;
13896 if (!BRACE_ENCLOSED_INITIALIZER_P (elt))
13898 tree type = TREE_TYPE (elt);
13899 /* It should only be possible to get here for a call. */
13900 gcc_assert (elt_strict & UNIFY_ALLOW_OUTER_LEVEL);
13901 elt_strict |= maybe_adjust_types_for_deduction
13902 (DEDUCE_CALL, &elttype, &type, elt);
13906 if (unify (tparms, targs, elttype, elt, elt_strict))
13910 /* If the std::initializer_list<T> deduction worked, replace the
13911 deduced A with std::initializer_list<A>. */
13912 if (orig_parm != parm)
13914 idx = TEMPLATE_TYPE_IDX (orig_parm);
13915 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
13916 targ = listify (targ);
13917 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = targ;
13922 /* Immediately reject some pairs that won't unify because of
13923 cv-qualification mismatches. */
13924 if (TREE_CODE (arg) == TREE_CODE (parm)
13926 /* It is the elements of the array which hold the cv quals of an array
13927 type, and the elements might be template type parms. We'll check
13928 when we recurse. */
13929 && TREE_CODE (arg) != ARRAY_TYPE
13930 /* We check the cv-qualifiers when unifying with template type
13931 parameters below. We want to allow ARG `const T' to unify with
13932 PARM `T' for example, when computing which of two templates
13933 is more specialized, for example. */
13934 && TREE_CODE (arg) != TEMPLATE_TYPE_PARM
13935 && !check_cv_quals_for_unify (strict_in, arg, parm))
13938 if (!(strict & UNIFY_ALLOW_OUTER_LEVEL)
13939 && TYPE_P (parm) && !CP_TYPE_CONST_P (parm))
13940 strict &= ~UNIFY_ALLOW_MORE_CV_QUAL;
13941 strict &= ~UNIFY_ALLOW_OUTER_LEVEL;
13942 strict &= ~UNIFY_ALLOW_DERIVED;
13943 strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
13944 strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL;
13946 switch (TREE_CODE (parm))
13948 case TYPENAME_TYPE:
13950 case UNBOUND_CLASS_TEMPLATE:
13951 /* In a type which contains a nested-name-specifier, template
13952 argument values cannot be deduced for template parameters used
13953 within the nested-name-specifier. */
13956 case TEMPLATE_TYPE_PARM:
13957 case TEMPLATE_TEMPLATE_PARM:
13958 case BOUND_TEMPLATE_TEMPLATE_PARM:
13959 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
13960 if (tparm == error_mark_node)
13963 if (TEMPLATE_TYPE_LEVEL (parm)
13964 != template_decl_level (tparm))
13965 /* The PARM is not one we're trying to unify. Just check
13966 to see if it matches ARG. */
13967 return (TREE_CODE (arg) == TREE_CODE (parm)
13968 && same_type_p (parm, arg)) ? 0 : 1;
13969 idx = TEMPLATE_TYPE_IDX (parm);
13970 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
13971 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx));
13973 /* Check for mixed types and values. */
13974 if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
13975 && TREE_CODE (tparm) != TYPE_DECL)
13976 || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
13977 && TREE_CODE (tparm) != TEMPLATE_DECL))
13980 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
13982 /* ARG must be constructed from a template class or a template
13983 template parameter. */
13984 if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM
13985 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg))
13989 tree parmvec = TYPE_TI_ARGS (parm);
13990 tree argvec = INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg));
13992 = DECL_INNERMOST_TEMPLATE_PARMS
13993 (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm));
13995 int parm_variadic_p = 0;
13997 /* The resolution to DR150 makes clear that default
13998 arguments for an N-argument may not be used to bind T
13999 to a template template parameter with fewer than N
14000 parameters. It is not safe to permit the binding of
14001 default arguments as an extension, as that may change
14002 the meaning of a conforming program. Consider:
14004 struct Dense { static const unsigned int dim = 1; };
14006 template <template <typename> class View,
14008 void operator+(float, View<Block> const&);
14010 template <typename Block,
14011 unsigned int Dim = Block::dim>
14012 struct Lvalue_proxy { operator float() const; };
14016 Lvalue_proxy<Dense> p;
14021 Here, if Lvalue_proxy is permitted to bind to View, then
14022 the global operator+ will be used; if they are not, the
14023 Lvalue_proxy will be converted to float. */
14024 if (coerce_template_parms (parm_parms,
14026 TYPE_TI_TEMPLATE (parm),
14028 /*require_all_args=*/true,
14029 /*use_default_args=*/false)
14030 == error_mark_node)
14033 /* Deduce arguments T, i from TT<T> or TT<i>.
14034 We check each element of PARMVEC and ARGVEC individually
14035 rather than the whole TREE_VEC since they can have
14036 different number of elements. */
14038 parmvec = expand_template_argument_pack (parmvec);
14039 argvec = expand_template_argument_pack (argvec);
14041 len = TREE_VEC_LENGTH (parmvec);
14043 /* Check if the parameters end in a pack, making them
14046 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec, len - 1)))
14047 parm_variadic_p = 1;
14049 if (TREE_VEC_LENGTH (argvec) < len - parm_variadic_p)
14052 for (i = 0; i < len - parm_variadic_p; ++i)
14054 if (unify (tparms, targs,
14055 TREE_VEC_ELT (parmvec, i),
14056 TREE_VEC_ELT (argvec, i),
14061 if (parm_variadic_p
14062 && unify_pack_expansion (tparms, targs,
14065 /*call_args_p=*/false,
14069 arg = TYPE_TI_TEMPLATE (arg);
14071 /* Fall through to deduce template name. */
14074 if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
14075 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
14077 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
14079 /* Simple cases: Value already set, does match or doesn't. */
14080 if (targ != NULL_TREE && template_args_equal (targ, arg))
14087 /* If PARM is `const T' and ARG is only `int', we don't have
14088 a match unless we are allowing additional qualification.
14089 If ARG is `const int' and PARM is just `T' that's OK;
14090 that binds `const int' to `T'. */
14091 if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL,
14095 /* Consider the case where ARG is `const volatile int' and
14096 PARM is `const T'. Then, T should be `volatile int'. */
14097 arg = cp_build_qualified_type_real
14098 (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
14099 if (arg == error_mark_node)
14102 /* Simple cases: Value already set, does match or doesn't. */
14103 if (targ != NULL_TREE && same_type_p (targ, arg))
14108 /* Make sure that ARG is not a variable-sized array. (Note
14109 that were talking about variable-sized arrays (like
14110 `int[n]'), rather than arrays of unknown size (like
14111 `int[]').) We'll get very confused by such a type since
14112 the bound of the array will not be computable in an
14113 instantiation. Besides, such types are not allowed in
14114 ISO C++, so we can do as we please here. */
14115 if (variably_modified_type_p (arg, NULL_TREE))
14118 /* Strip typedefs as in convert_template_argument. */
14119 arg = strip_typedefs (arg);
14122 /* If ARG is a parameter pack or an expansion, we cannot unify
14123 against it unless PARM is also a parameter pack. */
14124 if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
14125 && !template_parameter_pack_p (parm))
14128 /* If the argument deduction results is a METHOD_TYPE,
14129 then there is a problem.
14130 METHOD_TYPE doesn't map to any real C++ type the result of
14131 the deduction can not be of that type. */
14132 if (TREE_CODE (arg) == METHOD_TYPE)
14135 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
14138 case TEMPLATE_PARM_INDEX:
14139 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
14140 if (tparm == error_mark_node)
14143 if (TEMPLATE_PARM_LEVEL (parm)
14144 != template_decl_level (tparm))
14145 /* The PARM is not one we're trying to unify. Just check
14146 to see if it matches ARG. */
14147 return !(TREE_CODE (arg) == TREE_CODE (parm)
14148 && cp_tree_equal (parm, arg));
14150 idx = TEMPLATE_PARM_IDX (parm);
14151 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
14154 return !cp_tree_equal (targ, arg);
14156 /* [temp.deduct.type] If, in the declaration of a function template
14157 with a non-type template-parameter, the non-type
14158 template-parameter is used in an expression in the function
14159 parameter-list and, if the corresponding template-argument is
14160 deduced, the template-argument type shall match the type of the
14161 template-parameter exactly, except that a template-argument
14162 deduced from an array bound may be of any integral type.
14163 The non-type parameter might use already deduced type parameters. */
14164 tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE);
14165 if (!TREE_TYPE (arg))
14166 /* Template-parameter dependent expression. Just accept it for now.
14167 It will later be processed in convert_template_argument. */
14169 else if (same_type_p (TREE_TYPE (arg), tparm))
14171 else if ((strict & UNIFY_ALLOW_INTEGER)
14172 && (TREE_CODE (tparm) == INTEGER_TYPE
14173 || TREE_CODE (tparm) == BOOLEAN_TYPE))
14174 /* Convert the ARG to the type of PARM; the deduced non-type
14175 template argument must exactly match the types of the
14176 corresponding parameter. */
14177 arg = fold (build_nop (tparm, arg));
14178 else if (uses_template_parms (tparm))
14179 /* We haven't deduced the type of this parameter yet. Try again
14185 /* If ARG is a parameter pack or an expansion, we cannot unify
14186 against it unless PARM is also a parameter pack. */
14187 if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
14188 && !TEMPLATE_PARM_PARAMETER_PACK (parm))
14191 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
14196 /* A pointer-to-member constant can be unified only with
14197 another constant. */
14198 if (TREE_CODE (arg) != PTRMEM_CST)
14201 /* Just unify the class member. It would be useless (and possibly
14202 wrong, depending on the strict flags) to unify also
14203 PTRMEM_CST_CLASS, because we want to be sure that both parm and
14204 arg refer to the same variable, even if through different
14205 classes. For instance:
14207 struct A { int x; };
14210 Unification of &A::x and &B::x must succeed. */
14211 return unify (tparms, targs, PTRMEM_CST_MEMBER (parm),
14212 PTRMEM_CST_MEMBER (arg), strict);
14217 if (TREE_CODE (arg) != POINTER_TYPE)
14220 /* [temp.deduct.call]
14222 A can be another pointer or pointer to member type that can
14223 be converted to the deduced A via a qualification
14224 conversion (_conv.qual_).
14226 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
14227 This will allow for additional cv-qualification of the
14228 pointed-to types if appropriate. */
14230 if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
14231 /* The derived-to-base conversion only persists through one
14232 level of pointers. */
14233 strict |= (strict_in & UNIFY_ALLOW_DERIVED);
14235 return unify (tparms, targs, TREE_TYPE (parm),
14236 TREE_TYPE (arg), strict);
14239 case REFERENCE_TYPE:
14240 if (TREE_CODE (arg) != REFERENCE_TYPE)
14242 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
14243 strict & UNIFY_ALLOW_MORE_CV_QUAL);
14246 if (TREE_CODE (arg) != ARRAY_TYPE)
14248 if ((TYPE_DOMAIN (parm) == NULL_TREE)
14249 != (TYPE_DOMAIN (arg) == NULL_TREE))
14251 if (TYPE_DOMAIN (parm) != NULL_TREE)
14258 /* Our representation of array types uses "N - 1" as the
14259 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
14260 not an integer constant. We cannot unify arbitrarily
14261 complex expressions, so we eliminate the MINUS_EXPRs
14263 parm_max = TYPE_MAX_VALUE (TYPE_DOMAIN (parm));
14264 parm_cst = TREE_CODE (parm_max) == INTEGER_CST;
14267 gcc_assert (TREE_CODE (parm_max) == MINUS_EXPR);
14268 parm_max = TREE_OPERAND (parm_max, 0);
14270 arg_max = TYPE_MAX_VALUE (TYPE_DOMAIN (arg));
14271 arg_cst = TREE_CODE (arg_max) == INTEGER_CST;
14274 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
14275 trying to unify the type of a variable with the type
14276 of a template parameter. For example:
14278 template <unsigned int N>
14279 void f (char (&) [N]);
14286 Here, the type of the ARG will be "int [g(i)]", and
14287 may be a SAVE_EXPR, etc. */
14288 if (TREE_CODE (arg_max) != MINUS_EXPR)
14290 arg_max = TREE_OPERAND (arg_max, 0);
14293 /* If only one of the bounds used a MINUS_EXPR, compensate
14294 by adding one to the other bound. */
14295 if (parm_cst && !arg_cst)
14296 parm_max = fold_build2_loc (input_location, PLUS_EXPR,
14300 else if (arg_cst && !parm_cst)
14301 arg_max = fold_build2_loc (input_location, PLUS_EXPR,
14306 if (unify (tparms, targs, parm_max, arg_max, UNIFY_ALLOW_INTEGER))
14309 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
14310 strict & UNIFY_ALLOW_MORE_CV_QUAL);
14317 case ENUMERAL_TYPE:
14319 if (TREE_CODE (arg) != TREE_CODE (parm))
14322 /* We have already checked cv-qualification at the top of the
14324 if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
14327 /* As far as unification is concerned, this wins. Later checks
14328 will invalidate it if necessary. */
14331 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
14332 /* Type INTEGER_CST can come from ordinary constant template args. */
14334 while (TREE_CODE (arg) == NOP_EXPR)
14335 arg = TREE_OPERAND (arg, 0);
14337 if (TREE_CODE (arg) != INTEGER_CST)
14339 return !tree_int_cst_equal (parm, arg);
14344 if (TREE_CODE (arg) != TREE_VEC)
14346 if (TREE_VEC_LENGTH (parm) != TREE_VEC_LENGTH (arg))
14348 for (i = 0; i < TREE_VEC_LENGTH (parm); ++i)
14349 if (unify (tparms, targs,
14350 TREE_VEC_ELT (parm, i), TREE_VEC_ELT (arg, i),
14358 if (TREE_CODE (arg) != TREE_CODE (parm))
14361 if (TYPE_PTRMEMFUNC_P (parm))
14363 if (!TYPE_PTRMEMFUNC_P (arg))
14366 return unify (tparms, targs,
14367 TYPE_PTRMEMFUNC_FN_TYPE (parm),
14368 TYPE_PTRMEMFUNC_FN_TYPE (arg),
14372 if (CLASSTYPE_TEMPLATE_INFO (parm))
14374 tree t = NULL_TREE;
14376 if (strict_in & UNIFY_ALLOW_DERIVED)
14378 /* First, we try to unify the PARM and ARG directly. */
14379 t = try_class_unification (tparms, targs,
14384 /* Fallback to the special case allowed in
14385 [temp.deduct.call]:
14387 If P is a class, and P has the form
14388 template-id, then A can be a derived class of
14389 the deduced A. Likewise, if P is a pointer to
14390 a class of the form template-id, A can be a
14391 pointer to a derived class pointed to by the
14393 t = get_template_base (tparms, targs, parm, arg);
14399 else if (CLASSTYPE_TEMPLATE_INFO (arg)
14400 && (CLASSTYPE_TI_TEMPLATE (parm)
14401 == CLASSTYPE_TI_TEMPLATE (arg)))
14402 /* Perhaps PARM is something like S<U> and ARG is S<int>.
14403 Then, we should unify `int' and `U'. */
14406 /* There's no chance of unification succeeding. */
14409 return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
14410 CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE);
14412 else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
14417 case FUNCTION_TYPE:
14419 unsigned int nargs;
14424 if (TREE_CODE (arg) != TREE_CODE (parm))
14427 /* CV qualifications for methods can never be deduced, they must
14428 match exactly. We need to check them explicitly here,
14429 because type_unification_real treats them as any other
14430 cv-qualified parameter. */
14431 if (TREE_CODE (parm) == METHOD_TYPE
14432 && (!check_cv_quals_for_unify
14434 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (arg))),
14435 TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (parm))))))
14438 if (unify (tparms, targs, TREE_TYPE (parm),
14439 TREE_TYPE (arg), UNIFY_ALLOW_NONE))
14442 nargs = list_length (TYPE_ARG_TYPES (arg));
14443 args = XALLOCAVEC (tree, nargs);
14444 for (a = TYPE_ARG_TYPES (arg), i = 0;
14445 a != NULL_TREE && a != void_list_node;
14446 a = TREE_CHAIN (a), ++i)
14447 args[i] = TREE_VALUE (a);
14450 return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
14451 args, nargs, 1, DEDUCE_EXACT,
14456 /* Unify a pointer to member with a pointer to member function, which
14457 deduces the type of the member as a function type. */
14458 if (TYPE_PTRMEMFUNC_P (arg))
14462 cp_cv_quals cv_quals;
14464 /* Check top-level cv qualifiers */
14465 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE, arg, parm))
14468 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
14469 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg), UNIFY_ALLOW_NONE))
14472 /* Determine the type of the function we are unifying against. */
14473 method_type = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (arg));
14475 build_function_type (TREE_TYPE (method_type),
14476 TREE_CHAIN (TYPE_ARG_TYPES (method_type)));
14478 /* Extract the cv-qualifiers of the member function from the
14479 implicit object parameter and place them on the function
14480 type to be restored later. */
14482 cp_type_quals(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (method_type))));
14483 fntype = build_qualified_type (fntype, cv_quals);
14484 return unify (tparms, targs, TREE_TYPE (parm), fntype, strict);
14487 if (TREE_CODE (arg) != OFFSET_TYPE)
14489 if (unify (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
14490 TYPE_OFFSET_BASETYPE (arg), UNIFY_ALLOW_NONE))
14492 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
14496 if (DECL_TEMPLATE_PARM_P (parm))
14497 return unify (tparms, targs, DECL_INITIAL (parm), arg, strict);
14498 if (arg != integral_constant_value (parm))
14503 case TEMPLATE_DECL:
14504 /* Matched cases are handled by the ARG == PARM test above. */
14507 case TYPE_ARGUMENT_PACK:
14508 case NONTYPE_ARGUMENT_PACK:
14510 tree packed_parms = ARGUMENT_PACK_ARGS (parm);
14511 tree packed_args = ARGUMENT_PACK_ARGS (arg);
14512 int i, len = TREE_VEC_LENGTH (packed_parms);
14513 int argslen = TREE_VEC_LENGTH (packed_args);
14514 int parm_variadic_p = 0;
14516 for (i = 0; i < len; ++i)
14518 if (PACK_EXPANSION_P (TREE_VEC_ELT (packed_parms, i)))
14521 /* We can unify against something with a trailing
14523 parm_variadic_p = 1;
14525 /* Since there is something following the pack
14526 expansion, we cannot unify this template argument
14533 /* If we don't have enough arguments to satisfy the parameters
14534 (not counting the pack expression at the end), or we have
14535 too many arguments for a parameter list that doesn't end in
14536 a pack expression, we can't unify. */
14537 if (argslen < (len - parm_variadic_p)
14538 || (argslen > len && !parm_variadic_p))
14541 /* Unify all of the parameters that precede the (optional)
14542 pack expression. */
14543 for (i = 0; i < len - parm_variadic_p; ++i)
14545 if (unify (tparms, targs, TREE_VEC_ELT (packed_parms, i),
14546 TREE_VEC_ELT (packed_args, i), strict))
14550 if (parm_variadic_p)
14551 return unify_pack_expansion (tparms, targs,
14552 packed_parms, packed_args,
14553 strict, /*call_args_p=*/false,
14561 case DECLTYPE_TYPE:
14562 /* Cannot deduce anything from TYPEOF_TYPE or DECLTYPE_TYPE
14567 /* Unification fails if we hit an error node. */
14571 gcc_assert (EXPR_P (parm));
14573 /* We must be looking at an expression. This can happen with
14577 void foo(S<I>, S<I + 2>);
14579 This is a "nondeduced context":
14583 The nondeduced contexts are:
14585 --A type that is a template-id in which one or more of
14586 the template-arguments is an expression that references
14587 a template-parameter.
14589 In these cases, we assume deduction succeeded, but don't
14590 actually infer any unifications. */
14592 if (!uses_template_parms (parm)
14593 && !template_args_equal (parm, arg))
14600 /* Note that DECL can be defined in this translation unit, if
14604 mark_definable (tree decl)
14607 DECL_NOT_REALLY_EXTERN (decl) = 1;
14608 FOR_EACH_CLONE (clone, decl)
14609 DECL_NOT_REALLY_EXTERN (clone) = 1;
14612 /* Called if RESULT is explicitly instantiated, or is a member of an
14613 explicitly instantiated class. */
14616 mark_decl_instantiated (tree result, int extern_p)
14618 SET_DECL_EXPLICIT_INSTANTIATION (result);
14620 /* If this entity has already been written out, it's too late to
14621 make any modifications. */
14622 if (TREE_ASM_WRITTEN (result))
14625 if (TREE_CODE (result) != FUNCTION_DECL)
14626 /* The TREE_PUBLIC flag for function declarations will have been
14627 set correctly by tsubst. */
14628 TREE_PUBLIC (result) = 1;
14630 /* This might have been set by an earlier implicit instantiation. */
14631 DECL_COMDAT (result) = 0;
14634 DECL_NOT_REALLY_EXTERN (result) = 0;
14637 mark_definable (result);
14638 /* Always make artificials weak. */
14639 if (DECL_ARTIFICIAL (result) && flag_weak)
14640 comdat_linkage (result);
14641 /* For WIN32 we also want to put explicit instantiations in
14642 linkonce sections. */
14643 else if (TREE_PUBLIC (result))
14644 maybe_make_one_only (result);
14647 /* If EXTERN_P, then this function will not be emitted -- unless
14648 followed by an explicit instantiation, at which point its linkage
14649 will be adjusted. If !EXTERN_P, then this function will be
14650 emitted here. In neither circumstance do we want
14651 import_export_decl to adjust the linkage. */
14652 DECL_INTERFACE_KNOWN (result) = 1;
14655 /* Given two function templates PAT1 and PAT2, return:
14657 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
14658 -1 if PAT2 is more specialized than PAT1.
14659 0 if neither is more specialized.
14661 LEN indicates the number of parameters we should consider
14662 (defaulted parameters should not be considered).
14664 The 1998 std underspecified function template partial ordering, and
14665 DR214 addresses the issue. We take pairs of arguments, one from
14666 each of the templates, and deduce them against each other. One of
14667 the templates will be more specialized if all the *other*
14668 template's arguments deduce against its arguments and at least one
14669 of its arguments *does* *not* deduce against the other template's
14670 corresponding argument. Deduction is done as for class templates.
14671 The arguments used in deduction have reference and top level cv
14672 qualifiers removed. Iff both arguments were originally reference
14673 types *and* deduction succeeds in both directions, the template
14674 with the more cv-qualified argument wins for that pairing (if
14675 neither is more cv-qualified, they both are equal). Unlike regular
14676 deduction, after all the arguments have been deduced in this way,
14677 we do *not* verify the deduced template argument values can be
14678 substituted into non-deduced contexts, nor do we have to verify
14679 that all template arguments have been deduced. */
14682 more_specialized_fn (tree pat1, tree pat2, int len)
14684 tree decl1 = DECL_TEMPLATE_RESULT (pat1);
14685 tree decl2 = DECL_TEMPLATE_RESULT (pat2);
14686 tree targs1 = make_tree_vec (DECL_NTPARMS (pat1));
14687 tree targs2 = make_tree_vec (DECL_NTPARMS (pat2));
14688 tree tparms1 = DECL_INNERMOST_TEMPLATE_PARMS (pat1);
14689 tree tparms2 = DECL_INNERMOST_TEMPLATE_PARMS (pat2);
14690 tree args1 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
14691 tree args2 = TYPE_ARG_TYPES (TREE_TYPE (decl2));
14695 /* Remove the this parameter from non-static member functions. If
14696 one is a non-static member function and the other is not a static
14697 member function, remove the first parameter from that function
14698 also. This situation occurs for operator functions where we
14699 locate both a member function (with this pointer) and non-member
14700 operator (with explicit first operand). */
14701 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1))
14703 len--; /* LEN is the number of significant arguments for DECL1 */
14704 args1 = TREE_CHAIN (args1);
14705 if (!DECL_STATIC_FUNCTION_P (decl2))
14706 args2 = TREE_CHAIN (args2);
14708 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2))
14710 args2 = TREE_CHAIN (args2);
14711 if (!DECL_STATIC_FUNCTION_P (decl1))
14714 args1 = TREE_CHAIN (args1);
14718 /* If only one is a conversion operator, they are unordered. */
14719 if (DECL_CONV_FN_P (decl1) != DECL_CONV_FN_P (decl2))
14722 /* Consider the return type for a conversion function */
14723 if (DECL_CONV_FN_P (decl1))
14725 args1 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl1)), args1);
14726 args2 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl2)), args2);
14730 processing_template_decl++;
14733 /* Stop when an ellipsis is seen. */
14734 && args1 != NULL_TREE && args2 != NULL_TREE)
14736 tree arg1 = TREE_VALUE (args1);
14737 tree arg2 = TREE_VALUE (args2);
14738 int deduce1, deduce2;
14742 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
14743 && TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
14745 /* When both arguments are pack expansions, we need only
14746 unify the patterns themselves. */
14747 arg1 = PACK_EXPANSION_PATTERN (arg1);
14748 arg2 = PACK_EXPANSION_PATTERN (arg2);
14750 /* This is the last comparison we need to do. */
14754 if (TREE_CODE (arg1) == REFERENCE_TYPE)
14756 arg1 = TREE_TYPE (arg1);
14757 quals1 = cp_type_quals (arg1);
14760 if (TREE_CODE (arg2) == REFERENCE_TYPE)
14762 arg2 = TREE_TYPE (arg2);
14763 quals2 = cp_type_quals (arg2);
14766 if ((quals1 < 0) != (quals2 < 0))
14768 /* Only of the args is a reference, see if we should apply
14769 array/function pointer decay to it. This is not part of
14770 DR214, but is, IMHO, consistent with the deduction rules
14771 for the function call itself, and with our earlier
14772 implementation of the underspecified partial ordering
14773 rules. (nathan). */
14776 switch (TREE_CODE (arg1))
14779 arg1 = TREE_TYPE (arg1);
14781 case FUNCTION_TYPE:
14782 arg1 = build_pointer_type (arg1);
14791 switch (TREE_CODE (arg2))
14794 arg2 = TREE_TYPE (arg2);
14796 case FUNCTION_TYPE:
14797 arg2 = build_pointer_type (arg2);
14806 arg1 = TYPE_MAIN_VARIANT (arg1);
14807 arg2 = TYPE_MAIN_VARIANT (arg2);
14809 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION)
14811 int i, len2 = list_length (args2);
14812 tree parmvec = make_tree_vec (1);
14813 tree argvec = make_tree_vec (len2);
14816 /* Setup the parameter vector, which contains only ARG1. */
14817 TREE_VEC_ELT (parmvec, 0) = arg1;
14819 /* Setup the argument vector, which contains the remaining
14821 for (i = 0; i < len2; i++, ta = TREE_CHAIN (ta))
14822 TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
14824 deduce1 = !unify_pack_expansion (tparms1, targs1, parmvec,
14825 argvec, UNIFY_ALLOW_NONE,
14826 /*call_args_p=*/false,
14829 /* We cannot deduce in the other direction, because ARG1 is
14830 a pack expansion but ARG2 is not. */
14833 else if (TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
14835 int i, len1 = list_length (args1);
14836 tree parmvec = make_tree_vec (1);
14837 tree argvec = make_tree_vec (len1);
14840 /* Setup the parameter vector, which contains only ARG1. */
14841 TREE_VEC_ELT (parmvec, 0) = arg2;
14843 /* Setup the argument vector, which contains the remaining
14845 for (i = 0; i < len1; i++, ta = TREE_CHAIN (ta))
14846 TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
14848 deduce2 = !unify_pack_expansion (tparms2, targs2, parmvec,
14849 argvec, UNIFY_ALLOW_NONE,
14850 /*call_args_p=*/false,
14853 /* We cannot deduce in the other direction, because ARG2 is
14854 a pack expansion but ARG1 is not.*/
14860 /* The normal case, where neither argument is a pack
14862 deduce1 = !unify (tparms1, targs1, arg1, arg2, UNIFY_ALLOW_NONE);
14863 deduce2 = !unify (tparms2, targs2, arg2, arg1, UNIFY_ALLOW_NONE);
14870 if (better1 < 0 && better2 < 0)
14871 /* We've failed to deduce something in either direction.
14872 These must be unordered. */
14875 if (deduce1 && deduce2 && quals1 >= 0 && quals2 >= 0)
14877 /* Deduces in both directions, see if quals can
14878 disambiguate. Pretend the worse one failed to deduce. */
14879 if ((quals1 & quals2) == quals2)
14881 if ((quals1 & quals2) == quals1)
14884 if (deduce1 && !deduce2 && !better2)
14886 if (deduce2 && !deduce1 && !better1)
14889 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
14890 || TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
14891 /* We have already processed all of the arguments in our
14892 handing of the pack expansion type. */
14895 args1 = TREE_CHAIN (args1);
14896 args2 = TREE_CHAIN (args2);
14899 processing_template_decl--;
14901 /* All things being equal, if the next argument is a pack expansion
14902 for one function but not for the other, prefer the
14903 non-variadic function. */
14904 if ((better1 > 0) - (better2 > 0) == 0
14905 && args1 && TREE_VALUE (args1)
14906 && args2 && TREE_VALUE (args2))
14908 if (TREE_CODE (TREE_VALUE (args1)) == TYPE_PACK_EXPANSION)
14909 return TREE_CODE (TREE_VALUE (args2)) == TYPE_PACK_EXPANSION ? 0 : -1;
14910 else if (TREE_CODE (TREE_VALUE (args2)) == TYPE_PACK_EXPANSION)
14914 return (better1 > 0) - (better2 > 0);
14917 /* Determine which of two partial specializations is more specialized.
14919 PAT1 is a TREE_LIST whose TREE_TYPE is the _TYPE node corresponding
14920 to the first partial specialization. The TREE_VALUE is the
14921 innermost set of template parameters for the partial
14922 specialization. PAT2 is similar, but for the second template.
14924 Return 1 if the first partial specialization is more specialized;
14925 -1 if the second is more specialized; 0 if neither is more
14928 See [temp.class.order] for information about determining which of
14929 two templates is more specialized. */
14932 more_specialized_class (tree pat1, tree pat2)
14937 bool any_deductions = false;
14939 tmpl1 = TREE_TYPE (pat1);
14940 tmpl2 = TREE_TYPE (pat2);
14942 /* Just like what happens for functions, if we are ordering between
14943 different class template specializations, we may encounter dependent
14944 types in the arguments, and we need our dependency check functions
14945 to behave correctly. */
14946 ++processing_template_decl;
14947 targs = get_class_bindings (TREE_VALUE (pat1),
14948 CLASSTYPE_TI_ARGS (tmpl1),
14949 CLASSTYPE_TI_ARGS (tmpl2));
14953 any_deductions = true;
14956 targs = get_class_bindings (TREE_VALUE (pat2),
14957 CLASSTYPE_TI_ARGS (tmpl2),
14958 CLASSTYPE_TI_ARGS (tmpl1));
14962 any_deductions = true;
14964 --processing_template_decl;
14966 /* In the case of a tie where at least one of the class templates
14967 has a parameter pack at the end, the template with the most
14968 non-packed parameters wins. */
14971 && (template_args_variadic_p (TREE_PURPOSE (pat1))
14972 || template_args_variadic_p (TREE_PURPOSE (pat2))))
14974 tree args1 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1));
14975 tree args2 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2));
14976 int len1 = TREE_VEC_LENGTH (args1);
14977 int len2 = TREE_VEC_LENGTH (args2);
14979 /* We don't count the pack expansion at the end. */
14980 if (template_args_variadic_p (TREE_PURPOSE (pat1)))
14982 if (template_args_variadic_p (TREE_PURPOSE (pat2)))
14987 else if (len1 < len2)
14994 /* Return the template arguments that will produce the function signature
14995 DECL from the function template FN, with the explicit template
14996 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
14997 also match. Return NULL_TREE if no satisfactory arguments could be
15001 get_bindings (tree fn, tree decl, tree explicit_args, bool check_rettype)
15003 int ntparms = DECL_NTPARMS (fn);
15004 tree targs = make_tree_vec (ntparms);
15006 tree decl_arg_types;
15008 unsigned int nargs, ix;
15011 /* Substitute the explicit template arguments into the type of DECL.
15012 The call to fn_type_unification will handle substitution into the
15014 decl_type = TREE_TYPE (decl);
15015 if (explicit_args && uses_template_parms (decl_type))
15018 tree converted_args;
15020 if (DECL_TEMPLATE_INFO (decl))
15021 tmpl = DECL_TI_TEMPLATE (decl);
15023 /* We can get here for some invalid specializations. */
15027 = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
15028 explicit_args, NULL_TREE,
15030 /*require_all_args=*/false,
15031 /*use_default_args=*/false);
15032 if (converted_args == error_mark_node)
15035 decl_type = tsubst (decl_type, converted_args, tf_none, NULL_TREE);
15036 if (decl_type == error_mark_node)
15040 /* Never do unification on the 'this' parameter. */
15041 decl_arg_types = skip_artificial_parms_for (decl,
15042 TYPE_ARG_TYPES (decl_type));
15044 nargs = list_length (decl_arg_types);
15045 args = XALLOCAVEC (tree, nargs);
15046 for (arg = decl_arg_types, ix = 0;
15047 arg != NULL_TREE && arg != void_list_node;
15048 arg = TREE_CHAIN (arg), ++ix)
15049 args[ix] = TREE_VALUE (arg);
15051 if (fn_type_unification (fn, explicit_args, targs,
15053 (check_rettype || DECL_CONV_FN_P (fn)
15054 ? TREE_TYPE (decl_type) : NULL_TREE),
15055 DEDUCE_EXACT, LOOKUP_NORMAL))
15061 /* Return the innermost template arguments that, when applied to a
15062 template specialization whose innermost template parameters are
15063 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
15066 For example, suppose we have:
15068 template <class T, class U> struct S {};
15069 template <class T> struct S<T*, int> {};
15071 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
15072 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
15073 int}. The resulting vector will be {double}, indicating that `T'
15074 is bound to `double'. */
15077 get_class_bindings (tree tparms, tree spec_args, tree args)
15079 int i, ntparms = TREE_VEC_LENGTH (tparms);
15081 tree innermost_deduced_args;
15083 innermost_deduced_args = make_tree_vec (ntparms);
15084 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
15086 deduced_args = copy_node (args);
15087 SET_TMPL_ARGS_LEVEL (deduced_args,
15088 TMPL_ARGS_DEPTH (deduced_args),
15089 innermost_deduced_args);
15092 deduced_args = innermost_deduced_args;
15094 if (unify (tparms, deduced_args,
15095 INNERMOST_TEMPLATE_ARGS (spec_args),
15096 INNERMOST_TEMPLATE_ARGS (args),
15100 for (i = 0; i < ntparms; ++i)
15101 if (! TREE_VEC_ELT (innermost_deduced_args, i))
15104 /* Verify that nondeduced template arguments agree with the type
15105 obtained from argument deduction.
15109 struct A { typedef int X; };
15110 template <class T, class U> struct C {};
15111 template <class T> struct C<T, typename T::X> {};
15113 Then with the instantiation `C<A, int>', we can deduce that
15114 `T' is `A' but unify () does not check whether `typename T::X'
15116 spec_args = tsubst (spec_args, deduced_args, tf_none, NULL_TREE);
15117 if (spec_args == error_mark_node
15118 /* We only need to check the innermost arguments; the other
15119 arguments will always agree. */
15120 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args),
15121 INNERMOST_TEMPLATE_ARGS (args)))
15124 /* Now that we have bindings for all of the template arguments,
15125 ensure that the arguments deduced for the template template
15126 parameters have compatible template parameter lists. See the use
15127 of template_template_parm_bindings_ok_p in fn_type_unification
15128 for more information. */
15129 if (!template_template_parm_bindings_ok_p (tparms, deduced_args))
15132 return deduced_args;
15135 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
15136 Return the TREE_LIST node with the most specialized template, if
15137 any. If there is no most specialized template, the error_mark_node
15140 Note that this function does not look at, or modify, the
15141 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
15142 returned is one of the elements of INSTANTIATIONS, callers may
15143 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
15144 and retrieve it from the value returned. */
15147 most_specialized_instantiation (tree templates)
15151 ++processing_template_decl;
15154 for (fn = TREE_CHAIN (templates); fn; fn = TREE_CHAIN (fn))
15158 if (get_bindings (TREE_VALUE (champ),
15159 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
15160 NULL_TREE, /*check_ret=*/false))
15163 if (get_bindings (TREE_VALUE (fn),
15164 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
15165 NULL_TREE, /*check_ret=*/false))
15172 /* Equally specialized, move to next function. If there
15173 is no next function, nothing's most specialized. */
15174 fn = TREE_CHAIN (fn);
15182 /* Now verify that champ is better than everything earlier in the
15183 instantiation list. */
15184 for (fn = templates; fn != champ; fn = TREE_CHAIN (fn))
15185 if (get_bindings (TREE_VALUE (champ),
15186 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
15187 NULL_TREE, /*check_ret=*/false)
15188 || !get_bindings (TREE_VALUE (fn),
15189 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
15190 NULL_TREE, /*check_ret=*/false))
15196 processing_template_decl--;
15199 return error_mark_node;
15204 /* If DECL is a specialization of some template, return the most
15205 general such template. Otherwise, returns NULL_TREE.
15207 For example, given:
15209 template <class T> struct S { template <class U> void f(U); };
15211 if TMPL is `template <class U> void S<int>::f(U)' this will return
15212 the full template. This function will not trace past partial
15213 specializations, however. For example, given in addition:
15215 template <class T> struct S<T*> { template <class U> void f(U); };
15217 if TMPL is `template <class U> void S<int*>::f(U)' this will return
15218 `template <class T> template <class U> S<T*>::f(U)'. */
15221 most_general_template (tree decl)
15223 /* If DECL is a FUNCTION_DECL, find the TEMPLATE_DECL of which it is
15224 an immediate specialization. */
15225 if (TREE_CODE (decl) == FUNCTION_DECL)
15227 if (DECL_TEMPLATE_INFO (decl)) {
15228 decl = DECL_TI_TEMPLATE (decl);
15230 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE for a
15231 template friend. */
15232 if (TREE_CODE (decl) != TEMPLATE_DECL)
15238 /* Look for more and more general templates. */
15239 while (DECL_TEMPLATE_INFO (decl))
15241 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
15242 (See cp-tree.h for details.) */
15243 if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
15246 if (CLASS_TYPE_P (TREE_TYPE (decl))
15247 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
15250 /* Stop if we run into an explicitly specialized class template. */
15251 if (!DECL_NAMESPACE_SCOPE_P (decl)
15252 && DECL_CONTEXT (decl)
15253 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl)))
15256 decl = DECL_TI_TEMPLATE (decl);
15262 /* Return the most specialized of the class template partial
15263 specializations of TMPL which can produce TYPE, a specialization of
15264 TMPL. The value returned is actually a TREE_LIST; the TREE_TYPE is
15265 a _TYPE node corresponding to the partial specialization, while the
15266 TREE_PURPOSE is the set of template arguments that must be
15267 substituted into the TREE_TYPE in order to generate TYPE.
15269 If the choice of partial specialization is ambiguous, a diagnostic
15270 is issued, and the error_mark_node is returned. If there are no
15271 partial specializations of TMPL matching TYPE, then NULL_TREE is
15275 most_specialized_class (tree type, tree tmpl)
15277 tree list = NULL_TREE;
15283 tree outer_args = NULL_TREE;
15285 tmpl = most_general_template (tmpl);
15286 args = CLASSTYPE_TI_ARGS (type);
15288 /* For determining which partial specialization to use, only the
15289 innermost args are interesting. */
15290 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
15292 outer_args = strip_innermost_template_args (args, 1);
15293 args = INNERMOST_TEMPLATE_ARGS (args);
15296 for (t = DECL_TEMPLATE_SPECIALIZATIONS (tmpl); t; t = TREE_CHAIN (t))
15298 tree partial_spec_args;
15300 tree parms = TREE_VALUE (t);
15302 partial_spec_args = CLASSTYPE_TI_ARGS (TREE_TYPE (t));
15307 ++processing_template_decl;
15309 /* Discard the outer levels of args, and then substitute in the
15310 template args from the enclosing class. */
15311 partial_spec_args = INNERMOST_TEMPLATE_ARGS (partial_spec_args);
15312 partial_spec_args = tsubst_template_args
15313 (partial_spec_args, outer_args, tf_none, NULL_TREE);
15315 /* PARMS already refers to just the innermost parms, but the
15316 template parms in partial_spec_args had their levels lowered
15317 by tsubst, so we need to do the same for the parm list. We
15318 can't just tsubst the TREE_VEC itself, as tsubst wants to
15319 treat a TREE_VEC as an argument vector. */
15320 parms = copy_node (parms);
15321 for (i = TREE_VEC_LENGTH (parms) - 1; i >= 0; --i)
15322 TREE_VEC_ELT (parms, i) =
15323 tsubst (TREE_VEC_ELT (parms, i), outer_args, tf_none, NULL_TREE);
15325 --processing_template_decl;
15327 spec_args = get_class_bindings (parms,
15333 spec_args = add_to_template_args (outer_args, spec_args);
15334 list = tree_cons (spec_args, TREE_VALUE (t), list);
15335 TREE_TYPE (list) = TREE_TYPE (t);
15342 ambiguous_p = false;
15345 t = TREE_CHAIN (t);
15346 for (; t; t = TREE_CHAIN (t))
15348 fate = more_specialized_class (champ, t);
15355 t = TREE_CHAIN (t);
15358 ambiguous_p = true;
15367 for (t = list; t && t != champ; t = TREE_CHAIN (t))
15369 fate = more_specialized_class (champ, t);
15372 ambiguous_p = true;
15379 const char *str = "candidates are:";
15380 error ("ambiguous class template instantiation for %q#T", type);
15381 for (t = list; t; t = TREE_CHAIN (t))
15383 error ("%s %+#T", str, TREE_TYPE (t));
15386 return error_mark_node;
15392 /* Explicitly instantiate DECL. */
15395 do_decl_instantiation (tree decl, tree storage)
15397 tree result = NULL_TREE;
15400 if (!decl || decl == error_mark_node)
15401 /* An error occurred, for which grokdeclarator has already issued
15402 an appropriate message. */
15404 else if (! DECL_LANG_SPECIFIC (decl))
15406 error ("explicit instantiation of non-template %q#D", decl);
15409 else if (TREE_CODE (decl) == VAR_DECL)
15411 /* There is an asymmetry here in the way VAR_DECLs and
15412 FUNCTION_DECLs are handled by grokdeclarator. In the case of
15413 the latter, the DECL we get back will be marked as a
15414 template instantiation, and the appropriate
15415 DECL_TEMPLATE_INFO will be set up. This does not happen for
15416 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
15417 should handle VAR_DECLs as it currently handles
15419 if (!DECL_CLASS_SCOPE_P (decl))
15421 error ("%qD is not a static data member of a class template", decl);
15424 result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false);
15425 if (!result || TREE_CODE (result) != VAR_DECL)
15427 error ("no matching template for %qD found", decl);
15430 if (!same_type_p (TREE_TYPE (result), TREE_TYPE (decl)))
15432 error ("type %qT for explicit instantiation %qD does not match "
15433 "declared type %qT", TREE_TYPE (result), decl,
15438 else if (TREE_CODE (decl) != FUNCTION_DECL)
15440 error ("explicit instantiation of %q#D", decl);
15446 /* Check for various error cases. Note that if the explicit
15447 instantiation is valid the RESULT will currently be marked as an
15448 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
15449 until we get here. */
15451 if (DECL_TEMPLATE_SPECIALIZATION (result))
15453 /* DR 259 [temp.spec].
15455 Both an explicit instantiation and a declaration of an explicit
15456 specialization shall not appear in a program unless the explicit
15457 instantiation follows a declaration of the explicit specialization.
15459 For a given set of template parameters, if an explicit
15460 instantiation of a template appears after a declaration of an
15461 explicit specialization for that template, the explicit
15462 instantiation has no effect. */
15465 else if (DECL_EXPLICIT_INSTANTIATION (result))
15469 No program shall explicitly instantiate any template more
15472 We check DECL_NOT_REALLY_EXTERN so as not to complain when
15473 the first instantiation was `extern' and the second is not,
15474 and EXTERN_P for the opposite case. */
15475 if (DECL_NOT_REALLY_EXTERN (result) && !extern_p)
15476 permerror (input_location, "duplicate explicit instantiation of %q#D", result);
15477 /* If an "extern" explicit instantiation follows an ordinary
15478 explicit instantiation, the template is instantiated. */
15482 else if (!DECL_IMPLICIT_INSTANTIATION (result))
15484 error ("no matching template for %qD found", result);
15487 else if (!DECL_TEMPLATE_INFO (result))
15489 permerror (input_location, "explicit instantiation of non-template %q#D", result);
15493 if (storage == NULL_TREE)
15495 else if (storage == ridpointers[(int) RID_EXTERN])
15497 if (!in_system_header && (cxx_dialect == cxx98))
15498 pedwarn (input_location, OPT_pedantic,
15499 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
15504 error ("storage class %qD applied to template instantiation", storage);
15506 check_explicit_instantiation_namespace (result);
15507 mark_decl_instantiated (result, extern_p);
15509 instantiate_decl (result, /*defer_ok=*/1,
15510 /*expl_inst_class_mem_p=*/false);
15514 mark_class_instantiated (tree t, int extern_p)
15516 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
15517 SET_CLASSTYPE_INTERFACE_KNOWN (t);
15518 CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
15519 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
15522 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
15523 rest_of_type_compilation (t, 1);
15527 /* Called from do_type_instantiation through binding_table_foreach to
15528 do recursive instantiation for the type bound in ENTRY. */
15530 bt_instantiate_type_proc (binding_entry entry, void *data)
15532 tree storage = *(tree *) data;
15534 if (MAYBE_CLASS_TYPE_P (entry->type)
15535 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type)))
15536 do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0);
15539 /* Called from do_type_instantiation to instantiate a member
15540 (a member function or a static member variable) of an
15541 explicitly instantiated class template. */
15543 instantiate_class_member (tree decl, int extern_p)
15545 mark_decl_instantiated (decl, extern_p);
15547 instantiate_decl (decl, /*defer_ok=*/1,
15548 /*expl_inst_class_mem_p=*/true);
15551 /* Perform an explicit instantiation of template class T. STORAGE, if
15552 non-null, is the RID for extern, inline or static. COMPLAIN is
15553 nonzero if this is called from the parser, zero if called recursively,
15554 since the standard is unclear (as detailed below). */
15557 do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
15562 int previous_instantiation_extern_p = 0;
15564 if (TREE_CODE (t) == TYPE_DECL)
15567 if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t))
15569 error ("explicit instantiation of non-template type %qT", t);
15575 if (!COMPLETE_TYPE_P (t))
15577 if (complain & tf_error)
15578 error ("explicit instantiation of %q#T before definition of template",
15583 if (storage != NULL_TREE)
15585 if (!in_system_header)
15587 if (storage == ridpointers[(int) RID_EXTERN])
15589 if (cxx_dialect == cxx98)
15590 pedwarn (input_location, OPT_pedantic,
15591 "ISO C++ 1998 forbids the use of %<extern%> on "
15592 "explicit instantiations");
15595 pedwarn (input_location, OPT_pedantic,
15596 "ISO C++ forbids the use of %qE"
15597 " on explicit instantiations", storage);
15600 if (storage == ridpointers[(int) RID_INLINE])
15602 else if (storage == ridpointers[(int) RID_EXTERN])
15604 else if (storage == ridpointers[(int) RID_STATIC])
15608 error ("storage class %qD applied to template instantiation",
15614 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
15616 /* DR 259 [temp.spec].
15618 Both an explicit instantiation and a declaration of an explicit
15619 specialization shall not appear in a program unless the explicit
15620 instantiation follows a declaration of the explicit specialization.
15622 For a given set of template parameters, if an explicit
15623 instantiation of a template appears after a declaration of an
15624 explicit specialization for that template, the explicit
15625 instantiation has no effect. */
15628 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t))
15632 No program shall explicitly instantiate any template more
15635 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
15636 instantiation was `extern'. If EXTERN_P then the second is.
15637 These cases are OK. */
15638 previous_instantiation_extern_p = CLASSTYPE_INTERFACE_ONLY (t);
15640 if (!previous_instantiation_extern_p && !extern_p
15641 && (complain & tf_error))
15642 permerror (input_location, "duplicate explicit instantiation of %q#T", t);
15644 /* If we've already instantiated the template, just return now. */
15645 if (!CLASSTYPE_INTERFACE_ONLY (t))
15649 check_explicit_instantiation_namespace (TYPE_NAME (t));
15650 mark_class_instantiated (t, extern_p);
15658 /* In contrast to implicit instantiation, where only the
15659 declarations, and not the definitions, of members are
15660 instantiated, we have here:
15664 The explicit instantiation of a class template specialization
15665 implies the instantiation of all of its members not
15666 previously explicitly specialized in the translation unit
15667 containing the explicit instantiation.
15669 Of course, we can't instantiate member template classes, since
15670 we don't have any arguments for them. Note that the standard
15671 is unclear on whether the instantiation of the members are
15672 *explicit* instantiations or not. However, the most natural
15673 interpretation is that it should be an explicit instantiation. */
15676 for (tmp = TYPE_METHODS (t); tmp; tmp = TREE_CHAIN (tmp))
15677 if (TREE_CODE (tmp) == FUNCTION_DECL
15678 && DECL_TEMPLATE_INSTANTIATION (tmp))
15679 instantiate_class_member (tmp, extern_p);
15681 for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp))
15682 if (TREE_CODE (tmp) == VAR_DECL && DECL_TEMPLATE_INSTANTIATION (tmp))
15683 instantiate_class_member (tmp, extern_p);
15685 if (CLASSTYPE_NESTED_UTDS (t))
15686 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t),
15687 bt_instantiate_type_proc, &storage);
15691 /* Given a function DECL, which is a specialization of TMPL, modify
15692 DECL to be a re-instantiation of TMPL with the same template
15693 arguments. TMPL should be the template into which tsubst'ing
15694 should occur for DECL, not the most general template.
15696 One reason for doing this is a scenario like this:
15699 void f(const T&, int i);
15701 void g() { f(3, 7); }
15704 void f(const T& t, const int i) { }
15706 Note that when the template is first instantiated, with
15707 instantiate_template, the resulting DECL will have no name for the
15708 first parameter, and the wrong type for the second. So, when we go
15709 to instantiate the DECL, we regenerate it. */
15712 regenerate_decl_from_template (tree decl, tree tmpl)
15714 /* The arguments used to instantiate DECL, from the most general
15719 args = DECL_TI_ARGS (decl);
15720 code_pattern = DECL_TEMPLATE_RESULT (tmpl);
15722 /* Make sure that we can see identifiers, and compute access
15724 push_access_scope (decl);
15726 if (TREE_CODE (decl) == FUNCTION_DECL)
15734 args_depth = TMPL_ARGS_DEPTH (args);
15735 parms_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
15736 if (args_depth > parms_depth)
15737 args = get_innermost_template_args (args, parms_depth);
15739 specs = tsubst_exception_specification (TREE_TYPE (code_pattern),
15740 args, tf_error, NULL_TREE);
15742 TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl),
15745 /* Merge parameter declarations. */
15746 decl_parm = skip_artificial_parms_for (decl,
15747 DECL_ARGUMENTS (decl));
15749 = skip_artificial_parms_for (code_pattern,
15750 DECL_ARGUMENTS (code_pattern));
15751 while (decl_parm && !FUNCTION_PARAMETER_PACK_P (pattern_parm))
15756 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
15757 DECL_NAME (decl_parm) = DECL_NAME (pattern_parm);
15758 parm_type = tsubst (TREE_TYPE (pattern_parm), args, tf_error,
15760 parm_type = type_decays_to (parm_type);
15761 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
15762 TREE_TYPE (decl_parm) = parm_type;
15763 attributes = DECL_ATTRIBUTES (pattern_parm);
15764 if (DECL_ATTRIBUTES (decl_parm) != attributes)
15766 DECL_ATTRIBUTES (decl_parm) = attributes;
15767 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
15769 decl_parm = TREE_CHAIN (decl_parm);
15770 pattern_parm = TREE_CHAIN (pattern_parm);
15772 /* Merge any parameters that match with the function parameter
15774 if (pattern_parm && FUNCTION_PARAMETER_PACK_P (pattern_parm))
15777 tree expanded_types;
15778 /* Expand the TYPE_PACK_EXPANSION that provides the types for
15779 the parameters in this function parameter pack. */
15780 expanded_types = tsubst_pack_expansion (TREE_TYPE (pattern_parm),
15781 args, tf_error, NULL_TREE);
15782 len = TREE_VEC_LENGTH (expanded_types);
15783 for (i = 0; i < len; i++)
15788 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
15789 /* Rename the parameter to include the index. */
15790 DECL_NAME (decl_parm) =
15791 make_ith_pack_parameter_name (DECL_NAME (pattern_parm), i);
15792 parm_type = TREE_VEC_ELT (expanded_types, i);
15793 parm_type = type_decays_to (parm_type);
15794 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
15795 TREE_TYPE (decl_parm) = parm_type;
15796 attributes = DECL_ATTRIBUTES (pattern_parm);
15797 if (DECL_ATTRIBUTES (decl_parm) != attributes)
15799 DECL_ATTRIBUTES (decl_parm) = attributes;
15800 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
15802 decl_parm = TREE_CHAIN (decl_parm);
15805 /* Merge additional specifiers from the CODE_PATTERN. */
15806 if (DECL_DECLARED_INLINE_P (code_pattern)
15807 && !DECL_DECLARED_INLINE_P (decl))
15808 DECL_DECLARED_INLINE_P (decl) = 1;
15810 else if (TREE_CODE (decl) == VAR_DECL)
15811 DECL_INITIAL (decl) =
15812 tsubst_expr (DECL_INITIAL (code_pattern), args,
15813 tf_error, DECL_TI_TEMPLATE (decl),
15814 /*integral_constant_expression_p=*/false);
15816 gcc_unreachable ();
15818 pop_access_scope (decl);
15821 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
15822 substituted to get DECL. */
15825 template_for_substitution (tree decl)
15827 tree tmpl = DECL_TI_TEMPLATE (decl);
15829 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
15830 for the instantiation. This is not always the most general
15831 template. Consider, for example:
15834 struct S { template <class U> void f();
15835 template <> void f<int>(); };
15837 and an instantiation of S<double>::f<int>. We want TD to be the
15838 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
15839 while (/* An instantiation cannot have a definition, so we need a
15840 more general template. */
15841 DECL_TEMPLATE_INSTANTIATION (tmpl)
15842 /* We must also deal with friend templates. Given:
15844 template <class T> struct S {
15845 template <class U> friend void f() {};
15848 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
15849 so far as the language is concerned, but that's still
15850 where we get the pattern for the instantiation from. On
15851 other hand, if the definition comes outside the class, say:
15853 template <class T> struct S {
15854 template <class U> friend void f();
15856 template <class U> friend void f() {}
15858 we don't need to look any further. That's what the check for
15859 DECL_INITIAL is for. */
15860 || (TREE_CODE (decl) == FUNCTION_DECL
15861 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl)
15862 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl))))
15864 /* The present template, TD, should not be a definition. If it
15865 were a definition, we should be using it! Note that we
15866 cannot restructure the loop to just keep going until we find
15867 a template with a definition, since that might go too far if
15868 a specialization was declared, but not defined. */
15869 gcc_assert (TREE_CODE (decl) != VAR_DECL
15870 || DECL_IN_AGGR_P (DECL_TEMPLATE_RESULT (tmpl)));
15872 /* Fetch the more general template. */
15873 tmpl = DECL_TI_TEMPLATE (tmpl);
15879 /* Returns true if we need to instantiate this template instance even if we
15880 know we aren't going to emit it.. */
15883 always_instantiate_p (tree decl)
15885 /* We always instantiate inline functions so that we can inline them. An
15886 explicit instantiation declaration prohibits implicit instantiation of
15887 non-inline functions. With high levels of optimization, we would
15888 normally inline non-inline functions -- but we're not allowed to do
15889 that for "extern template" functions. Therefore, we check
15890 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
15891 return ((TREE_CODE (decl) == FUNCTION_DECL
15892 && DECL_DECLARED_INLINE_P (decl))
15893 /* And we need to instantiate static data members so that
15894 their initializers are available in integral constant
15896 || (TREE_CODE (decl) == VAR_DECL
15897 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl)));
15900 /* Produce the definition of D, a _DECL generated from a template. If
15901 DEFER_OK is nonzero, then we don't have to actually do the
15902 instantiation now; we just have to do it sometime. Normally it is
15903 an error if this is an explicit instantiation but D is undefined.
15904 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
15905 explicitly instantiated class template. */
15908 instantiate_decl (tree d, int defer_ok,
15909 bool expl_inst_class_mem_p)
15911 tree tmpl = DECL_TI_TEMPLATE (d);
15918 bool pattern_defined;
15920 location_t saved_loc = input_location;
15923 /* This function should only be used to instantiate templates for
15924 functions and static member variables. */
15925 gcc_assert (TREE_CODE (d) == FUNCTION_DECL
15926 || TREE_CODE (d) == VAR_DECL);
15928 /* Variables are never deferred; if instantiation is required, they
15929 are instantiated right away. That allows for better code in the
15930 case that an expression refers to the value of the variable --
15931 if the variable has a constant value the referring expression can
15932 take advantage of that fact. */
15933 if (TREE_CODE (d) == VAR_DECL)
15936 /* Don't instantiate cloned functions. Instead, instantiate the
15937 functions they cloned. */
15938 if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d))
15939 d = DECL_CLONED_FUNCTION (d);
15941 if (DECL_TEMPLATE_INSTANTIATED (d)
15942 || DECL_TEMPLATE_SPECIALIZATION (d))
15943 /* D has already been instantiated or explicitly specialized, so
15944 there's nothing for us to do here.
15946 It might seem reasonable to check whether or not D is an explicit
15947 instantiation, and, if so, stop here. But when an explicit
15948 instantiation is deferred until the end of the compilation,
15949 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
15950 the instantiation. */
15953 /* Check to see whether we know that this template will be
15954 instantiated in some other file, as with "extern template"
15956 external_p = (DECL_INTERFACE_KNOWN (d) && DECL_REALLY_EXTERN (d));
15958 /* In general, we do not instantiate such templates. */
15959 if (external_p && !always_instantiate_p (d))
15962 gen_tmpl = most_general_template (tmpl);
15963 gen_args = DECL_TI_ARGS (d);
15965 if (tmpl != gen_tmpl)
15966 /* We should already have the extra args. */
15967 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl))
15968 == TMPL_ARGS_DEPTH (gen_args));
15969 /* And what's in the hash table should match D. */
15970 gcc_assert ((spec = retrieve_specialization (gen_tmpl, gen_args, 0)) == d
15971 || spec == NULL_TREE);
15973 /* This needs to happen before any tsubsting. */
15974 if (! push_tinst_level (d))
15977 timevar_push (TV_PARSE);
15979 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
15980 for the instantiation. */
15981 td = template_for_substitution (d);
15982 code_pattern = DECL_TEMPLATE_RESULT (td);
15984 /* We should never be trying to instantiate a member of a class
15985 template or partial specialization. */
15986 gcc_assert (d != code_pattern);
15988 if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d))
15989 || DECL_TEMPLATE_SPECIALIZATION (td))
15990 /* In the case of a friend template whose definition is provided
15991 outside the class, we may have too many arguments. Drop the
15992 ones we don't need. The same is true for specializations. */
15993 args = get_innermost_template_args
15994 (gen_args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td)));
15998 if (TREE_CODE (d) == FUNCTION_DECL)
15999 pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE);
16001 pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
16003 /* We may be in the middle of deferred access check. Disable it now. */
16004 push_deferring_access_checks (dk_no_deferred);
16006 /* Unless an explicit instantiation directive has already determined
16007 the linkage of D, remember that a definition is available for
16009 if (pattern_defined
16010 && !DECL_INTERFACE_KNOWN (d)
16011 && !DECL_NOT_REALLY_EXTERN (d))
16012 mark_definable (d);
16014 input_location = DECL_SOURCE_LOCATION (d);
16016 /* If D is a member of an explicitly instantiated class template,
16017 and no definition is available, treat it like an implicit
16019 if (!pattern_defined && expl_inst_class_mem_p
16020 && DECL_EXPLICIT_INSTANTIATION (d))
16022 DECL_NOT_REALLY_EXTERN (d) = 0;
16023 DECL_INTERFACE_KNOWN (d) = 0;
16024 SET_DECL_IMPLICIT_INSTANTIATION (d);
16027 /* Recheck the substitutions to obtain any warning messages
16028 about ignoring cv qualifiers. Don't do this for artificial decls,
16029 as it breaks the context-sensitive substitution for lambda op(). */
16030 if (!defer_ok && !DECL_ARTIFICIAL (d))
16032 tree gen = DECL_TEMPLATE_RESULT (gen_tmpl);
16033 tree type = TREE_TYPE (gen);
16035 /* Make sure that we can see identifiers, and compute access
16036 correctly. D is already the target FUNCTION_DECL with the
16038 push_access_scope (d);
16040 if (TREE_CODE (gen) == FUNCTION_DECL)
16042 tsubst (DECL_ARGUMENTS (gen), gen_args, tf_warning_or_error, d);
16043 tsubst_exception_specification (type, gen_args, tf_warning_or_error,
16045 /* Don't simply tsubst the function type, as that will give
16046 duplicate warnings about poor parameter qualifications.
16047 The function arguments are the same as the decl_arguments
16048 without the top level cv qualifiers. */
16049 type = TREE_TYPE (type);
16051 tsubst (type, gen_args, tf_warning_or_error, d);
16053 pop_access_scope (d);
16056 /* Defer all other templates, unless we have been explicitly
16057 forbidden from doing so. */
16058 if (/* If there is no definition, we cannot instantiate the
16061 /* If it's OK to postpone instantiation, do so. */
16063 /* If this is a static data member that will be defined
16064 elsewhere, we don't want to instantiate the entire data
16065 member, but we do want to instantiate the initializer so that
16066 we can substitute that elsewhere. */
16067 || (external_p && TREE_CODE (d) == VAR_DECL))
16069 /* The definition of the static data member is now required so
16070 we must substitute the initializer. */
16071 if (TREE_CODE (d) == VAR_DECL
16072 && !DECL_INITIAL (d)
16073 && DECL_INITIAL (code_pattern))
16078 ns = decl_namespace_context (d);
16079 push_nested_namespace (ns);
16080 push_nested_class (DECL_CONTEXT (d));
16081 init = tsubst_expr (DECL_INITIAL (code_pattern),
16083 tf_warning_or_error, NULL_TREE,
16084 /*integral_constant_expression_p=*/false);
16085 cp_finish_decl (d, init, /*init_const_expr_p=*/false,
16086 /*asmspec_tree=*/NULL_TREE,
16087 LOOKUP_ONLYCONVERTING);
16088 pop_nested_class ();
16089 pop_nested_namespace (ns);
16092 /* We restore the source position here because it's used by
16093 add_pending_template. */
16094 input_location = saved_loc;
16096 if (at_eof && !pattern_defined
16097 && DECL_EXPLICIT_INSTANTIATION (d)
16098 && DECL_NOT_REALLY_EXTERN (d))
16101 The definition of a non-exported function template, a
16102 non-exported member function template, or a non-exported
16103 member function or static data member of a class template
16104 shall be present in every translation unit in which it is
16105 explicitly instantiated. */
16106 permerror (input_location, "explicit instantiation of %qD "
16107 "but no definition available", d);
16109 /* ??? Historically, we have instantiated inline functions, even
16110 when marked as "extern template". */
16111 if (!(external_p && TREE_CODE (d) == VAR_DECL))
16112 add_pending_template (d);
16115 /* Tell the repository that D is available in this translation unit
16116 -- and see if it is supposed to be instantiated here. */
16117 if (TREE_PUBLIC (d) && !DECL_REALLY_EXTERN (d) && !repo_emit_p (d))
16119 /* In a PCH file, despite the fact that the repository hasn't
16120 requested instantiation in the PCH it is still possible that
16121 an instantiation will be required in a file that includes the
16124 add_pending_template (d);
16125 /* Instantiate inline functions so that the inliner can do its
16126 job, even though we'll not be emitting a copy of this
16128 if (!(TREE_CODE (d) == FUNCTION_DECL && possibly_inlined_p (d)))
16132 need_push = !cfun || !global_bindings_p ();
16134 push_to_top_level ();
16136 /* Mark D as instantiated so that recursive calls to
16137 instantiate_decl do not try to instantiate it again. */
16138 DECL_TEMPLATE_INSTANTIATED (d) = 1;
16140 /* Regenerate the declaration in case the template has been modified
16141 by a subsequent redeclaration. */
16142 regenerate_decl_from_template (d, td);
16144 /* We already set the file and line above. Reset them now in case
16145 they changed as a result of calling regenerate_decl_from_template. */
16146 input_location = DECL_SOURCE_LOCATION (d);
16148 if (TREE_CODE (d) == VAR_DECL)
16152 /* Clear out DECL_RTL; whatever was there before may not be right
16153 since we've reset the type of the declaration. */
16154 SET_DECL_RTL (d, NULL_RTX);
16155 DECL_IN_AGGR_P (d) = 0;
16157 /* The initializer is placed in DECL_INITIAL by
16158 regenerate_decl_from_template. Pull it out so that
16159 cp_finish_decl can process it. */
16160 init = DECL_INITIAL (d);
16161 DECL_INITIAL (d) = NULL_TREE;
16162 DECL_INITIALIZED_P (d) = 0;
16164 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
16165 initializer. That function will defer actual emission until
16166 we have a chance to determine linkage. */
16167 DECL_EXTERNAL (d) = 0;
16169 /* Enter the scope of D so that access-checking works correctly. */
16170 push_nested_class (DECL_CONTEXT (d));
16171 cp_finish_decl (d, init, false, NULL_TREE, 0);
16172 pop_nested_class ();
16174 else if (TREE_CODE (d) == FUNCTION_DECL)
16176 htab_t saved_local_specializations;
16181 /* Save away the current list, in case we are instantiating one
16182 template from within the body of another. */
16183 saved_local_specializations = local_specializations;
16185 /* Set up the list of local specializations. */
16186 local_specializations = htab_create (37,
16187 hash_local_specialization,
16188 eq_local_specializations,
16191 /* Set up context. */
16192 start_preparsed_function (d, NULL_TREE, SF_PRE_PARSED);
16194 /* Create substitution entries for the parameters. */
16195 subst_decl = DECL_TEMPLATE_RESULT (template_for_substitution (d));
16196 tmpl_parm = DECL_ARGUMENTS (subst_decl);
16197 spec_parm = DECL_ARGUMENTS (d);
16198 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d))
16200 register_local_specialization (spec_parm, tmpl_parm);
16201 spec_parm = skip_artificial_parms_for (d, spec_parm);
16202 tmpl_parm = skip_artificial_parms_for (subst_decl, tmpl_parm);
16204 while (tmpl_parm && !FUNCTION_PARAMETER_PACK_P (tmpl_parm))
16206 register_local_specialization (spec_parm, tmpl_parm);
16207 tmpl_parm = TREE_CHAIN (tmpl_parm);
16208 spec_parm = TREE_CHAIN (spec_parm);
16210 if (tmpl_parm && FUNCTION_PARAMETER_PACK_P (tmpl_parm))
16212 /* Register the (value) argument pack as a specialization of
16213 TMPL_PARM, then move on. */
16214 tree argpack = make_fnparm_pack (spec_parm);
16215 register_local_specialization (argpack, tmpl_parm);
16216 tmpl_parm = TREE_CHAIN (tmpl_parm);
16217 spec_parm = NULL_TREE;
16219 gcc_assert (!spec_parm);
16221 /* Substitute into the body of the function. */
16222 tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
16223 tf_warning_or_error, tmpl,
16224 /*integral_constant_expression_p=*/false);
16226 /* Set the current input_location to the end of the function
16227 so that finish_function knows where we are. */
16228 input_location = DECL_STRUCT_FUNCTION (code_pattern)->function_end_locus;
16230 /* We don't need the local specializations any more. */
16231 htab_delete (local_specializations);
16232 local_specializations = saved_local_specializations;
16234 /* Finish the function. */
16235 d = finish_function (0);
16236 expand_or_defer_fn (d);
16239 /* We're not deferring instantiation any more. */
16240 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
16243 pop_from_top_level ();
16246 input_location = saved_loc;
16247 pop_deferring_access_checks ();
16248 pop_tinst_level ();
16250 timevar_pop (TV_PARSE);
16255 /* Run through the list of templates that we wish we could
16256 instantiate, and instantiate any we can. RETRIES is the
16257 number of times we retry pending template instantiation. */
16260 instantiate_pending_templates (int retries)
16263 location_t saved_loc = input_location;
16265 /* Instantiating templates may trigger vtable generation. This in turn
16266 may require further template instantiations. We place a limit here
16267 to avoid infinite loop. */
16268 if (pending_templates && retries >= max_tinst_depth)
16270 tree decl = pending_templates->tinst->decl;
16272 error ("template instantiation depth exceeds maximum of %d"
16273 " instantiating %q+D, possibly from virtual table generation"
16274 " (use -ftemplate-depth-NN to increase the maximum)",
16275 max_tinst_depth, decl);
16276 if (TREE_CODE (decl) == FUNCTION_DECL)
16277 /* Pretend that we defined it. */
16278 DECL_INITIAL (decl) = error_mark_node;
16284 struct pending_template **t = &pending_templates;
16285 struct pending_template *last = NULL;
16289 tree instantiation = reopen_tinst_level ((*t)->tinst);
16290 bool complete = false;
16292 if (TYPE_P (instantiation))
16296 if (!COMPLETE_TYPE_P (instantiation))
16298 instantiate_class_template (instantiation);
16299 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
16300 for (fn = TYPE_METHODS (instantiation);
16302 fn = TREE_CHAIN (fn))
16303 if (! DECL_ARTIFICIAL (fn))
16304 instantiate_decl (fn,
16306 /*expl_inst_class_mem_p=*/false);
16307 if (COMPLETE_TYPE_P (instantiation))
16311 complete = COMPLETE_TYPE_P (instantiation);
16315 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation)
16316 && !DECL_TEMPLATE_INSTANTIATED (instantiation))
16319 = instantiate_decl (instantiation,
16321 /*expl_inst_class_mem_p=*/false);
16322 if (DECL_TEMPLATE_INSTANTIATED (instantiation))
16326 complete = (DECL_TEMPLATE_SPECIALIZATION (instantiation)
16327 || DECL_TEMPLATE_INSTANTIATED (instantiation));
16331 /* If INSTANTIATION has been instantiated, then we don't
16332 need to consider it again in the future. */
16340 current_tinst_level = NULL;
16342 last_pending_template = last;
16344 while (reconsider);
16346 input_location = saved_loc;
16349 /* Substitute ARGVEC into T, which is a list of initializers for
16350 either base class or a non-static data member. The TREE_PURPOSEs
16351 are DECLs, and the TREE_VALUEs are the initializer values. Used by
16352 instantiate_decl. */
16355 tsubst_initializer_list (tree t, tree argvec)
16357 tree inits = NULL_TREE;
16359 for (; t; t = TREE_CHAIN (t))
16363 tree expanded_bases = NULL_TREE;
16364 tree expanded_arguments = NULL_TREE;
16367 if (TREE_CODE (TREE_PURPOSE (t)) == TYPE_PACK_EXPANSION)
16372 /* Expand the base class expansion type into separate base
16374 expanded_bases = tsubst_pack_expansion (TREE_PURPOSE (t), argvec,
16375 tf_warning_or_error,
16377 if (expanded_bases == error_mark_node)
16380 /* We'll be building separate TREE_LISTs of arguments for
16382 len = TREE_VEC_LENGTH (expanded_bases);
16383 expanded_arguments = make_tree_vec (len);
16384 for (i = 0; i < len; i++)
16385 TREE_VEC_ELT (expanded_arguments, i) = NULL_TREE;
16387 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
16388 expand each argument in the TREE_VALUE of t. */
16389 expr = make_node (EXPR_PACK_EXPANSION);
16390 PACK_EXPANSION_PARAMETER_PACKS (expr) =
16391 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t));
16393 if (TREE_VALUE (t) == void_type_node)
16394 /* VOID_TYPE_NODE is used to indicate
16395 value-initialization. */
16397 for (i = 0; i < len; i++)
16398 TREE_VEC_ELT (expanded_arguments, i) = void_type_node;
16402 /* Substitute parameter packs into each argument in the
16404 in_base_initializer = 1;
16405 for (arg = TREE_VALUE (t); arg; arg = TREE_CHAIN (arg))
16407 tree expanded_exprs;
16409 /* Expand the argument. */
16410 SET_PACK_EXPANSION_PATTERN (expr, TREE_VALUE (arg));
16412 = tsubst_pack_expansion (expr, argvec,
16413 tf_warning_or_error,
16415 if (expanded_exprs == error_mark_node)
16418 /* Prepend each of the expanded expressions to the
16419 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
16420 for (i = 0; i < len; i++)
16422 TREE_VEC_ELT (expanded_arguments, i) =
16423 tree_cons (NULL_TREE,
16424 TREE_VEC_ELT (expanded_exprs, i),
16425 TREE_VEC_ELT (expanded_arguments, i));
16428 in_base_initializer = 0;
16430 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
16431 since we built them backwards. */
16432 for (i = 0; i < len; i++)
16434 TREE_VEC_ELT (expanded_arguments, i) =
16435 nreverse (TREE_VEC_ELT (expanded_arguments, i));
16440 for (i = 0; i < len; ++i)
16442 if (expanded_bases)
16444 decl = TREE_VEC_ELT (expanded_bases, i);
16445 decl = expand_member_init (decl);
16446 init = TREE_VEC_ELT (expanded_arguments, i);
16450 decl = tsubst_copy (TREE_PURPOSE (t), argvec,
16451 tf_warning_or_error, NULL_TREE);
16453 decl = expand_member_init (decl);
16454 if (decl && !DECL_P (decl))
16455 in_base_initializer = 1;
16457 init = tsubst_expr (TREE_VALUE (t), argvec,
16458 tf_warning_or_error, NULL_TREE,
16459 /*integral_constant_expression_p=*/false);
16460 in_base_initializer = 0;
16465 init = build_tree_list (decl, init);
16466 TREE_CHAIN (init) = inits;
16474 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
16477 set_current_access_from_decl (tree decl)
16479 if (TREE_PRIVATE (decl))
16480 current_access_specifier = access_private_node;
16481 else if (TREE_PROTECTED (decl))
16482 current_access_specifier = access_protected_node;
16484 current_access_specifier = access_public_node;
16487 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
16488 is the instantiation (which should have been created with
16489 start_enum) and ARGS are the template arguments to use. */
16492 tsubst_enum (tree tag, tree newtag, tree args)
16496 for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
16501 decl = TREE_VALUE (e);
16502 /* Note that in a template enum, the TREE_VALUE is the
16503 CONST_DECL, not the corresponding INTEGER_CST. */
16504 value = tsubst_expr (DECL_INITIAL (decl),
16505 args, tf_warning_or_error, NULL_TREE,
16506 /*integral_constant_expression_p=*/true);
16508 /* Give this enumeration constant the correct access. */
16509 set_current_access_from_decl (decl);
16511 /* Actually build the enumerator itself. */
16512 build_enumerator (DECL_NAME (decl), value, newtag);
16515 finish_enum (newtag);
16516 DECL_SOURCE_LOCATION (TYPE_NAME (newtag))
16517 = DECL_SOURCE_LOCATION (TYPE_NAME (tag));
16520 /* DECL is a FUNCTION_DECL that is a template specialization. Return
16521 its type -- but without substituting the innermost set of template
16522 arguments. So, innermost set of template parameters will appear in
16526 get_mostly_instantiated_function_type (tree decl)
16534 tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
16535 targs = DECL_TI_ARGS (decl);
16536 tparms = DECL_TEMPLATE_PARMS (tmpl);
16537 parm_depth = TMPL_PARMS_DEPTH (tparms);
16539 /* There should be as many levels of arguments as there are levels
16541 gcc_assert (parm_depth == TMPL_ARGS_DEPTH (targs));
16543 fn_type = TREE_TYPE (tmpl);
16545 if (parm_depth == 1)
16546 /* No substitution is necessary. */
16550 int i, save_access_control;
16553 /* Replace the innermost level of the TARGS with NULL_TREEs to
16554 let tsubst know not to substitute for those parameters. */
16555 partial_args = make_tree_vec (TREE_VEC_LENGTH (targs));
16556 for (i = 1; i < TMPL_ARGS_DEPTH (targs); ++i)
16557 SET_TMPL_ARGS_LEVEL (partial_args, i,
16558 TMPL_ARGS_LEVEL (targs, i));
16559 SET_TMPL_ARGS_LEVEL (partial_args,
16560 TMPL_ARGS_DEPTH (targs),
16561 make_tree_vec (DECL_NTPARMS (tmpl)));
16563 /* Disable access control as this function is used only during
16565 save_access_control = flag_access_control;
16566 flag_access_control = 0;
16568 ++processing_template_decl;
16569 /* Now, do the (partial) substitution to figure out the
16570 appropriate function type. */
16571 fn_type = tsubst (fn_type, partial_args, tf_error, NULL_TREE);
16572 --processing_template_decl;
16574 /* Substitute into the template parameters to obtain the real
16575 innermost set of parameters. This step is important if the
16576 innermost set of template parameters contains value
16577 parameters whose types depend on outer template parameters. */
16578 TREE_VEC_LENGTH (partial_args)--;
16579 tparms = tsubst_template_parms (tparms, partial_args, tf_error);
16581 flag_access_control = save_access_control;
16587 /* Return truthvalue if we're processing a template different from
16588 the last one involved in diagnostics. */
16590 problematic_instantiation_changed (void)
16592 return last_template_error_tick != tinst_level_tick;
16595 /* Remember current template involved in diagnostics. */
16597 record_last_problematic_instantiation (void)
16599 last_template_error_tick = tinst_level_tick;
16602 struct tinst_level *
16603 current_instantiation (void)
16605 return current_tinst_level;
16608 /* [temp.param] Check that template non-type parm TYPE is of an allowable
16609 type. Return zero for ok, nonzero for disallowed. Issue error and
16610 warning messages under control of COMPLAIN. */
16613 invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain)
16615 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type))
16617 else if (POINTER_TYPE_P (type))
16619 else if (TYPE_PTR_TO_MEMBER_P (type))
16621 else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
16623 else if (TREE_CODE (type) == TYPENAME_TYPE)
16626 if (complain & tf_error)
16627 error ("%q#T is not a valid type for a template constant parameter", type);
16631 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
16632 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
16635 dependent_type_p_r (tree type)
16641 A type is dependent if it is:
16643 -- a template parameter. Template template parameters are types
16644 for us (since TYPE_P holds true for them) so we handle
16646 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
16647 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
16649 /* -- a qualified-id with a nested-name-specifier which contains a
16650 class-name that names a dependent type or whose unqualified-id
16651 names a dependent type. */
16652 if (TREE_CODE (type) == TYPENAME_TYPE)
16654 /* -- a cv-qualified type where the cv-unqualified type is
16656 type = TYPE_MAIN_VARIANT (type);
16657 /* -- a compound type constructed from any dependent type. */
16658 if (TYPE_PTR_TO_MEMBER_P (type))
16659 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type))
16660 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
16662 else if (TREE_CODE (type) == POINTER_TYPE
16663 || TREE_CODE (type) == REFERENCE_TYPE)
16664 return dependent_type_p (TREE_TYPE (type));
16665 else if (TREE_CODE (type) == FUNCTION_TYPE
16666 || TREE_CODE (type) == METHOD_TYPE)
16670 if (dependent_type_p (TREE_TYPE (type)))
16672 for (arg_type = TYPE_ARG_TYPES (type);
16674 arg_type = TREE_CHAIN (arg_type))
16675 if (dependent_type_p (TREE_VALUE (arg_type)))
16679 /* -- an array type constructed from any dependent type or whose
16680 size is specified by a constant expression that is
16681 value-dependent. */
16682 if (TREE_CODE (type) == ARRAY_TYPE)
16684 if (TYPE_DOMAIN (type)
16685 && dependent_type_p (TYPE_DOMAIN (type)))
16687 return dependent_type_p (TREE_TYPE (type));
16689 else if (TREE_CODE (type) == INTEGER_TYPE
16690 && !TREE_CONSTANT (TYPE_MAX_VALUE (type)))
16692 /* If this is the TYPE_DOMAIN of an array type, consider it
16693 dependent. We already checked for value-dependence in
16694 compute_array_index_type. */
16695 return type_dependent_expression_p (TYPE_MAX_VALUE (type));
16698 /* -- a template-id in which either the template name is a template
16700 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
16702 /* ... or any of the template arguments is a dependent type or
16703 an expression that is type-dependent or value-dependent. */
16704 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
16705 && (any_dependent_template_arguments_p
16706 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
16709 /* All TYPEOF_TYPEs and DECLTYPE_TYPEs are dependent; if the
16710 argument of the `typeof' expression is not type-dependent, then
16711 it should already been have resolved. */
16712 if (TREE_CODE (type) == TYPEOF_TYPE
16713 || TREE_CODE (type) == DECLTYPE_TYPE)
16716 /* A template argument pack is dependent if any of its packed
16718 if (TREE_CODE (type) == TYPE_ARGUMENT_PACK)
16720 tree args = ARGUMENT_PACK_ARGS (type);
16721 int i, len = TREE_VEC_LENGTH (args);
16722 for (i = 0; i < len; ++i)
16723 if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
16727 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
16728 be template parameters. */
16729 if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
16732 /* The standard does not specifically mention types that are local
16733 to template functions or local classes, but they should be
16734 considered dependent too. For example:
16736 template <int I> void f() {
16741 The size of `E' cannot be known until the value of `I' has been
16742 determined. Therefore, `E' must be considered dependent. */
16743 scope = TYPE_CONTEXT (type);
16744 if (scope && TYPE_P (scope))
16745 return dependent_type_p (scope);
16746 else if (scope && TREE_CODE (scope) == FUNCTION_DECL)
16747 return type_dependent_expression_p (scope);
16749 /* Other types are non-dependent. */
16753 /* Returns TRUE if TYPE is dependent, in the sense of
16754 [temp.dep.type]. */
16757 dependent_type_p (tree type)
16759 /* If there are no template parameters in scope, then there can't be
16760 any dependent types. */
16761 if (!processing_template_decl)
16763 /* If we are not processing a template, then nobody should be
16764 providing us with a dependent type. */
16766 gcc_assert (TREE_CODE (type) != TEMPLATE_TYPE_PARM || is_auto (type));
16770 /* If the type is NULL, we have not computed a type for the entity
16771 in question; in that case, the type is dependent. */
16775 /* Erroneous types can be considered non-dependent. */
16776 if (type == error_mark_node)
16779 /* If we have not already computed the appropriate value for TYPE,
16781 if (!TYPE_DEPENDENT_P_VALID (type))
16783 TYPE_DEPENDENT_P (type) = dependent_type_p_r (type);
16784 TYPE_DEPENDENT_P_VALID (type) = 1;
16787 return TYPE_DEPENDENT_P (type);
16790 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
16791 lookup. In other words, a dependent type that is not the current
16795 dependent_scope_p (tree scope)
16797 return (scope && TYPE_P (scope) && dependent_type_p (scope)
16798 && !currently_open_class (scope));
16801 /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
16804 dependent_scope_ref_p (tree expression, bool criterion (tree))
16809 gcc_assert (TREE_CODE (expression) == SCOPE_REF);
16811 if (!TYPE_P (TREE_OPERAND (expression, 0)))
16814 scope = TREE_OPERAND (expression, 0);
16815 name = TREE_OPERAND (expression, 1);
16819 An id-expression is type-dependent if it contains a
16820 nested-name-specifier that contains a class-name that names a
16822 /* The suggested resolution to Core Issue 224 implies that if the
16823 qualifying type is the current class, then we must peek
16826 && currently_open_class (scope)
16827 && !criterion (name))
16829 if (dependent_type_p (scope))
16835 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
16836 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
16840 value_dependent_expression_p (tree expression)
16842 if (!processing_template_decl)
16845 /* A name declared with a dependent type. */
16846 if (DECL_P (expression) && type_dependent_expression_p (expression))
16849 switch (TREE_CODE (expression))
16851 case IDENTIFIER_NODE:
16852 /* A name that has not been looked up -- must be dependent. */
16855 case TEMPLATE_PARM_INDEX:
16856 /* A non-type template parm. */
16860 /* A non-type template parm. */
16861 if (DECL_TEMPLATE_PARM_P (expression))
16863 return value_dependent_expression_p (DECL_INITIAL (expression));
16866 /* A constant with integral or enumeration type and is initialized
16867 with an expression that is value-dependent. */
16868 if (DECL_INITIAL (expression)
16869 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression))
16870 && value_dependent_expression_p (DECL_INITIAL (expression)))
16874 case DYNAMIC_CAST_EXPR:
16875 case STATIC_CAST_EXPR:
16876 case CONST_CAST_EXPR:
16877 case REINTERPRET_CAST_EXPR:
16879 /* These expressions are value-dependent if the type to which
16880 the cast occurs is dependent or the expression being casted
16881 is value-dependent. */
16883 tree type = TREE_TYPE (expression);
16885 if (dependent_type_p (type))
16888 /* A functional cast has a list of operands. */
16889 expression = TREE_OPERAND (expression, 0);
16892 /* If there are no operands, it must be an expression such
16893 as "int()". This should not happen for aggregate types
16894 because it would form non-constant expressions. */
16895 gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type));
16900 if (TREE_CODE (expression) == TREE_LIST)
16901 return any_value_dependent_elements_p (expression);
16903 return value_dependent_expression_p (expression);
16908 /* A `sizeof' expression is value-dependent if the operand is
16909 type-dependent or is a pack expansion. */
16910 expression = TREE_OPERAND (expression, 0);
16911 if (PACK_EXPANSION_P (expression))
16913 else if (TYPE_P (expression))
16914 return dependent_type_p (expression);
16915 return type_dependent_expression_p (expression);
16918 return dependent_scope_ref_p (expression, value_dependent_expression_p);
16920 case COMPONENT_REF:
16921 return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
16922 || value_dependent_expression_p (TREE_OPERAND (expression, 1)));
16925 /* A CALL_EXPR may appear in a constant expression if it is a
16926 call to a builtin function, e.g., __builtin_constant_p. All
16927 such calls are value-dependent. */
16930 case NONTYPE_ARGUMENT_PACK:
16931 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
16932 is value-dependent. */
16934 tree values = ARGUMENT_PACK_ARGS (expression);
16935 int i, len = TREE_VEC_LENGTH (values);
16937 for (i = 0; i < len; ++i)
16938 if (value_dependent_expression_p (TREE_VEC_ELT (values, i)))
16946 tree type2 = TRAIT_EXPR_TYPE2 (expression);
16947 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression))
16948 || (type2 ? dependent_type_p (type2) : false));
16952 return ((value_dependent_expression_p (TREE_OPERAND (expression, 0)))
16953 || (value_dependent_expression_p (TREE_OPERAND (expression, 2))));
16956 /* A constant expression is value-dependent if any subexpression is
16957 value-dependent. */
16958 switch (TREE_CODE_CLASS (TREE_CODE (expression)))
16960 case tcc_reference:
16962 return (value_dependent_expression_p
16963 (TREE_OPERAND (expression, 0)));
16965 case tcc_comparison:
16967 return ((value_dependent_expression_p
16968 (TREE_OPERAND (expression, 0)))
16969 || (value_dependent_expression_p
16970 (TREE_OPERAND (expression, 1))));
16972 case tcc_expression:
16976 for (i = 0; i < TREE_OPERAND_LENGTH (expression); ++i)
16977 /* In some cases, some of the operands may be missing.
16978 (For example, in the case of PREDECREMENT_EXPR, the
16979 amount to increment by may be missing.) That doesn't
16980 make the expression dependent. */
16981 if (TREE_OPERAND (expression, i)
16982 && (value_dependent_expression_p
16983 (TREE_OPERAND (expression, i))))
16993 /* The expression is not value-dependent. */
16997 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
16998 [temp.dep.expr]. */
17001 type_dependent_expression_p (tree expression)
17003 if (!processing_template_decl)
17006 if (expression == error_mark_node)
17009 /* An unresolved name is always dependent. */
17010 if (TREE_CODE (expression) == IDENTIFIER_NODE
17011 || TREE_CODE (expression) == USING_DECL)
17014 /* Some expression forms are never type-dependent. */
17015 if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR
17016 || TREE_CODE (expression) == SIZEOF_EXPR
17017 || TREE_CODE (expression) == ALIGNOF_EXPR
17018 || TREE_CODE (expression) == TRAIT_EXPR
17019 || TREE_CODE (expression) == TYPEID_EXPR
17020 || TREE_CODE (expression) == DELETE_EXPR
17021 || TREE_CODE (expression) == VEC_DELETE_EXPR
17022 || TREE_CODE (expression) == THROW_EXPR)
17025 /* The types of these expressions depends only on the type to which
17026 the cast occurs. */
17027 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
17028 || TREE_CODE (expression) == STATIC_CAST_EXPR
17029 || TREE_CODE (expression) == CONST_CAST_EXPR
17030 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
17031 || TREE_CODE (expression) == CAST_EXPR)
17032 return dependent_type_p (TREE_TYPE (expression));
17034 /* The types of these expressions depends only on the type created
17035 by the expression. */
17036 if (TREE_CODE (expression) == NEW_EXPR
17037 || TREE_CODE (expression) == VEC_NEW_EXPR)
17039 /* For NEW_EXPR tree nodes created inside a template, either
17040 the object type itself or a TREE_LIST may appear as the
17042 tree type = TREE_OPERAND (expression, 1);
17043 if (TREE_CODE (type) == TREE_LIST)
17044 /* This is an array type. We need to check array dimensions
17046 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type)))
17047 || value_dependent_expression_p
17048 (TREE_OPERAND (TREE_VALUE (type), 1));
17050 return dependent_type_p (type);
17053 if (TREE_CODE (expression) == SCOPE_REF
17054 && dependent_scope_ref_p (expression,
17055 type_dependent_expression_p))
17058 if (TREE_CODE (expression) == FUNCTION_DECL
17059 && DECL_LANG_SPECIFIC (expression)
17060 && DECL_TEMPLATE_INFO (expression)
17061 && (any_dependent_template_arguments_p
17062 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
17065 if (TREE_CODE (expression) == TEMPLATE_DECL
17066 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression))
17069 if (TREE_CODE (expression) == STMT_EXPR)
17070 expression = stmt_expr_value_expr (expression);
17072 if (BRACE_ENCLOSED_INITIALIZER_P (expression))
17077 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression), i, elt)
17079 if (type_dependent_expression_p (elt))
17085 if (TREE_TYPE (expression) == unknown_type_node)
17087 if (TREE_CODE (expression) == ADDR_EXPR)
17088 return type_dependent_expression_p (TREE_OPERAND (expression, 0));
17089 if (TREE_CODE (expression) == COMPONENT_REF
17090 || TREE_CODE (expression) == OFFSET_REF)
17092 if (type_dependent_expression_p (TREE_OPERAND (expression, 0)))
17094 expression = TREE_OPERAND (expression, 1);
17095 if (TREE_CODE (expression) == IDENTIFIER_NODE)
17098 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
17099 if (TREE_CODE (expression) == SCOPE_REF)
17102 if (TREE_CODE (expression) == BASELINK)
17103 expression = BASELINK_FUNCTIONS (expression);
17105 if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
17107 if (any_dependent_template_arguments_p
17108 (TREE_OPERAND (expression, 1)))
17110 expression = TREE_OPERAND (expression, 0);
17112 gcc_assert (TREE_CODE (expression) == OVERLOAD
17113 || TREE_CODE (expression) == FUNCTION_DECL);
17117 if (type_dependent_expression_p (OVL_CURRENT (expression)))
17119 expression = OVL_NEXT (expression);
17124 gcc_assert (TREE_CODE (expression) != TYPE_DECL);
17126 return (dependent_type_p (TREE_TYPE (expression)));
17129 /* Like type_dependent_expression_p, but it also works while not processing
17130 a template definition, i.e. during substitution or mangling. */
17133 type_dependent_expression_p_push (tree expr)
17136 ++processing_template_decl;
17137 b = type_dependent_expression_p (expr);
17138 --processing_template_decl;
17142 /* Returns TRUE if ARGS contains a type-dependent expression. */
17145 any_type_dependent_arguments_p (const VEC(tree,gc) *args)
17150 for (i = 0; VEC_iterate (tree, args, i, arg); ++i)
17152 if (type_dependent_expression_p (arg))
17158 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
17159 expressions) contains any value-dependent expressions. */
17162 any_value_dependent_elements_p (const_tree list)
17164 for (; list; list = TREE_CHAIN (list))
17165 if (value_dependent_expression_p (TREE_VALUE (list)))
17171 /* Returns TRUE if the ARG (a template argument) is dependent. */
17174 dependent_template_arg_p (tree arg)
17176 if (!processing_template_decl)
17179 if (TREE_CODE (arg) == TEMPLATE_DECL
17180 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
17181 return dependent_template_p (arg);
17182 else if (ARGUMENT_PACK_P (arg))
17184 tree args = ARGUMENT_PACK_ARGS (arg);
17185 int i, len = TREE_VEC_LENGTH (args);
17186 for (i = 0; i < len; ++i)
17188 if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
17194 else if (TYPE_P (arg))
17195 return dependent_type_p (arg);
17197 return (type_dependent_expression_p (arg)
17198 || value_dependent_expression_p (arg));
17201 /* Returns true if ARGS (a collection of template arguments) contains
17202 any types that require structural equality testing. */
17205 any_template_arguments_need_structural_equality_p (tree args)
17212 if (args == error_mark_node)
17215 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
17217 tree level = TMPL_ARGS_LEVEL (args, i + 1);
17218 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
17220 tree arg = TREE_VEC_ELT (level, j);
17221 tree packed_args = NULL_TREE;
17224 if (ARGUMENT_PACK_P (arg))
17226 /* Look inside the argument pack. */
17227 packed_args = ARGUMENT_PACK_ARGS (arg);
17228 len = TREE_VEC_LENGTH (packed_args);
17231 for (k = 0; k < len; ++k)
17234 arg = TREE_VEC_ELT (packed_args, k);
17236 if (error_operand_p (arg))
17238 else if (TREE_CODE (arg) == TEMPLATE_DECL
17239 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
17241 else if (TYPE_P (arg) && TYPE_STRUCTURAL_EQUALITY_P (arg))
17243 else if (!TYPE_P (arg) && TREE_TYPE (arg)
17244 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg)))
17253 /* Returns true if ARGS (a collection of template arguments) contains
17254 any dependent arguments. */
17257 any_dependent_template_arguments_p (const_tree args)
17264 if (args == error_mark_node)
17267 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
17269 const_tree level = TMPL_ARGS_LEVEL (args, i + 1);
17270 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
17271 if (dependent_template_arg_p (TREE_VEC_ELT (level, j)))
17278 /* Returns TRUE if the template TMPL is dependent. */
17281 dependent_template_p (tree tmpl)
17283 if (TREE_CODE (tmpl) == OVERLOAD)
17287 if (dependent_template_p (OVL_FUNCTION (tmpl)))
17289 tmpl = OVL_CHAIN (tmpl);
17294 /* Template template parameters are dependent. */
17295 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
17296 || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
17298 /* So are names that have not been looked up. */
17299 if (TREE_CODE (tmpl) == SCOPE_REF
17300 || TREE_CODE (tmpl) == IDENTIFIER_NODE)
17302 /* So are member templates of dependent classes. */
17303 if (TYPE_P (CP_DECL_CONTEXT (tmpl)))
17304 return dependent_type_p (DECL_CONTEXT (tmpl));
17308 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
17311 dependent_template_id_p (tree tmpl, tree args)
17313 return (dependent_template_p (tmpl)
17314 || any_dependent_template_arguments_p (args));
17317 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
17321 dependent_omp_for_p (tree declv, tree initv, tree condv, tree incrv)
17325 if (!processing_template_decl)
17328 for (i = 0; i < TREE_VEC_LENGTH (declv); i++)
17330 tree decl = TREE_VEC_ELT (declv, i);
17331 tree init = TREE_VEC_ELT (initv, i);
17332 tree cond = TREE_VEC_ELT (condv, i);
17333 tree incr = TREE_VEC_ELT (incrv, i);
17335 if (type_dependent_expression_p (decl))
17338 if (init && type_dependent_expression_p (init))
17341 if (type_dependent_expression_p (cond))
17344 if (COMPARISON_CLASS_P (cond)
17345 && (type_dependent_expression_p (TREE_OPERAND (cond, 0))
17346 || type_dependent_expression_p (TREE_OPERAND (cond, 1))))
17349 if (TREE_CODE (incr) == MODOP_EXPR)
17351 if (type_dependent_expression_p (TREE_OPERAND (incr, 0))
17352 || type_dependent_expression_p (TREE_OPERAND (incr, 2)))
17355 else if (type_dependent_expression_p (incr))
17357 else if (TREE_CODE (incr) == MODIFY_EXPR)
17359 if (type_dependent_expression_p (TREE_OPERAND (incr, 0)))
17361 else if (BINARY_CLASS_P (TREE_OPERAND (incr, 1)))
17363 tree t = TREE_OPERAND (incr, 1);
17364 if (type_dependent_expression_p (TREE_OPERAND (t, 0))
17365 || type_dependent_expression_p (TREE_OPERAND (t, 1)))
17374 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
17375 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
17376 no such TYPE can be found. Note that this function peers inside
17377 uninstantiated templates and therefore should be used only in
17378 extremely limited situations. ONLY_CURRENT_P restricts this
17379 peering to the currently open classes hierarchy (which is required
17380 when comparing types). */
17383 resolve_typename_type (tree type, bool only_current_p)
17392 gcc_assert (TREE_CODE (type) == TYPENAME_TYPE);
17394 scope = TYPE_CONTEXT (type);
17395 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
17396 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
17397 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
17398 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
17399 identifier of the TYPENAME_TYPE anymore.
17400 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
17401 TYPENAME_TYPE instead, we avoid messing up with a possible
17402 typedef variant case. */
17403 name = TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
17405 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
17406 it first before we can figure out what NAME refers to. */
17407 if (TREE_CODE (scope) == TYPENAME_TYPE)
17408 scope = resolve_typename_type (scope, only_current_p);
17409 /* If we don't know what SCOPE refers to, then we cannot resolve the
17411 if (TREE_CODE (scope) == TYPENAME_TYPE)
17413 /* If the SCOPE is a template type parameter, we have no way of
17414 resolving the name. */
17415 if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
17417 /* If the SCOPE is not the current instantiation, there's no reason
17418 to look inside it. */
17419 if (only_current_p && !currently_open_class (scope))
17421 /* If SCOPE isn't the template itself, it will not have a valid
17422 TYPE_FIELDS list. */
17423 if (same_type_p (scope, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope)))
17424 /* scope is either the template itself or a compatible instantiation
17425 like X<T>, so look up the name in the original template. */
17426 scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope);
17428 /* scope is a partial instantiation, so we can't do the lookup or we
17429 will lose the template arguments. */
17431 /* Enter the SCOPE so that name lookup will be resolved as if we
17432 were in the class definition. In particular, SCOPE will no
17433 longer be considered a dependent type. */
17434 pushed_scope = push_scope (scope);
17435 /* Look up the declaration. */
17436 decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true);
17438 result = NULL_TREE;
17440 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
17441 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
17444 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE
17445 && TREE_CODE (decl) == TYPE_DECL)
17447 result = TREE_TYPE (decl);
17448 if (result == error_mark_node)
17449 result = NULL_TREE;
17451 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR
17452 && DECL_CLASS_TEMPLATE_P (decl))
17456 /* Obtain the template and the arguments. */
17457 tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0);
17458 args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1);
17459 /* Instantiate the template. */
17460 result = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE,
17461 /*entering_scope=*/0,
17462 tf_error | tf_user);
17463 if (result == error_mark_node)
17464 result = NULL_TREE;
17467 /* Leave the SCOPE. */
17469 pop_scope (pushed_scope);
17471 /* If we failed to resolve it, return the original typename. */
17475 /* If lookup found a typename type, resolve that too. */
17476 if (TREE_CODE (result) == TYPENAME_TYPE && !TYPENAME_IS_RESOLVING_P (result))
17478 /* Ill-formed programs can cause infinite recursion here, so we
17479 must catch that. */
17480 TYPENAME_IS_RESOLVING_P (type) = 1;
17481 result = resolve_typename_type (result, only_current_p);
17482 TYPENAME_IS_RESOLVING_P (type) = 0;
17485 /* Qualify the resulting type. */
17486 quals = cp_type_quals (type);
17488 result = cp_build_qualified_type (result, cp_type_quals (result) | quals);
17493 /* EXPR is an expression which is not type-dependent. Return a proxy
17494 for EXPR that can be used to compute the types of larger
17495 expressions containing EXPR. */
17498 build_non_dependent_expr (tree expr)
17502 /* Preserve null pointer constants so that the type of things like
17503 "p == 0" where "p" is a pointer can be determined. */
17504 if (null_ptr_cst_p (expr))
17506 /* Preserve OVERLOADs; the functions must be available to resolve
17509 if (TREE_CODE (inner_expr) == STMT_EXPR)
17510 inner_expr = stmt_expr_value_expr (inner_expr);
17511 if (TREE_CODE (inner_expr) == ADDR_EXPR)
17512 inner_expr = TREE_OPERAND (inner_expr, 0);
17513 if (TREE_CODE (inner_expr) == COMPONENT_REF)
17514 inner_expr = TREE_OPERAND (inner_expr, 1);
17515 if (is_overloaded_fn (inner_expr)
17516 || TREE_CODE (inner_expr) == OFFSET_REF)
17518 /* There is no need to return a proxy for a variable. */
17519 if (TREE_CODE (expr) == VAR_DECL)
17521 /* Preserve string constants; conversions from string constants to
17522 "char *" are allowed, even though normally a "const char *"
17523 cannot be used to initialize a "char *". */
17524 if (TREE_CODE (expr) == STRING_CST)
17526 /* Preserve arithmetic constants, as an optimization -- there is no
17527 reason to create a new node. */
17528 if (TREE_CODE (expr) == INTEGER_CST || TREE_CODE (expr) == REAL_CST)
17530 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
17531 There is at least one place where we want to know that a
17532 particular expression is a throw-expression: when checking a ?:
17533 expression, there are special rules if the second or third
17534 argument is a throw-expression. */
17535 if (TREE_CODE (expr) == THROW_EXPR)
17538 if (TREE_CODE (expr) == COND_EXPR)
17539 return build3 (COND_EXPR,
17541 TREE_OPERAND (expr, 0),
17542 (TREE_OPERAND (expr, 1)
17543 ? build_non_dependent_expr (TREE_OPERAND (expr, 1))
17544 : build_non_dependent_expr (TREE_OPERAND (expr, 0))),
17545 build_non_dependent_expr (TREE_OPERAND (expr, 2)));
17546 if (TREE_CODE (expr) == COMPOUND_EXPR
17547 && !COMPOUND_EXPR_OVERLOADED (expr))
17548 return build2 (COMPOUND_EXPR,
17550 TREE_OPERAND (expr, 0),
17551 build_non_dependent_expr (TREE_OPERAND (expr, 1)));
17553 /* If the type is unknown, it can't really be non-dependent */
17554 gcc_assert (TREE_TYPE (expr) != unknown_type_node);
17556 /* Otherwise, build a NON_DEPENDENT_EXPR.
17558 REFERENCE_TYPEs are not stripped for expressions in templates
17559 because doing so would play havoc with mangling. Consider, for
17562 template <typename T> void f<T& g>() { g(); }
17564 In the body of "f", the expression for "g" will have
17565 REFERENCE_TYPE, even though the standard says that it should
17566 not. The reason is that we must preserve the syntactic form of
17567 the expression so that mangling (say) "f<g>" inside the body of
17568 "f" works out correctly. Therefore, the REFERENCE_TYPE is
17570 return build1 (NON_DEPENDENT_EXPR, non_reference (TREE_TYPE (expr)), expr);
17573 /* ARGS is a vector of expressions as arguments to a function call.
17574 Replace the arguments with equivalent non-dependent expressions.
17575 This modifies ARGS in place. */
17578 make_args_non_dependent (VEC(tree,gc) *args)
17583 for (ix = 0; VEC_iterate (tree, args, ix, arg); ++ix)
17585 tree newarg = build_non_dependent_expr (arg);
17587 VEC_replace (tree, args, ix, newarg);
17591 /* Returns a type which represents 'auto'. We use a TEMPLATE_TYPE_PARM
17592 with a level one deeper than the actual template parms. */
17599 /* ??? Is it worth caching this for multiple autos at the same level? */
17600 au = cxx_make_type (TEMPLATE_TYPE_PARM);
17601 TYPE_NAME (au) = build_decl (BUILTINS_LOCATION,
17602 TYPE_DECL, get_identifier ("auto"), au);
17603 TYPE_STUB_DECL (au) = TYPE_NAME (au);
17604 TEMPLATE_TYPE_PARM_INDEX (au) = build_template_parm_index
17605 (0, processing_template_decl + 1, processing_template_decl + 1,
17606 TYPE_NAME (au), NULL_TREE);
17607 TYPE_CANONICAL (au) = canonical_type_parameter (au);
17608 DECL_ARTIFICIAL (TYPE_NAME (au)) = 1;
17609 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au));
17614 /* Given type ARG, return std::initializer_list<ARG>. */
17619 tree std_init_list = namespace_binding
17620 (get_identifier ("initializer_list"), std_node);
17622 if (!std_init_list || !DECL_CLASS_TEMPLATE_P (std_init_list))
17624 error ("deducing from brace-enclosed initializer list requires "
17625 "#include <initializer_list>");
17626 return error_mark_node;
17628 argvec = make_tree_vec (1);
17629 TREE_VEC_ELT (argvec, 0) = arg;
17630 return lookup_template_class (std_init_list, argvec, NULL_TREE,
17631 NULL_TREE, 0, tf_warning_or_error);
17634 /* Replace auto in TYPE with std::initializer_list<auto>. */
17637 listify_autos (tree type, tree auto_node)
17639 tree init_auto = listify (auto_node);
17640 tree argvec = make_tree_vec (1);
17641 TREE_VEC_ELT (argvec, 0) = init_auto;
17642 if (processing_template_decl)
17643 argvec = add_to_template_args (current_template_args (), argvec);
17644 return tsubst (type, argvec, tf_warning_or_error, NULL_TREE);
17647 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
17648 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
17651 do_auto_deduction (tree type, tree init, tree auto_node)
17653 tree parms, tparms, targs;
17657 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
17658 with either a new invented type template parameter U or, if the
17659 initializer is a braced-init-list (8.5.4), with
17660 std::initializer_list<U>. */
17661 if (BRACE_ENCLOSED_INITIALIZER_P (init))
17662 type = listify_autos (type, auto_node);
17664 parms = build_tree_list (NULL_TREE, type);
17666 tparms = make_tree_vec (1);
17667 targs = make_tree_vec (1);
17668 TREE_VEC_ELT (tparms, 0)
17669 = build_tree_list (NULL_TREE, TYPE_NAME (auto_node));
17670 val = type_unification_real (tparms, targs, parms, args, 1, 0,
17671 DEDUCE_CALL, LOOKUP_NORMAL);
17674 error ("unable to deduce %qT from %qE", type, init);
17675 return error_mark_node;
17678 if (processing_template_decl)
17679 targs = add_to_template_args (current_template_args (), targs);
17680 return tsubst (type, targs, tf_warning_or_error, NULL_TREE);
17683 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
17687 splice_late_return_type (tree type, tree late_return_type)
17691 if (late_return_type == NULL_TREE)
17693 argvec = make_tree_vec (1);
17694 TREE_VEC_ELT (argvec, 0) = late_return_type;
17695 if (processing_template_decl)
17696 argvec = add_to_template_args (current_template_args (), argvec);
17697 return tsubst (type, argvec, tf_warning_or_error, NULL_TREE);
17700 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto'. */
17703 is_auto (const_tree type)
17705 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
17706 && TYPE_IDENTIFIER (type) == get_identifier ("auto"))
17712 /* Returns true iff TYPE contains a use of 'auto'. Since auto can only
17713 appear as a type-specifier for the declaration in question, we don't
17714 have to look through the whole type. */
17717 type_uses_auto (tree type)
17719 enum tree_code code;
17720 if (is_auto (type))
17723 code = TREE_CODE (type);
17725 if (code == POINTER_TYPE || code == REFERENCE_TYPE
17726 || code == OFFSET_TYPE || code == FUNCTION_TYPE
17727 || code == METHOD_TYPE || code == ARRAY_TYPE)
17728 return type_uses_auto (TREE_TYPE (type));
17730 if (TYPE_PTRMEMFUNC_P (type))
17731 return type_uses_auto (TREE_TYPE (TREE_TYPE
17732 (TYPE_PTRMEMFUNC_FN_TYPE (type))));
17737 /* For a given template T, return the list of typedefs referenced
17738 in T for which access check is needed at T instantiation time.
17739 T is either a FUNCTION_DECL or a RECORD_TYPE.
17740 Those typedefs were added to T by the function
17741 append_type_to_template_for_access_check. */
17744 get_types_needing_access_check (tree t)
17746 tree ti, result = NULL_TREE;
17748 if (!t || t == error_mark_node)
17751 if (!(ti = get_template_info (t)))
17754 if (CLASS_TYPE_P (t)
17755 || TREE_CODE (t) == FUNCTION_DECL)
17757 if (!TI_TEMPLATE (ti))
17760 result = TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti);
17766 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
17767 tied to T. That list of typedefs will be access checked at
17768 T instantiation time.
17769 T is either a FUNCTION_DECL or a RECORD_TYPE.
17770 TYPE_DECL is a TYPE_DECL node representing a typedef.
17771 SCOPE is the scope through which TYPE_DECL is accessed.
17773 This function is a subroutine of
17774 append_type_to_template_for_access_check. */
17777 append_type_to_template_for_access_check_1 (tree t,
17783 if (!t || t == error_mark_node)
17786 gcc_assert ((TREE_CODE (t) == FUNCTION_DECL
17787 || CLASS_TYPE_P (t))
17789 && TREE_CODE (type_decl) == TYPE_DECL
17792 if (!(ti = get_template_info (t)))
17795 gcc_assert (TI_TEMPLATE (ti));
17797 TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti) =
17798 tree_cons (type_decl, scope, TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti));
17801 /* Append TYPE_DECL to the template TEMPL.
17802 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
17803 At TEMPL instanciation time, TYPE_DECL will be checked to see
17804 if it can be accessed through SCOPE.
17806 e.g. consider the following code snippet:
17813 template<class U> struct S
17820 At S<char> instantiation time, we need to check the access of C::myint
17821 In other words, we need to check the access of the myint typedef through
17822 the C scope. For that purpose, this function will add the myint typedef
17823 and the scope C through which its being accessed to a list of typedefs
17824 tied to the template S. That list will be walked at template instantiation
17825 time and access check performed on each typedefs it contains.
17826 Note that this particular code snippet should yield an error because
17827 myint is private to C. */
17830 append_type_to_template_for_access_check (tree templ,
17836 gcc_assert (type_decl && (TREE_CODE (type_decl) == TYPE_DECL));
17838 /* Make sure we don't append the type to the template twice. */
17839 for (node = get_types_needing_access_check (templ);
17841 node = TREE_CHAIN (node))
17843 tree decl = TREE_PURPOSE (node);
17844 tree type_scope = TREE_VALUE (node);
17846 if (decl == type_decl && type_scope == scope)
17850 append_type_to_template_for_access_check_1 (templ, type_decl, scope);
17853 /* Set up the hash tables for template instantiations. */
17856 init_template_processing (void)
17858 decl_specializations = htab_create_ggc (37,
17859 hash_specialization,
17860 eq_specializations,
17862 type_specializations = htab_create_ggc (37,
17863 hash_specialization,
17864 eq_specializations,
17868 #include "gt-cp-pt.h"