1 /* Handle parameterized types (templates) for GNU -*- C++ -*-.
2 Copyright (C) 1992-2015 Free Software Foundation, Inc.
3 Written by Ken Raeburn (raeburn@cygnus.com) while at Watchmaker Computing.
4 Rewritten by Jason Merrill (jason@cygnus.com).
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* Known bugs or deficiencies include:
24 all methods must be provided in header files; can't use a source
25 file that contains only the method templates and "just win". */
29 #include "coretypes.h"
34 #include "double-int.h"
41 #include "stringpool.h"
44 #include "stor-layout.h"
48 #include "c-family/c-common.h"
49 #include "c-family/c-objc.h"
50 #include "cp-objcp-common.h"
51 #include "tree-inline.h"
55 #include "tree-iterator.h"
56 #include "type-utils.h"
59 /* The type of functions taking a tree, and some additional data, and
61 typedef int (*tree_fn_t) (tree, void*);
63 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
64 instantiations have been deferred, either because their definitions
65 were not yet available, or because we were putting off doing the work. */
66 struct GTY ((chain_next ("%h.next"))) pending_template {
67 struct pending_template *next;
68 struct tinst_level *tinst;
71 static GTY(()) struct pending_template *pending_templates;
72 static GTY(()) struct pending_template *last_pending_template;
74 int processing_template_parmlist;
75 static int template_header_count;
77 static GTY(()) tree saved_trees;
78 static vec<int> inline_parm_levels;
80 static GTY(()) struct tinst_level *current_tinst_level;
82 static GTY(()) tree saved_access_scope;
84 /* Live only within one (recursive) call to tsubst_expr. We use
85 this to pass the statement expression node from the STMT_EXPR
86 to the EXPR_STMT that is its result. */
87 static tree cur_stmt_expr;
89 /* True if we've recursed into fn_type_unification too many times. */
90 static bool excessive_deduction_depth;
92 struct GTY((for_user)) spec_entry
99 struct spec_hasher : ggc_hasher<spec_entry *>
101 static hashval_t hash (spec_entry *);
102 static bool equal (spec_entry *, spec_entry *);
105 static GTY (()) hash_table<spec_hasher> *decl_specializations;
107 static GTY (()) hash_table<spec_hasher> *type_specializations;
109 /* Contains canonical template parameter types. The vector is indexed by
110 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
111 TREE_LIST, whose TREE_VALUEs contain the canonical template
112 parameters of various types and levels. */
113 static GTY(()) vec<tree, va_gc> *canonical_template_parms;
115 #define UNIFY_ALLOW_NONE 0
116 #define UNIFY_ALLOW_MORE_CV_QUAL 1
117 #define UNIFY_ALLOW_LESS_CV_QUAL 2
118 #define UNIFY_ALLOW_DERIVED 4
119 #define UNIFY_ALLOW_INTEGER 8
120 #define UNIFY_ALLOW_OUTER_LEVEL 16
121 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
122 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
124 enum template_base_result {
126 tbr_ambiguous_baseclass,
130 static void push_access_scope (tree);
131 static void pop_access_scope (tree);
132 static bool resolve_overloaded_unification (tree, tree, tree, tree,
133 unification_kind_t, int,
135 static int try_one_overload (tree, tree, tree, tree, tree,
136 unification_kind_t, int, bool, bool);
137 static int unify (tree, tree, tree, tree, int, bool);
138 static void add_pending_template (tree);
139 static tree reopen_tinst_level (struct tinst_level *);
140 static tree tsubst_initializer_list (tree, tree);
141 static tree get_partial_spec_bindings (tree, tree, tree, tree);
142 static tree coerce_template_parms (tree, tree, tree, tsubst_flags_t,
144 static tree coerce_innermost_template_parms (tree, tree, tree, tsubst_flags_t,
146 static void tsubst_enum (tree, tree, tree);
147 static tree add_to_template_args (tree, tree);
148 static tree add_outermost_template_args (tree, tree);
149 static bool check_instantiated_args (tree, tree, tsubst_flags_t);
150 static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*,
152 static int type_unification_real (tree, tree, tree, const tree *,
153 unsigned int, int, unification_kind_t, int,
154 vec<deferred_access_check, va_gc> **,
156 static void note_template_header (int);
157 static tree convert_nontype_argument_function (tree, tree, tsubst_flags_t);
158 static tree convert_nontype_argument (tree, tree, tsubst_flags_t);
159 static tree convert_template_argument (tree, tree, tree,
160 tsubst_flags_t, int, tree);
161 static int for_each_template_parm (tree, tree_fn_t, void*,
162 hash_set<tree> *, bool);
163 static tree expand_template_argument_pack (tree);
164 static tree build_template_parm_index (int, int, int, tree, tree);
165 static bool inline_needs_template_parms (tree, bool);
166 static void push_inline_template_parms_recursive (tree, int);
167 static tree retrieve_local_specialization (tree);
168 static void register_local_specialization (tree, tree);
169 static tree reduce_template_parm_level (tree, tree, int, tree, tsubst_flags_t);
170 static int mark_template_parm (tree, void *);
171 static int template_parm_this_level_p (tree, void *);
172 static tree tsubst_friend_function (tree, tree);
173 static tree tsubst_friend_class (tree, tree);
174 static int can_complete_type_without_circularity (tree);
175 static tree get_bindings (tree, tree, tree, bool);
176 static int template_decl_level (tree);
177 static int check_cv_quals_for_unify (int, tree, tree);
178 static void template_parm_level_and_index (tree, int*, int*);
179 static int unify_pack_expansion (tree, tree, tree,
180 tree, unification_kind_t, bool, bool);
181 static tree copy_template_args (tree);
182 static tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree);
183 static tree tsubst_template_args (tree, tree, tsubst_flags_t, tree);
184 static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
185 static void regenerate_decl_from_template (tree, tree);
186 static tree most_specialized_partial_spec (tree, tsubst_flags_t);
187 static tree tsubst_aggr_type (tree, tree, tsubst_flags_t, tree, int);
188 static tree tsubst_arg_types (tree, tree, tree, tsubst_flags_t, tree);
189 static tree tsubst_function_type (tree, tree, tsubst_flags_t, tree);
190 static bool check_specialization_scope (void);
191 static tree process_partial_specialization (tree);
192 static void set_current_access_from_decl (tree);
193 static enum template_base_result get_template_base (tree, tree, tree, tree,
195 static tree try_class_unification (tree, tree, tree, tree, bool);
196 static int coerce_template_template_parms (tree, tree, tsubst_flags_t,
198 static bool template_template_parm_bindings_ok_p (tree, tree);
199 static int template_args_equal (tree, tree);
200 static void tsubst_default_arguments (tree, tsubst_flags_t);
201 static tree for_each_template_parm_r (tree *, int *, void *);
202 static tree copy_default_args_to_explicit_spec_1 (tree, tree);
203 static void copy_default_args_to_explicit_spec (tree);
204 static int invalid_nontype_parm_type_p (tree, tsubst_flags_t);
205 static bool dependent_template_arg_p (tree);
206 static bool any_template_arguments_need_structural_equality_p (tree);
207 static bool dependent_type_p_r (tree);
208 static tree tsubst_expr (tree, tree, tsubst_flags_t, tree, bool);
209 static tree tsubst_copy (tree, tree, tsubst_flags_t, tree);
210 static tree tsubst_pack_expansion (tree, tree, tsubst_flags_t, tree);
211 static tree tsubst_decl (tree, tree, tsubst_flags_t);
212 static void perform_typedefs_access_check (tree tmpl, tree targs);
213 static void append_type_to_template_for_access_check_1 (tree, tree, tree,
215 static tree listify (tree);
216 static tree listify_autos (tree, tree);
217 static tree template_parm_to_arg (tree t);
218 static tree current_template_args (void);
219 static tree tsubst_template_parm (tree, tree, tsubst_flags_t);
220 static tree instantiate_alias_template (tree, tree, tsubst_flags_t);
221 static bool complex_alias_template_p (const_tree tmpl);
223 /* Make the current scope suitable for access checking when we are
224 processing T. T can be FUNCTION_DECL for instantiated function
225 template, VAR_DECL for static member variable, or TYPE_DECL for
226 alias template (needed by instantiate_decl). */
229 push_access_scope (tree t)
231 gcc_assert (VAR_OR_FUNCTION_DECL_P (t)
232 || TREE_CODE (t) == TYPE_DECL);
234 if (DECL_FRIEND_CONTEXT (t))
235 push_nested_class (DECL_FRIEND_CONTEXT (t));
236 else if (DECL_CLASS_SCOPE_P (t))
237 push_nested_class (DECL_CONTEXT (t));
239 push_to_top_level ();
241 if (TREE_CODE (t) == FUNCTION_DECL)
243 saved_access_scope = tree_cons
244 (NULL_TREE, current_function_decl, saved_access_scope);
245 current_function_decl = t;
249 /* Restore the scope set up by push_access_scope. T is the node we
253 pop_access_scope (tree t)
255 if (TREE_CODE (t) == FUNCTION_DECL)
257 current_function_decl = TREE_VALUE (saved_access_scope);
258 saved_access_scope = TREE_CHAIN (saved_access_scope);
261 if (DECL_FRIEND_CONTEXT (t) || DECL_CLASS_SCOPE_P (t))
264 pop_from_top_level ();
267 /* Do any processing required when DECL (a member template
268 declaration) is finished. Returns the TEMPLATE_DECL corresponding
269 to DECL, unless it is a specialization, in which case the DECL
270 itself is returned. */
273 finish_member_template_decl (tree decl)
275 if (decl == error_mark_node)
276 return error_mark_node;
278 gcc_assert (DECL_P (decl));
280 if (TREE_CODE (decl) == TYPE_DECL)
284 type = TREE_TYPE (decl);
285 if (type == error_mark_node)
286 return error_mark_node;
287 if (MAYBE_CLASS_TYPE_P (type)
288 && CLASSTYPE_TEMPLATE_INFO (type)
289 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
291 tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
292 check_member_template (tmpl);
297 else if (TREE_CODE (decl) == FIELD_DECL)
298 error ("data member %qD cannot be a member template", decl);
299 else if (DECL_TEMPLATE_INFO (decl))
301 if (!DECL_TEMPLATE_SPECIALIZATION (decl))
303 check_member_template (DECL_TI_TEMPLATE (decl));
304 return DECL_TI_TEMPLATE (decl);
310 error ("invalid member template declaration %qD", decl);
312 return error_mark_node;
315 /* Create a template info node. */
318 build_template_info (tree template_decl, tree template_args)
320 tree result = make_node (TEMPLATE_INFO);
321 TI_TEMPLATE (result) = template_decl;
322 TI_ARGS (result) = template_args;
326 /* Return the template info node corresponding to T, whatever T is. */
329 get_template_info (const_tree t)
331 tree tinfo = NULL_TREE;
333 if (!t || t == error_mark_node)
336 if (TREE_CODE (t) == NAMESPACE_DECL)
339 if (DECL_P (t) && DECL_LANG_SPECIFIC (t))
340 tinfo = DECL_TEMPLATE_INFO (t);
342 if (!tinfo && DECL_IMPLICIT_TYPEDEF_P (t))
345 if (OVERLOAD_TYPE_P (t))
346 tinfo = TYPE_TEMPLATE_INFO (t);
347 else if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM)
348 tinfo = TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t);
353 /* Returns the template nesting level of the indicated class TYPE.
363 A<T>::B<U> has depth two, while A<T> has depth one.
364 Both A<T>::B<int> and A<int>::B<U> have depth one, if
365 they are instantiations, not specializations.
367 This function is guaranteed to return 0 if passed NULL_TREE so
368 that, for example, `template_class_depth (current_class_type)' is
372 template_class_depth (tree type)
377 type && TREE_CODE (type) != NAMESPACE_DECL;
378 type = (TREE_CODE (type) == FUNCTION_DECL)
379 ? CP_DECL_CONTEXT (type) : CP_TYPE_CONTEXT (type))
381 tree tinfo = get_template_info (type);
383 if (tinfo && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo))
384 && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo))))
391 /* Subroutine of maybe_begin_member_template_processing.
392 Returns true if processing DECL needs us to push template parms. */
395 inline_needs_template_parms (tree decl, bool nsdmi)
397 if (!decl || (!nsdmi && ! DECL_TEMPLATE_INFO (decl)))
400 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl)))
401 > (processing_template_decl + DECL_TEMPLATE_SPECIALIZATION (decl)));
404 /* Subroutine of maybe_begin_member_template_processing.
405 Push the template parms in PARMS, starting from LEVELS steps into the
406 chain, and ending at the beginning, since template parms are listed
410 push_inline_template_parms_recursive (tree parmlist, int levels)
412 tree parms = TREE_VALUE (parmlist);
416 push_inline_template_parms_recursive (TREE_CHAIN (parmlist), levels - 1);
418 ++processing_template_decl;
419 current_template_parms
420 = tree_cons (size_int (processing_template_decl),
421 parms, current_template_parms);
422 TEMPLATE_PARMS_FOR_INLINE (current_template_parms) = 1;
424 begin_scope (TREE_VEC_LENGTH (parms) ? sk_template_parms : sk_template_spec,
426 for (i = 0; i < TREE_VEC_LENGTH (parms); ++i)
428 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
430 if (error_operand_p (parm))
433 gcc_assert (DECL_P (parm));
435 switch (TREE_CODE (parm))
444 /* Make a CONST_DECL as is done in process_template_parm.
445 It is ugly that we recreate this here; the original
446 version built in process_template_parm is no longer
448 tree decl = build_decl (DECL_SOURCE_LOCATION (parm),
449 CONST_DECL, DECL_NAME (parm),
451 DECL_ARTIFICIAL (decl) = 1;
452 TREE_CONSTANT (decl) = 1;
453 TREE_READONLY (decl) = 1;
454 DECL_INITIAL (decl) = DECL_INITIAL (parm);
455 SET_DECL_TEMPLATE_PARM_P (decl);
466 /* Restore the template parameter context for a member template, a
467 friend template defined in a class definition, or a non-template
468 member of template class. */
471 maybe_begin_member_template_processing (tree decl)
475 bool nsdmi = TREE_CODE (decl) == FIELD_DECL;
479 tree ctx = DECL_CONTEXT (decl);
480 decl = (CLASSTYPE_TEMPLATE_INFO (ctx)
481 /* Disregard full specializations (c++/60999). */
482 && uses_template_parms (ctx)
483 ? CLASSTYPE_TI_TEMPLATE (ctx) : NULL_TREE);
486 if (inline_needs_template_parms (decl, nsdmi))
488 parms = DECL_TEMPLATE_PARMS (most_general_template (decl));
489 levels = TMPL_PARMS_DEPTH (parms) - processing_template_decl;
491 if (DECL_TEMPLATE_SPECIALIZATION (decl))
494 parms = TREE_CHAIN (parms);
497 push_inline_template_parms_recursive (parms, levels);
500 /* Remember how many levels of template parameters we pushed so that
501 we can pop them later. */
502 inline_parm_levels.safe_push (levels);
505 /* Undo the effects of maybe_begin_member_template_processing. */
508 maybe_end_member_template_processing (void)
513 if (inline_parm_levels.length () == 0)
516 last = inline_parm_levels.pop ();
517 for (i = 0; i < last; ++i)
519 --processing_template_decl;
520 current_template_parms = TREE_CHAIN (current_template_parms);
525 /* Return a new template argument vector which contains all of ARGS,
526 but has as its innermost set of arguments the EXTRA_ARGS. */
529 add_to_template_args (tree args, tree extra_args)
536 if (args == NULL_TREE || extra_args == error_mark_node)
539 extra_depth = TMPL_ARGS_DEPTH (extra_args);
540 new_args = make_tree_vec (TMPL_ARGS_DEPTH (args) + extra_depth);
542 for (i = 1; i <= TMPL_ARGS_DEPTH (args); ++i)
543 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (args, i));
545 for (j = 1; j <= extra_depth; ++j, ++i)
546 SET_TMPL_ARGS_LEVEL (new_args, i, TMPL_ARGS_LEVEL (extra_args, j));
551 /* Like add_to_template_args, but only the outermost ARGS are added to
552 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
553 (EXTRA_ARGS) levels are added. This function is used to combine
554 the template arguments from a partial instantiation with the
555 template arguments used to attain the full instantiation from the
556 partial instantiation. */
559 add_outermost_template_args (tree args, tree extra_args)
563 /* If there are more levels of EXTRA_ARGS than there are ARGS,
564 something very fishy is going on. */
565 gcc_assert (TMPL_ARGS_DEPTH (args) >= TMPL_ARGS_DEPTH (extra_args));
567 /* If *all* the new arguments will be the EXTRA_ARGS, just return
569 if (TMPL_ARGS_DEPTH (args) == TMPL_ARGS_DEPTH (extra_args))
572 /* For the moment, we make ARGS look like it contains fewer levels. */
573 TREE_VEC_LENGTH (args) -= TMPL_ARGS_DEPTH (extra_args);
575 new_args = add_to_template_args (args, extra_args);
577 /* Now, we restore ARGS to its full dimensions. */
578 TREE_VEC_LENGTH (args) += TMPL_ARGS_DEPTH (extra_args);
583 /* Return the N levels of innermost template arguments from the ARGS. */
586 get_innermost_template_args (tree args, int n)
594 /* If N is 1, just return the innermost set of template arguments. */
596 return TMPL_ARGS_LEVEL (args, TMPL_ARGS_DEPTH (args));
598 /* If we're not removing anything, just return the arguments we were
600 extra_levels = TMPL_ARGS_DEPTH (args) - n;
601 gcc_assert (extra_levels >= 0);
602 if (extra_levels == 0)
605 /* Make a new set of arguments, not containing the outer arguments. */
606 new_args = make_tree_vec (n);
607 for (i = 1; i <= n; ++i)
608 SET_TMPL_ARGS_LEVEL (new_args, i,
609 TMPL_ARGS_LEVEL (args, i + extra_levels));
614 /* The inverse of get_innermost_template_args: Return all but the innermost
615 EXTRA_LEVELS levels of template arguments from the ARGS. */
618 strip_innermost_template_args (tree args, int extra_levels)
621 int n = TMPL_ARGS_DEPTH (args) - extra_levels;
626 /* If N is 1, just return the outermost set of template arguments. */
628 return TMPL_ARGS_LEVEL (args, 1);
630 /* If we're not removing anything, just return the arguments we were
632 gcc_assert (extra_levels >= 0);
633 if (extra_levels == 0)
636 /* Make a new set of arguments, not containing the inner arguments. */
637 new_args = make_tree_vec (n);
638 for (i = 1; i <= n; ++i)
639 SET_TMPL_ARGS_LEVEL (new_args, i,
640 TMPL_ARGS_LEVEL (args, i));
645 /* We've got a template header coming up; push to a new level for storing
649 begin_template_parm_list (void)
651 /* We use a non-tag-transparent scope here, which causes pushtag to
652 put tags in this scope, rather than in the enclosing class or
653 namespace scope. This is the right thing, since we want
654 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
655 global template class, push_template_decl handles putting the
656 TEMPLATE_DECL into top-level scope. For a nested template class,
659 template <class T> struct S1 {
660 template <class T> struct S2 {};
663 pushtag contains special code to call pushdecl_with_scope on the
664 TEMPLATE_DECL for S2. */
665 begin_scope (sk_template_parms, NULL);
666 ++processing_template_decl;
667 ++processing_template_parmlist;
668 note_template_header (0);
671 /* This routine is called when a specialization is declared. If it is
672 invalid to declare a specialization here, an error is reported and
673 false is returned, otherwise this routine will return true. */
676 check_specialization_scope (void)
678 tree scope = current_scope ();
682 An explicit specialization shall be declared in the namespace of
683 which the template is a member, or, for member templates, in the
684 namespace of which the enclosing class or enclosing class
685 template is a member. An explicit specialization of a member
686 function, member class or static data member of a class template
687 shall be declared in the namespace of which the class template
689 if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
691 error ("explicit specialization in non-namespace scope %qD", scope);
697 In an explicit specialization declaration for a member of a class
698 template or a member template that appears in namespace scope,
699 the member template and some of its enclosing class templates may
700 remain unspecialized, except that the declaration shall not
701 explicitly specialize a class member template if its enclosing
702 class templates are not explicitly specialized as well. */
703 if (current_template_parms)
705 error ("enclosing class templates are not explicitly specialized");
712 /* We've just seen template <>. */
715 begin_specialization (void)
717 begin_scope (sk_template_spec, NULL);
718 note_template_header (1);
719 return check_specialization_scope ();
722 /* Called at then end of processing a declaration preceded by
726 end_specialization (void)
729 reset_specialization ();
732 /* Any template <>'s that we have seen thus far are not referring to a
733 function specialization. */
736 reset_specialization (void)
738 processing_specialization = 0;
739 template_header_count = 0;
742 /* We've just seen a template header. If SPECIALIZATION is nonzero,
743 it was of the form template <>. */
746 note_template_header (int specialization)
748 processing_specialization = specialization;
749 template_header_count++;
752 /* We're beginning an explicit instantiation. */
755 begin_explicit_instantiation (void)
757 gcc_assert (!processing_explicit_instantiation);
758 processing_explicit_instantiation = true;
763 end_explicit_instantiation (void)
765 gcc_assert (processing_explicit_instantiation);
766 processing_explicit_instantiation = false;
769 /* An explicit specialization or partial specialization of TMPL is being
770 declared. Check that the namespace in which the specialization is
771 occurring is permissible. Returns false iff it is invalid to
772 specialize TMPL in the current namespace. */
775 check_specialization_namespace (tree tmpl)
777 tree tpl_ns = decl_namespace_context (tmpl);
781 An explicit specialization shall be declared in the namespace of
782 which the template is a member, or, for member templates, in the
783 namespace of which the enclosing class or enclosing class
784 template is a member. An explicit specialization of a member
785 function, member class or static data member of a class template
786 shall be declared in the namespace of which the class template is
788 if (current_scope() != DECL_CONTEXT (tmpl)
789 && !at_namespace_scope_p ())
791 error ("specialization of %qD must appear at namespace scope", tmpl);
794 if (is_associated_namespace (current_namespace, tpl_ns))
795 /* Same or super-using namespace. */
799 permerror (input_location, "specialization of %qD in different namespace", tmpl);
800 permerror (input_location, " from definition of %q+#D", tmpl);
805 /* SPEC is an explicit instantiation. Check that it is valid to
806 perform this explicit instantiation in the current namespace. */
809 check_explicit_instantiation_namespace (tree spec)
813 /* DR 275: An explicit instantiation shall appear in an enclosing
814 namespace of its template. */
815 ns = decl_namespace_context (spec);
816 if (!is_ancestor (current_namespace, ns))
817 permerror (input_location, "explicit instantiation of %qD in namespace %qD "
818 "(which does not enclose namespace %qD)",
819 spec, current_namespace, ns);
822 /* The TYPE is being declared. If it is a template type, that means it
823 is a partial specialization. Do appropriate error-checking. */
826 maybe_process_partial_specialization (tree type)
830 if (type == error_mark_node)
831 return error_mark_node;
833 /* A lambda that appears in specialization context is not itself a
835 if (CLASS_TYPE_P (type) && CLASSTYPE_LAMBDA_EXPR (type))
838 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
840 error ("name of class shadows template template parameter %qD",
842 return error_mark_node;
845 context = TYPE_CONTEXT (type);
847 if (TYPE_ALIAS_P (type))
849 if (TYPE_TEMPLATE_INFO (type)
850 && DECL_ALIAS_TEMPLATE_P (TYPE_TI_TEMPLATE (type)))
851 error ("specialization of alias template %qD",
852 TYPE_TI_TEMPLATE (type));
854 error ("explicit specialization of non-template %qT", type);
855 return error_mark_node;
857 else if (CLASS_TYPE_P (type) && CLASSTYPE_USE_TEMPLATE (type))
859 /* This is for ordinary explicit specialization and partial
860 specialization of a template class such as:
862 template <> class C<int>;
866 template <class T> class C<T*>;
868 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
870 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
871 && !COMPLETE_TYPE_P (type))
873 if (!check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (type))
874 && !at_namespace_scope_p ())
875 return error_mark_node;
876 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
877 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)) = input_location;
878 if (processing_template_decl)
880 if (push_template_decl (TYPE_MAIN_DECL (type))
882 return error_mark_node;
885 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
886 error ("specialization of %qT after instantiation", type);
887 else if (errorcount && !processing_specialization
888 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type)
889 && !uses_template_parms (CLASSTYPE_TI_ARGS (type)))
890 /* Trying to define a specialization either without a template<> header
891 or in an inappropriate place. We've already given an error, so just
892 bail now so we don't actually define the specialization. */
893 return error_mark_node;
895 else if (CLASS_TYPE_P (type)
896 && !CLASSTYPE_USE_TEMPLATE (type)
897 && CLASSTYPE_TEMPLATE_INFO (type)
898 && context && CLASS_TYPE_P (context)
899 && CLASSTYPE_TEMPLATE_INFO (context))
901 /* This is for an explicit specialization of member class
902 template according to [temp.expl.spec/18]:
904 template <> template <class U> class C<int>::D;
906 The context `C<int>' must be an implicit instantiation.
907 Otherwise this is just a member class template declared
910 template <> class C<int> { template <class U> class D; };
911 template <> template <class U> class C<int>::D;
913 In the first case, `C<int>::D' is a specialization of `C<T>::D'
914 while in the second case, `C<int>::D' is a primary template
915 and `C<T>::D' may not exist. */
917 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context)
918 && !COMPLETE_TYPE_P (type))
921 tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
923 if (current_namespace
924 != decl_namespace_context (tmpl))
926 permerror (input_location, "specializing %q#T in different namespace", type);
927 permerror (input_location, " from definition of %q+#D", tmpl);
930 /* Check for invalid specialization after instantiation:
932 template <> template <> class C<int>::D<int>;
933 template <> template <class U> class C<int>::D; */
935 for (t = DECL_TEMPLATE_INSTANTIATIONS (tmpl);
936 t; t = TREE_CHAIN (t))
938 tree inst = TREE_VALUE (t);
939 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst)
940 || !COMPLETE_OR_OPEN_TYPE_P (inst))
942 /* We already have a full specialization of this partial
943 instantiation, or a full specialization has been
944 looked up but not instantiated. Reassign it to the
945 new member specialization template. */
949 elt.tmpl = most_general_template (tmpl);
950 elt.args = CLASSTYPE_TI_ARGS (inst);
953 type_specializations->remove_elt (&elt);
956 elt.args = INNERMOST_TEMPLATE_ARGS (elt.args);
959 = type_specializations->find_slot (&elt, INSERT);
960 entry = ggc_alloc<spec_entry> ();
965 /* But if we've had an implicit instantiation, that's a
966 problem ([temp.expl.spec]/6). */
967 error ("specialization %qT after instantiation %qT",
971 /* Mark TYPE as a specialization. And as a result, we only
972 have one level of template argument for the innermost
974 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type);
975 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)) = input_location;
976 CLASSTYPE_TI_ARGS (type)
977 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
980 else if (processing_specialization)
982 /* Someday C++0x may allow for enum template specialization. */
983 if (cxx_dialect > cxx98 && TREE_CODE (type) == ENUMERAL_TYPE
984 && CLASS_TYPE_P (context) && CLASSTYPE_USE_TEMPLATE (context))
985 pedwarn (input_location, OPT_Wpedantic, "template specialization "
986 "of %qD not allowed by ISO C++", type);
989 error ("explicit specialization of non-template %qT", type);
990 return error_mark_node;
997 /* Returns nonzero if we can optimize the retrieval of specializations
998 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
999 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
1002 optimize_specialization_lookup_p (tree tmpl)
1004 return (DECL_FUNCTION_TEMPLATE_P (tmpl)
1005 && DECL_CLASS_SCOPE_P (tmpl)
1006 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
1008 && CLASS_TYPE_P (DECL_CONTEXT (tmpl))
1009 /* The optimized lookup depends on the fact that the
1010 template arguments for the member function template apply
1011 purely to the containing class, which is not true if the
1012 containing class is an explicit or partial
1014 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl))
1015 && !DECL_MEMBER_TEMPLATE_P (tmpl)
1016 && !DECL_CONV_FN_P (tmpl)
1017 /* It is possible to have a template that is not a member
1018 template and is not a member of a template class:
1020 template <typename T>
1021 struct S { friend A::f(); };
1023 Here, the friend function is a template, but the context does
1024 not have template information. The optimized lookup relies
1025 on having ARGS be the template arguments for both the class
1026 and the function template. */
1027 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl)));
1030 /* Retrieve the specialization (in the sense of [temp.spec] - a
1031 specialization is either an instantiation or an explicit
1032 specialization) of TMPL for the given template ARGS. If there is
1033 no such specialization, return NULL_TREE. The ARGS are a vector of
1034 arguments, or a vector of vectors of arguments, in the case of
1035 templates with more than one level of parameters.
1037 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1038 then we search for a partial specialization matching ARGS. This
1039 parameter is ignored if TMPL is not a class template.
1041 We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1042 result is a NONTYPE_ARGUMENT_PACK. */
1045 retrieve_specialization (tree tmpl, tree args, hashval_t hash)
1047 if (tmpl == NULL_TREE)
1050 if (args == error_mark_node)
1053 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL
1054 || TREE_CODE (tmpl) == FIELD_DECL);
1056 /* There should be as many levels of arguments as there are
1057 levels of parameters. */
1058 gcc_assert (TMPL_ARGS_DEPTH (args)
1059 == (TREE_CODE (tmpl) == TEMPLATE_DECL
1060 ? TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl))
1061 : template_class_depth (DECL_CONTEXT (tmpl))));
1063 if (optimize_specialization_lookup_p (tmpl))
1065 tree class_template;
1066 tree class_specialization;
1067 vec<tree, va_gc> *methods;
1071 /* The template arguments actually apply to the containing
1072 class. Find the class specialization with those
1074 class_template = CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl));
1075 class_specialization
1076 = retrieve_specialization (class_template, args, 0);
1077 if (!class_specialization)
1079 /* Now, find the appropriate entry in the CLASSTYPE_METHOD_VEC
1080 for the specialization. */
1081 idx = class_method_index_for_fn (class_specialization, tmpl);
1084 /* Iterate through the methods with the indicated name, looking
1085 for the one that has an instance of TMPL. */
1086 methods = CLASSTYPE_METHOD_VEC (class_specialization);
1087 for (fns = (*methods)[idx]; fns; fns = OVL_NEXT (fns))
1089 tree fn = OVL_CURRENT (fns);
1090 if (DECL_TEMPLATE_INFO (fn) && DECL_TI_TEMPLATE (fn) == tmpl
1091 /* using-declarations can add base methods to the method vec,
1092 and we don't want those here. */
1093 && DECL_CONTEXT (fn) == class_specialization)
1102 hash_table<spec_hasher> *specializations;
1106 elt.spec = NULL_TREE;
1108 if (DECL_CLASS_TEMPLATE_P (tmpl))
1109 specializations = type_specializations;
1111 specializations = decl_specializations;
1114 hash = spec_hasher::hash (&elt);
1115 found = specializations->find_with_hash (&elt, hash);
1123 /* Like retrieve_specialization, but for local declarations. */
1126 retrieve_local_specialization (tree tmpl)
1128 if (local_specializations == NULL)
1131 tree *slot = local_specializations->get (tmpl);
1132 return slot ? *slot : NULL_TREE;
1135 /* Returns nonzero iff DECL is a specialization of TMPL. */
1138 is_specialization_of (tree decl, tree tmpl)
1142 if (TREE_CODE (decl) == FUNCTION_DECL)
1146 t = DECL_TEMPLATE_INFO (t) ? DECL_TI_TEMPLATE (t) : NULL_TREE)
1152 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
1154 for (t = TREE_TYPE (decl);
1156 t = CLASSTYPE_USE_TEMPLATE (t)
1157 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t)) : NULL_TREE)
1158 if (same_type_ignoring_top_level_qualifiers_p (t, TREE_TYPE (tmpl)))
1165 /* Returns nonzero iff DECL is a specialization of friend declaration
1166 FRIEND_DECL according to [temp.friend]. */
1169 is_specialization_of_friend (tree decl, tree friend_decl)
1171 bool need_template = true;
1174 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
1175 || TREE_CODE (decl) == TYPE_DECL);
1177 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1178 of a template class, we want to check if DECL is a specialization
1180 if (TREE_CODE (friend_decl) == FUNCTION_DECL
1181 && DECL_TEMPLATE_INFO (friend_decl)
1182 && !DECL_USE_TEMPLATE (friend_decl))
1184 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1185 friend_decl = DECL_TI_TEMPLATE (friend_decl);
1186 need_template = false;
1188 else if (TREE_CODE (friend_decl) == TEMPLATE_DECL
1189 && !PRIMARY_TEMPLATE_P (friend_decl))
1190 need_template = false;
1192 /* There is nothing to do if this is not a template friend. */
1193 if (TREE_CODE (friend_decl) != TEMPLATE_DECL)
1196 if (is_specialization_of (decl, friend_decl))
1200 A member of a class template may be declared to be a friend of a
1201 non-template class. In this case, the corresponding member of
1202 every specialization of the class template is a friend of the
1203 class granting friendship.
1205 For example, given a template friend declaration
1207 template <class T> friend void A<T>::f();
1209 the member function below is considered a friend
1211 template <> struct A<int> {
1215 For this type of template friend, TEMPLATE_DEPTH below will be
1216 nonzero. To determine if DECL is a friend of FRIEND, we first
1217 check if the enclosing class is a specialization of another. */
1219 template_depth = template_class_depth (CP_DECL_CONTEXT (friend_decl));
1221 && DECL_CLASS_SCOPE_P (decl)
1222 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)),
1223 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl))))
1225 /* Next, we check the members themselves. In order to handle
1226 a few tricky cases, such as when FRIEND_DECL's are
1228 template <class T> friend void A<T>::g(T t);
1229 template <class T> template <T t> friend void A<T>::h();
1233 void A<int>::g(int);
1234 template <int> void A<int>::h();
1236 we need to figure out ARGS, the template arguments from
1237 the context of DECL. This is required for template substitution
1238 of `T' in the function parameter of `g' and template parameter
1239 of `h' in the above examples. Here ARGS corresponds to `int'. */
1241 tree context = DECL_CONTEXT (decl);
1242 tree args = NULL_TREE;
1243 int current_depth = 0;
1245 while (current_depth < template_depth)
1247 if (CLASSTYPE_TEMPLATE_INFO (context))
1249 if (current_depth == 0)
1250 args = TYPE_TI_ARGS (context);
1252 args = add_to_template_args (TYPE_TI_ARGS (context), args);
1255 context = TYPE_CONTEXT (context);
1258 if (TREE_CODE (decl) == FUNCTION_DECL)
1263 tree friend_args_type;
1264 tree decl_args_type;
1266 /* Make sure that both DECL and FRIEND_DECL are templates or
1268 is_template = DECL_TEMPLATE_INFO (decl)
1269 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl));
1270 if (need_template ^ is_template)
1272 else if (is_template)
1274 /* If both are templates, check template parameter list. */
1276 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl),
1278 if (!comp_template_parms
1279 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)),
1283 decl_type = TREE_TYPE (DECL_TI_TEMPLATE (decl));
1286 decl_type = TREE_TYPE (decl);
1288 friend_type = tsubst_function_type (TREE_TYPE (friend_decl), args,
1289 tf_none, NULL_TREE);
1290 if (friend_type == error_mark_node)
1293 /* Check if return types match. */
1294 if (!same_type_p (TREE_TYPE (decl_type), TREE_TYPE (friend_type)))
1297 /* Check if function parameter types match, ignoring the
1298 `this' parameter. */
1299 friend_args_type = TYPE_ARG_TYPES (friend_type);
1300 decl_args_type = TYPE_ARG_TYPES (decl_type);
1301 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl))
1302 friend_args_type = TREE_CHAIN (friend_args_type);
1303 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
1304 decl_args_type = TREE_CHAIN (decl_args_type);
1306 return compparms (decl_args_type, friend_args_type);
1310 /* DECL is a TYPE_DECL */
1312 tree decl_type = TREE_TYPE (decl);
1314 /* Make sure that both DECL and FRIEND_DECL are templates or
1317 = CLASSTYPE_TEMPLATE_INFO (decl_type)
1318 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type));
1320 if (need_template ^ is_template)
1322 else if (is_template)
1325 /* If both are templates, check the name of the two
1326 TEMPLATE_DECL's first because is_friend didn't. */
1327 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type))
1328 != DECL_NAME (friend_decl))
1331 /* Now check template parameter list. */
1333 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl),
1335 return comp_template_parms
1336 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type)),
1340 return (DECL_NAME (decl)
1341 == DECL_NAME (friend_decl));
1347 /* Register the specialization SPEC as a specialization of TMPL with
1348 the indicated ARGS. IS_FRIEND indicates whether the specialization
1349 is actually just a friend declaration. Returns SPEC, or an
1350 equivalent prior declaration, if available.
1352 We also store instantiations of field packs in the hash table, even
1353 though they are not themselves templates, to make lookup easier. */
1356 register_specialization (tree spec, tree tmpl, tree args, bool is_friend,
1360 spec_entry **slot = NULL;
1363 gcc_assert ((TREE_CODE (tmpl) == TEMPLATE_DECL && DECL_P (spec))
1364 || (TREE_CODE (tmpl) == FIELD_DECL
1365 && TREE_CODE (spec) == NONTYPE_ARGUMENT_PACK));
1367 if (TREE_CODE (spec) == FUNCTION_DECL
1368 && uses_template_parms (DECL_TI_ARGS (spec)))
1369 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1370 register it; we want the corresponding TEMPLATE_DECL instead.
1371 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1372 the more obvious `uses_template_parms (spec)' to avoid problems
1373 with default function arguments. In particular, given
1374 something like this:
1376 template <class T> void f(T t1, T t = T())
1378 the default argument expression is not substituted for in an
1379 instantiation unless and until it is actually needed. */
1382 if (optimize_specialization_lookup_p (tmpl))
1383 /* We don't put these specializations in the hash table, but we might
1384 want to give an error about a mismatch. */
1385 fn = retrieve_specialization (tmpl, args, 0);
1393 hash = spec_hasher::hash (&elt);
1396 decl_specializations->find_slot_with_hash (&elt, hash, INSERT);
1398 fn = ((spec_entry *) *slot)->spec;
1403 /* We can sometimes try to re-register a specialization that we've
1404 already got. In particular, regenerate_decl_from_template calls
1405 duplicate_decls which will update the specialization list. But,
1406 we'll still get called again here anyhow. It's more convenient
1407 to simply allow this than to try to prevent it. */
1410 else if (fn && DECL_TEMPLATE_SPECIALIZATION (spec))
1412 if (DECL_TEMPLATE_INSTANTIATION (fn))
1414 if (DECL_ODR_USED (fn)
1415 || DECL_EXPLICIT_INSTANTIATION (fn))
1417 error ("specialization of %qD after instantiation",
1419 return error_mark_node;
1424 /* This situation should occur only if the first
1425 specialization is an implicit instantiation, the
1426 second is an explicit specialization, and the
1427 implicit instantiation has not yet been used. That
1428 situation can occur if we have implicitly
1429 instantiated a member function and then specialized
1432 We can also wind up here if a friend declaration that
1433 looked like an instantiation turns out to be a
1436 template <class T> void foo(T);
1437 class S { friend void foo<>(int) };
1438 template <> void foo(int);
1440 We transform the existing DECL in place so that any
1441 pointers to it become pointers to the updated
1444 If there was a definition for the template, but not
1445 for the specialization, we want this to look as if
1446 there were no definition, and vice versa. */
1447 DECL_INITIAL (fn) = NULL_TREE;
1448 duplicate_decls (spec, fn, is_friend);
1449 /* The call to duplicate_decls will have applied
1452 An explicit specialization of a function template
1453 is inline only if it is explicitly declared to be,
1454 and independently of whether its function template
1457 to the primary function; now copy the inline bits to
1458 the various clones. */
1459 FOR_EACH_CLONE (clone, fn)
1461 DECL_DECLARED_INLINE_P (clone)
1462 = DECL_DECLARED_INLINE_P (fn);
1463 DECL_SOURCE_LOCATION (clone)
1464 = DECL_SOURCE_LOCATION (fn);
1465 DECL_DELETED_FN (clone)
1466 = DECL_DELETED_FN (fn);
1468 check_specialization_namespace (tmpl);
1473 else if (DECL_TEMPLATE_SPECIALIZATION (fn))
1475 if (!duplicate_decls (spec, fn, is_friend) && DECL_INITIAL (spec))
1476 /* Dup decl failed, but this is a new definition. Set the
1477 line number so any errors match this new
1479 DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (spec);
1485 return duplicate_decls (spec, fn, is_friend);
1487 /* A specialization must be declared in the same namespace as the
1488 template it is specializing. */
1489 if (DECL_P (spec) && DECL_TEMPLATE_SPECIALIZATION (spec)
1490 && !check_specialization_namespace (tmpl))
1491 DECL_CONTEXT (spec) = DECL_CONTEXT (tmpl);
1493 if (slot != NULL /* !optimize_specialization_lookup_p (tmpl) */)
1495 spec_entry *entry = ggc_alloc<spec_entry> ();
1496 gcc_assert (tmpl && args && spec);
1499 if ((TREE_CODE (spec) == FUNCTION_DECL && DECL_NAMESPACE_SCOPE_P (spec)
1500 && PRIMARY_TEMPLATE_P (tmpl)
1501 && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl)) == NULL_TREE)
1502 || variable_template_p (tmpl))
1503 /* If TMPL is a forward declaration of a template function, keep a list
1504 of all specializations in case we need to reassign them to a friend
1505 template later in tsubst_friend_function.
1507 Also keep a list of all variable template instantiations so that
1508 process_partial_specialization can check whether a later partial
1509 specialization would have used it. */
1510 DECL_TEMPLATE_INSTANTIATIONS (tmpl)
1511 = tree_cons (args, spec, DECL_TEMPLATE_INSTANTIATIONS (tmpl));
1517 /* Returns true iff two spec_entry nodes are equivalent. Only compares the
1518 TMPL and ARGS members, ignores SPEC. */
1520 int comparing_specializations;
1523 spec_hasher::equal (spec_entry *e1, spec_entry *e2)
1527 ++comparing_specializations;
1528 equal = (e1->tmpl == e2->tmpl
1529 && comp_template_args (e1->args, e2->args));
1530 --comparing_specializations;
1535 /* Returns a hash for a template TMPL and template arguments ARGS. */
1538 hash_tmpl_and_args (tree tmpl, tree args)
1540 hashval_t val = DECL_UID (tmpl);
1541 return iterative_hash_template_arg (args, val);
1544 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1548 spec_hasher::hash (spec_entry *e)
1550 return hash_tmpl_and_args (e->tmpl, e->args);
1553 /* Recursively calculate a hash value for a template argument ARG, for use
1554 in the hash tables of template specializations. */
1557 iterative_hash_template_arg (tree arg, hashval_t val)
1559 unsigned HOST_WIDE_INT i;
1560 enum tree_code code;
1563 if (arg == NULL_TREE)
1564 return iterative_hash_object (arg, val);
1569 if (TREE_CODE (arg) == ARGUMENT_PACK_SELECT)
1570 /* We can get one of these when re-hashing a previous entry in the middle
1571 of substituting into a pack expansion. Just look through it. */
1572 arg = ARGUMENT_PACK_SELECT_FROM_PACK (arg);
1574 code = TREE_CODE (arg);
1575 tclass = TREE_CODE_CLASS (code);
1577 val = iterative_hash_object (code, val);
1584 case IDENTIFIER_NODE:
1585 return iterative_hash_object (IDENTIFIER_HASH_VALUE (arg), val);
1589 int i, len = TREE_VEC_LENGTH (arg);
1590 for (i = 0; i < len; ++i)
1591 val = iterative_hash_template_arg (TREE_VEC_ELT (arg, i), val);
1595 case TYPE_PACK_EXPANSION:
1596 case EXPR_PACK_EXPANSION:
1597 val = iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg), val);
1598 return iterative_hash_template_arg (PACK_EXPANSION_EXTRA_ARGS (arg), val);
1600 case TYPE_ARGUMENT_PACK:
1601 case NONTYPE_ARGUMENT_PACK:
1602 return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg), val);
1605 for (; arg; arg = TREE_CHAIN (arg))
1606 val = iterative_hash_template_arg (TREE_VALUE (arg), val);
1610 for (; arg; arg = OVL_NEXT (arg))
1611 val = iterative_hash_template_arg (OVL_CURRENT (arg), val);
1617 iterative_hash_template_arg (TREE_TYPE (arg), val);
1618 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg), i, field, value)
1620 val = iterative_hash_template_arg (field, val);
1621 val = iterative_hash_template_arg (value, val);
1627 if (!DECL_ARTIFICIAL (arg))
1629 val = iterative_hash_object (DECL_PARM_INDEX (arg), val);
1630 val = iterative_hash_object (DECL_PARM_LEVEL (arg), val);
1632 return iterative_hash_template_arg (TREE_TYPE (arg), val);
1635 return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg), val);
1638 val = iterative_hash_template_arg (PTRMEM_CST_CLASS (arg), val);
1639 return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg), val);
1641 case TEMPLATE_PARM_INDEX:
1642 val = iterative_hash_template_arg
1643 (TREE_TYPE (TEMPLATE_PARM_DECL (arg)), val);
1644 val = iterative_hash_object (TEMPLATE_PARM_LEVEL (arg), val);
1645 return iterative_hash_object (TEMPLATE_PARM_IDX (arg), val);
1648 val = iterative_hash_object (TRAIT_EXPR_KIND (arg), val);
1649 val = iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg), val);
1650 return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg), val);
1653 val = iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg)),
1655 return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg)),
1659 val = iterative_hash_template_arg (TREE_OPERAND (arg, 0), val);
1660 code = TREE_CODE (TREE_OPERAND (arg, 1));
1661 val = iterative_hash_object (code, val);
1662 return iterative_hash_template_arg (TREE_OPERAND (arg, 2), val);
1665 /* A lambda can't appear in a template arg, but don't crash on
1667 gcc_assert (seen_error ());
1671 case IMPLICIT_CONV_EXPR:
1672 case STATIC_CAST_EXPR:
1673 case REINTERPRET_CAST_EXPR:
1674 case CONST_CAST_EXPR:
1675 case DYNAMIC_CAST_EXPR:
1677 val = iterative_hash_template_arg (TREE_TYPE (arg), val);
1678 /* Now hash operands as usual. */
1688 if (alias_template_specialization_p (arg))
1690 // We want an alias specialization that survived strip_typedefs
1691 // to hash differently from its TYPE_CANONICAL, to avoid hash
1692 // collisions that compare as different in template_args_equal.
1693 // These could be dependent specializations that strip_typedefs
1694 // left alone, or untouched specializations because
1695 // coerce_template_parms returns the unconverted template
1696 // arguments if it sees incomplete argument packs.
1697 tree ti = TYPE_TEMPLATE_INFO (arg);
1698 return hash_tmpl_and_args (TI_TEMPLATE (ti), TI_ARGS (ti));
1700 if (TYPE_CANONICAL (arg))
1701 return iterative_hash_object (TYPE_HASH (TYPE_CANONICAL (arg)),
1703 else if (TREE_CODE (arg) == DECLTYPE_TYPE)
1704 return iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg), val);
1705 /* Otherwise just compare the types during lookup. */
1708 case tcc_declaration:
1710 return iterative_hash_expr (arg, val);
1713 gcc_assert (IS_EXPR_CODE_CLASS (tclass));
1715 unsigned n = cp_tree_operand_length (arg);
1716 for (i = 0; i < n; ++i)
1717 val = iterative_hash_template_arg (TREE_OPERAND (arg, i), val);
1725 /* Unregister the specialization SPEC as a specialization of TMPL.
1726 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1727 if the SPEC was listed as a specialization of TMPL.
1729 Note that SPEC has been ggc_freed, so we can't look inside it. */
1732 reregister_specialization (tree spec, tree tinfo, tree new_spec)
1737 elt.tmpl = most_general_template (TI_TEMPLATE (tinfo));
1738 elt.args = TI_ARGS (tinfo);
1739 elt.spec = NULL_TREE;
1741 entry = decl_specializations->find (&elt);
1744 gcc_assert (entry->spec == spec || entry->spec == new_spec);
1745 gcc_assert (new_spec != NULL_TREE);
1746 entry->spec = new_spec;
1753 /* Like register_specialization, but for local declarations. We are
1754 registering SPEC, an instantiation of TMPL. */
1757 register_local_specialization (tree spec, tree tmpl)
1759 local_specializations->put (tmpl, spec);
1762 /* TYPE is a class type. Returns true if TYPE is an explicitly
1763 specialized class. */
1766 explicit_class_specialization_p (tree type)
1768 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
1770 return !uses_template_parms (CLASSTYPE_TI_ARGS (type));
1773 /* Print the list of functions at FNS, going through all the overloads
1774 for each element of the list. Alternatively, FNS can not be a
1775 TREE_LIST, in which case it will be printed together with all the
1778 MORE and *STR should respectively be FALSE and NULL when the function
1779 is called from the outside. They are used internally on recursive
1780 calls. print_candidates manages the two parameters and leaves NULL
1781 in *STR when it ends. */
1784 print_candidates_1 (tree fns, bool more, const char **str)
1787 char *spaces = NULL;
1789 for (fn = fns; fn; fn = OVL_NEXT (fn))
1790 if (TREE_CODE (fn) == TREE_LIST)
1792 for (fn2 = fn; fn2 != NULL_TREE; fn2 = TREE_CHAIN (fn2))
1793 print_candidates_1 (TREE_VALUE (fn2),
1794 TREE_CHAIN (fn2) || more, str);
1798 tree cand = OVL_CURRENT (fn);
1801 /* Pick the prefix string. */
1802 if (!more && !OVL_NEXT (fns))
1804 inform (DECL_SOURCE_LOCATION (cand),
1805 "candidate is: %#D", cand);
1809 *str = _("candidates are:");
1810 spaces = get_spaces (*str);
1812 inform (DECL_SOURCE_LOCATION (cand), "%s %#D", *str, cand);
1813 *str = spaces ? spaces : *str;
1823 /* Print the list of candidate FNS in an error message. FNS can also
1824 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
1827 print_candidates (tree fns)
1829 const char *str = NULL;
1830 print_candidates_1 (fns, false, &str);
1831 gcc_assert (str == NULL);
1834 /* Returns the template (one of the functions given by TEMPLATE_ID)
1835 which can be specialized to match the indicated DECL with the
1836 explicit template args given in TEMPLATE_ID. The DECL may be
1837 NULL_TREE if none is available. In that case, the functions in
1838 TEMPLATE_ID are non-members.
1840 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
1841 specialization of a member template.
1843 The TEMPLATE_COUNT is the number of references to qualifying
1844 template classes that appeared in the name of the function. See
1845 check_explicit_specialization for a more accurate description.
1847 TSK indicates what kind of template declaration (if any) is being
1848 declared. TSK_TEMPLATE indicates that the declaration given by
1849 DECL, though a FUNCTION_DECL, has template parameters, and is
1850 therefore a template function.
1852 The template args (those explicitly specified and those deduced)
1853 are output in a newly created vector *TARGS_OUT.
1855 If it is impossible to determine the result, an error message is
1856 issued. The error_mark_node is returned to indicate failure. */
1859 determine_specialization (tree template_id,
1862 int need_member_template,
1868 tree explicit_targs;
1869 tree candidates = NULL_TREE;
1870 /* A TREE_LIST of templates of which DECL may be a specialization.
1871 The TREE_VALUE of each node is a TEMPLATE_DECL. The
1872 corresponding TREE_PURPOSE is the set of template arguments that,
1873 when used to instantiate the template, would produce a function
1874 with the signature of DECL. */
1875 tree templates = NULL_TREE;
1877 cp_binding_level *b;
1879 *targs_out = NULL_TREE;
1881 if (template_id == error_mark_node || decl == error_mark_node)
1882 return error_mark_node;
1884 /* We shouldn't be specializing a member template of an
1885 unspecialized class template; we already gave an error in
1886 check_specialization_scope, now avoid crashing. */
1887 if (template_count && DECL_CLASS_SCOPE_P (decl)
1888 && template_class_depth (DECL_CONTEXT (decl)) > 0)
1890 gcc_assert (errorcount);
1891 return error_mark_node;
1894 fns = TREE_OPERAND (template_id, 0);
1895 explicit_targs = TREE_OPERAND (template_id, 1);
1897 if (fns == error_mark_node)
1898 return error_mark_node;
1900 /* Check for baselinks. */
1901 if (BASELINK_P (fns))
1902 fns = BASELINK_FUNCTIONS (fns);
1904 if (TREE_CODE (decl) == FUNCTION_DECL && !is_overloaded_fn (fns))
1906 error ("%qD is not a function template", fns);
1907 return error_mark_node;
1909 else if (VAR_P (decl) && !variable_template_p (fns))
1911 error ("%qD is not a variable template", fns);
1912 return error_mark_node;
1915 /* Count the number of template headers specified for this
1918 for (b = current_binding_level;
1919 b->kind == sk_template_parms;
1923 if (variable_template_p (fns))
1925 tree parms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (fns));
1926 targs = coerce_template_parms (parms, explicit_targs, fns,
1927 tf_warning_or_error,
1928 /*req_all*/true, /*use_defarg*/true);
1929 templates = tree_cons (targs, fns, templates);
1931 else for (; fns; fns = OVL_NEXT (fns))
1933 tree fn = OVL_CURRENT (fns);
1935 if (TREE_CODE (fn) == TEMPLATE_DECL)
1937 tree decl_arg_types;
1941 /* In case of explicit specialization, we need to check if
1942 the number of template headers appearing in the specialization
1943 is correct. This is usually done in check_explicit_specialization,
1944 but the check done there cannot be exhaustive when specializing
1945 member functions. Consider the following code:
1947 template <> void A<int>::f(int);
1948 template <> template <> void A<int>::f(int);
1950 Assuming that A<int> is not itself an explicit specialization
1951 already, the first line specializes "f" which is a non-template
1952 member function, whilst the second line specializes "f" which
1953 is a template member function. So both lines are syntactically
1954 correct, and check_explicit_specialization does not reject
1957 Here, we can do better, as we are matching the specialization
1958 against the declarations. We count the number of template
1959 headers, and we check if they match TEMPLATE_COUNT + 1
1960 (TEMPLATE_COUNT is the number of qualifying template classes,
1961 plus there must be another header for the member template
1964 Notice that if header_count is zero, this is not a
1965 specialization but rather a template instantiation, so there
1966 is no check we can perform here. */
1967 if (header_count && header_count != template_count + 1)
1970 /* Check that the number of template arguments at the
1971 innermost level for DECL is the same as for FN. */
1972 if (current_binding_level->kind == sk_template_parms
1973 && !current_binding_level->explicit_spec_p
1974 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn))
1975 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
1976 (current_template_parms))))
1979 /* DECL might be a specialization of FN. */
1980 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
1981 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
1983 /* For a non-static member function, we need to make sure
1984 that the const qualification is the same. Since
1985 get_bindings does not try to merge the "this" parameter,
1986 we must do the comparison explicitly. */
1987 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1988 && !same_type_p (TREE_VALUE (fn_arg_types),
1989 TREE_VALUE (decl_arg_types)))
1992 /* Skip the "this" parameter and, for constructors of
1993 classes with virtual bases, the VTT parameter. A
1994 full specialization of a constructor will have a VTT
1995 parameter, but a template never will. */
1997 = skip_artificial_parms_for (decl, decl_arg_types);
1999 = skip_artificial_parms_for (fn, fn_arg_types);
2001 /* Function templates cannot be specializations; there are
2002 no partial specializations of functions. Therefore, if
2003 the type of DECL does not match FN, there is no
2005 if (tsk == tsk_template)
2007 if (compparms (fn_arg_types, decl_arg_types))
2008 candidates = tree_cons (NULL_TREE, fn, candidates);
2012 /* See whether this function might be a specialization of this
2013 template. Suppress access control because we might be trying
2014 to make this specialization a friend, and we have already done
2015 access control for the declaration of the specialization. */
2016 push_deferring_access_checks (dk_no_check);
2017 targs = get_bindings (fn, decl, explicit_targs, /*check_ret=*/true);
2018 pop_deferring_access_checks ();
2021 /* We cannot deduce template arguments that when used to
2022 specialize TMPL will produce DECL. */
2025 /* Make sure that the deduced arguments actually work. */
2026 insttype = tsubst (TREE_TYPE (fn), targs, tf_none, NULL_TREE);
2027 if (insttype == error_mark_node)
2030 = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (insttype));
2031 if (!compparms (fn_arg_types, decl_arg_types))
2034 /* Save this template, and the arguments deduced. */
2035 templates = tree_cons (targs, fn, templates);
2037 else if (need_member_template)
2038 /* FN is an ordinary member function, and we need a
2039 specialization of a member template. */
2041 else if (TREE_CODE (fn) != FUNCTION_DECL)
2042 /* We can get IDENTIFIER_NODEs here in certain erroneous
2045 else if (!DECL_FUNCTION_MEMBER_P (fn))
2046 /* This is just an ordinary non-member function. Nothing can
2047 be a specialization of that. */
2049 else if (DECL_ARTIFICIAL (fn))
2050 /* Cannot specialize functions that are created implicitly. */
2054 tree decl_arg_types;
2056 /* This is an ordinary member function. However, since
2057 we're here, we can assume its enclosing class is a
2058 template class. For example,
2060 template <typename T> struct S { void f(); };
2061 template <> void S<int>::f() {}
2063 Here, S<int>::f is a non-template, but S<int> is a
2064 template class. If FN has the same type as DECL, we
2065 might be in business. */
2067 if (!DECL_TEMPLATE_INFO (fn))
2068 /* Its enclosing class is an explicit specialization
2069 of a template class. This is not a candidate. */
2072 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
2073 TREE_TYPE (TREE_TYPE (fn))))
2074 /* The return types differ. */
2077 /* Adjust the type of DECL in case FN is a static member. */
2078 decl_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
2079 if (DECL_STATIC_FUNCTION_P (fn)
2080 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2081 decl_arg_types = TREE_CHAIN (decl_arg_types);
2083 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
2086 candidates = tree_cons (NULL_TREE, fn, candidates);
2090 if (templates && TREE_CHAIN (templates))
2096 It is possible for a specialization with a given function
2097 signature to be instantiated from more than one function
2098 template. In such cases, explicit specification of the
2099 template arguments must be used to uniquely identify the
2100 function template specialization being specialized.
2102 Note that here, there's no suggestion that we're supposed to
2103 determine which of the candidate templates is most
2104 specialized. However, we, also have:
2108 Partial ordering of overloaded function template
2109 declarations is used in the following contexts to select
2110 the function template to which a function template
2111 specialization refers:
2113 -- when an explicit specialization refers to a function
2116 So, we do use the partial ordering rules, at least for now.
2117 This extension can only serve to make invalid programs valid,
2118 so it's safe. And, there is strong anecdotal evidence that
2119 the committee intended the partial ordering rules to apply;
2120 the EDG front end has that behavior, and John Spicer claims
2121 that the committee simply forgot to delete the wording in
2122 [temp.expl.spec]. */
2123 tree tmpl = most_specialized_instantiation (templates);
2124 if (tmpl != error_mark_node)
2127 TREE_CHAIN (templates) = NULL_TREE;
2131 if (templates == NULL_TREE && candidates == NULL_TREE)
2133 error ("template-id %qD for %q+D does not match any template "
2134 "declaration", template_id, decl);
2135 if (header_count && header_count != template_count + 1)
2136 inform (input_location, "saw %d %<template<>%>, need %d for "
2137 "specializing a member function template",
2138 header_count, template_count + 1);
2139 return error_mark_node;
2141 else if ((templates && TREE_CHAIN (templates))
2142 || (candidates && TREE_CHAIN (candidates))
2143 || (templates && candidates))
2145 error ("ambiguous template specialization %qD for %q+D",
2147 candidates = chainon (candidates, templates);
2148 print_candidates (candidates);
2149 return error_mark_node;
2152 /* We have one, and exactly one, match. */
2155 tree fn = TREE_VALUE (candidates);
2156 *targs_out = copy_node (DECL_TI_ARGS (fn));
2157 /* DECL is a re-declaration or partial instantiation of a template
2159 if (TREE_CODE (fn) == TEMPLATE_DECL)
2161 /* It was a specialization of an ordinary member function in a
2163 return DECL_TI_TEMPLATE (fn);
2166 /* It was a specialization of a template. */
2167 targs = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates)));
2168 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs))
2170 *targs_out = copy_node (targs);
2171 SET_TMPL_ARGS_LEVEL (*targs_out,
2172 TMPL_ARGS_DEPTH (*targs_out),
2173 TREE_PURPOSE (templates));
2176 *targs_out = TREE_PURPOSE (templates);
2177 return TREE_VALUE (templates);
2180 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2181 but with the default argument values filled in from those in the
2185 copy_default_args_to_explicit_spec_1 (tree spec_types,
2188 tree new_spec_types;
2193 if (spec_types == void_list_node)
2194 return void_list_node;
2196 /* Substitute into the rest of the list. */
2198 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types),
2199 TREE_CHAIN (tmpl_types));
2201 /* Add the default argument for this parameter. */
2202 return hash_tree_cons (TREE_PURPOSE (tmpl_types),
2203 TREE_VALUE (spec_types),
2207 /* DECL is an explicit specialization. Replicate default arguments
2208 from the template it specializes. (That way, code like:
2210 template <class T> void f(T = 3);
2211 template <> void f(double);
2214 works, as required.) An alternative approach would be to look up
2215 the correct default arguments at the call-site, but this approach
2216 is consistent with how implicit instantiations are handled. */
2219 copy_default_args_to_explicit_spec (tree decl)
2224 tree new_spec_types;
2228 tree object_type = NULL_TREE;
2229 tree in_charge = NULL_TREE;
2230 tree vtt = NULL_TREE;
2232 /* See if there's anything we need to do. */
2233 tmpl = DECL_TI_TEMPLATE (decl);
2234 tmpl_types = TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl)));
2235 for (t = tmpl_types; t; t = TREE_CHAIN (t))
2236 if (TREE_PURPOSE (t))
2241 old_type = TREE_TYPE (decl);
2242 spec_types = TYPE_ARG_TYPES (old_type);
2244 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2246 /* Remove the this pointer, but remember the object's type for
2248 object_type = TREE_TYPE (TREE_VALUE (spec_types));
2249 spec_types = TREE_CHAIN (spec_types);
2250 tmpl_types = TREE_CHAIN (tmpl_types);
2252 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
2254 /* DECL may contain more parameters than TMPL due to the extra
2255 in-charge parameter in constructors and destructors. */
2256 in_charge = spec_types;
2257 spec_types = TREE_CHAIN (spec_types);
2259 if (DECL_HAS_VTT_PARM_P (decl))
2262 spec_types = TREE_CHAIN (spec_types);
2266 /* Compute the merged default arguments. */
2268 copy_default_args_to_explicit_spec_1 (spec_types, tmpl_types);
2270 /* Compute the new FUNCTION_TYPE. */
2274 new_spec_types = hash_tree_cons (TREE_PURPOSE (vtt),
2279 /* Put the in-charge parameter back. */
2280 new_spec_types = hash_tree_cons (TREE_PURPOSE (in_charge),
2281 TREE_VALUE (in_charge),
2284 new_type = build_method_type_directly (object_type,
2285 TREE_TYPE (old_type),
2289 new_type = build_function_type (TREE_TYPE (old_type),
2291 new_type = cp_build_type_attribute_variant (new_type,
2292 TYPE_ATTRIBUTES (old_type));
2293 new_type = build_exception_variant (new_type,
2294 TYPE_RAISES_EXCEPTIONS (old_type));
2296 if (TYPE_HAS_LATE_RETURN_TYPE (old_type))
2297 TYPE_HAS_LATE_RETURN_TYPE (new_type) = 1;
2299 TREE_TYPE (decl) = new_type;
2302 /* Return the number of template headers we expect to see for a definition
2303 or specialization of CTYPE or one of its non-template members. */
2306 num_template_headers_for_class (tree ctype)
2308 int num_templates = 0;
2310 while (ctype && CLASS_TYPE_P (ctype))
2312 /* You're supposed to have one `template <...>' for every
2313 template class, but you don't need one for a full
2314 specialization. For example:
2316 template <class T> struct S{};
2317 template <> struct S<int> { void f(); };
2318 void S<int>::f () {}
2320 is correct; there shouldn't be a `template <>' for the
2321 definition of `S<int>::f'. */
2322 if (!CLASSTYPE_TEMPLATE_INFO (ctype))
2323 /* If CTYPE does not have template information of any
2324 kind, then it is not a template, nor is it nested
2325 within a template. */
2327 if (explicit_class_specialization_p (ctype))
2329 if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (ctype)))
2332 ctype = TYPE_CONTEXT (ctype);
2335 return num_templates;
2338 /* Do a simple sanity check on the template headers that precede the
2339 variable declaration DECL. */
2342 check_template_variable (tree decl)
2344 tree ctx = CP_DECL_CONTEXT (decl);
2345 int wanted = num_template_headers_for_class (ctx);
2346 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
2347 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl)))
2349 if (cxx_dialect < cxx14)
2350 pedwarn (DECL_SOURCE_LOCATION (decl), 0,
2351 "variable templates only available with "
2352 "-std=c++14 or -std=gnu++14");
2354 // Namespace-scope variable templates should have a template header.
2357 if (template_header_count > wanted)
2359 bool warned = pedwarn (DECL_SOURCE_LOCATION (decl), 0,
2360 "too many template headers for %D (should be %d)",
2362 if (warned && CLASS_TYPE_P (ctx)
2363 && CLASSTYPE_TEMPLATE_SPECIALIZATION (ctx))
2364 inform (DECL_SOURCE_LOCATION (decl),
2365 "members of an explicitly specialized class are defined "
2366 "without a template header");
2370 /* Check to see if the function just declared, as indicated in
2371 DECLARATOR, and in DECL, is a specialization of a function
2372 template. We may also discover that the declaration is an explicit
2373 instantiation at this point.
2375 Returns DECL, or an equivalent declaration that should be used
2376 instead if all goes well. Issues an error message if something is
2377 amiss. Returns error_mark_node if the error is not easily
2380 FLAGS is a bitmask consisting of the following flags:
2382 2: The function has a definition.
2383 4: The function is a friend.
2385 The TEMPLATE_COUNT is the number of references to qualifying
2386 template classes that appeared in the name of the function. For
2389 template <class T> struct S { void f(); };
2392 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2393 classes are not counted in the TEMPLATE_COUNT, so that in
2395 template <class T> struct S {};
2396 template <> struct S<int> { void f(); }
2397 template <> void S<int>::f();
2399 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2400 invalid; there should be no template <>.)
2402 If the function is a specialization, it is marked as such via
2403 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2404 is set up correctly, and it is added to the list of specializations
2405 for that template. */
2408 check_explicit_specialization (tree declarator,
2413 int have_def = flags & 2;
2414 int is_friend = flags & 4;
2415 int specialization = 0;
2416 int explicit_instantiation = 0;
2417 int member_specialization = 0;
2418 tree ctype = DECL_CLASS_CONTEXT (decl);
2419 tree dname = DECL_NAME (decl);
2424 if (!processing_specialization)
2427 tsk = tsk_excessive_parms;
2430 tsk = current_tmpl_spec_kind (template_count);
2435 if (processing_specialization)
2438 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
2440 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
2443 /* This could be something like:
2445 template <class T> void f(T);
2446 class S { friend void f<>(int); } */
2450 /* This case handles bogus declarations like template <>
2451 template <class T> void f<int>(); */
2453 error ("template-id %qD in declaration of primary template",
2460 case tsk_invalid_member_spec:
2461 /* The error has already been reported in
2462 check_specialization_scope. */
2463 return error_mark_node;
2465 case tsk_invalid_expl_inst:
2466 error ("template parameter list used in explicit instantiation");
2472 error ("definition provided for explicit instantiation");
2474 explicit_instantiation = 1;
2477 case tsk_excessive_parms:
2478 case tsk_insufficient_parms:
2479 if (tsk == tsk_excessive_parms)
2480 error ("too many template parameter lists in declaration of %qD",
2482 else if (template_header_count)
2483 error("too few template parameter lists in declaration of %qD", decl);
2485 error("explicit specialization of %qD must be introduced by "
2486 "%<template <>%>", decl);
2490 if (VAR_P (decl) && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
2491 /* In cases like template<> constexpr bool v = true;
2492 We'll give an error in check_template_variable. */
2495 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
2497 member_specialization = 1;
2503 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
2505 /* This case handles bogus declarations like template <>
2506 template <class T> void f<int>(); */
2508 if (!uses_template_parms (declarator))
2509 error ("template-id %qD in declaration of primary template",
2511 else if (variable_template_p (TREE_OPERAND (declarator, 0)))
2513 /* Partial specialization of variable template. */
2514 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
2518 else if (cxx_dialect < cxx14)
2519 error ("non-type partial specialization %qD "
2520 "is not allowed", declarator);
2522 error ("non-class, non-variable partial specialization %qD "
2523 "is not allowed", declarator);
2528 if (ctype && CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
2529 /* This is a specialization of a member template, without
2530 specialization the containing class. Something like:
2532 template <class T> struct S {
2533 template <class U> void f (U);
2535 template <> template <class U> void S<int>::f(U) {}
2537 That's a specialization -- but of the entire template. */
2545 if ((specialization || member_specialization)
2546 /* This doesn't apply to variable templates. */
2547 && (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE
2548 || TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE))
2550 tree t = TYPE_ARG_TYPES (TREE_TYPE (decl));
2551 for (; t; t = TREE_CHAIN (t))
2552 if (TREE_PURPOSE (t))
2554 permerror (input_location,
2555 "default argument specified in explicit specialization");
2560 if (specialization || member_specialization || explicit_instantiation)
2562 tree tmpl = NULL_TREE;
2563 tree targs = NULL_TREE;
2564 bool was_template_id = (TREE_CODE (declarator) == TEMPLATE_ID_EXPR);
2566 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2567 if (!was_template_id)
2571 gcc_assert (identifier_p (declarator));
2576 /* If there is no class context, the explicit instantiation
2577 must be at namespace scope. */
2578 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl));
2580 /* Find the namespace binding, using the declaration
2582 fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
2584 if (fns == error_mark_node || !is_overloaded_fn (fns))
2586 error ("%qD is not a template function", dname);
2587 fns = error_mark_node;
2591 tree fn = OVL_CURRENT (fns);
2592 if (!is_associated_namespace (CP_DECL_CONTEXT (decl),
2593 CP_DECL_CONTEXT (fn)))
2594 error ("%qD is not declared in %qD",
2595 decl, current_namespace);
2599 declarator = lookup_template_function (fns, NULL_TREE);
2602 if (declarator == error_mark_node)
2603 return error_mark_node;
2605 if (ctype != NULL_TREE && TYPE_BEING_DEFINED (ctype))
2607 if (!explicit_instantiation)
2608 /* A specialization in class scope. This is invalid,
2609 but the error will already have been flagged by
2610 check_specialization_scope. */
2611 return error_mark_node;
2614 /* It's not valid to write an explicit instantiation in
2617 class C { template void f(); }
2619 This case is caught by the parser. However, on
2622 template class C { void f(); };
2624 (which is invalid) we can get here. The error will be
2631 else if (ctype != NULL_TREE
2632 && (identifier_p (TREE_OPERAND (declarator, 0))))
2634 // We'll match variable templates in start_decl.
2638 /* Find the list of functions in ctype that have the same
2639 name as the declared function. */
2640 tree name = TREE_OPERAND (declarator, 0);
2641 tree fns = NULL_TREE;
2644 if (constructor_name_p (name, ctype))
2646 int is_constructor = DECL_CONSTRUCTOR_P (decl);
2648 if (is_constructor ? !TYPE_HAS_USER_CONSTRUCTOR (ctype)
2649 : !CLASSTYPE_DESTRUCTORS (ctype))
2651 /* From [temp.expl.spec]:
2653 If such an explicit specialization for the member
2654 of a class template names an implicitly-declared
2655 special member function (clause _special_), the
2656 program is ill-formed.
2658 Similar language is found in [temp.explicit]. */
2659 error ("specialization of implicitly-declared special member function");
2660 return error_mark_node;
2663 name = is_constructor ? ctor_identifier : dtor_identifier;
2666 if (!DECL_CONV_FN_P (decl))
2668 idx = lookup_fnfields_1 (ctype, name);
2670 fns = (*CLASSTYPE_METHOD_VEC (ctype))[idx];
2674 vec<tree, va_gc> *methods;
2677 /* For a type-conversion operator, we cannot do a
2678 name-based lookup. We might be looking for `operator
2679 int' which will be a specialization of `operator T'.
2680 So, we find *all* the conversion operators, and then
2681 select from them. */
2684 methods = CLASSTYPE_METHOD_VEC (ctype);
2686 for (idx = CLASSTYPE_FIRST_CONVERSION_SLOT;
2687 methods->iterate (idx, &ovl);
2690 if (!DECL_CONV_FN_P (OVL_CURRENT (ovl)))
2691 /* There are no more conversion functions. */
2694 /* Glue all these conversion functions together
2695 with those we already have. */
2696 for (; ovl; ovl = OVL_NEXT (ovl))
2697 fns = ovl_cons (OVL_CURRENT (ovl), fns);
2701 if (fns == NULL_TREE)
2703 error ("no member function %qD declared in %qT", name, ctype);
2704 return error_mark_node;
2707 TREE_OPERAND (declarator, 0) = fns;
2710 /* Figure out what exactly is being specialized at this point.
2711 Note that for an explicit instantiation, even one for a
2712 member function, we cannot tell apriori whether the
2713 instantiation is for a member template, or just a member
2714 function of a template class. Even if a member template is
2715 being instantiated, the member template arguments may be
2716 elided if they can be deduced from the rest of the
2718 tmpl = determine_specialization (declarator, decl,
2720 member_specialization,
2724 if (!tmpl || tmpl == error_mark_node)
2725 /* We couldn't figure out what this declaration was
2727 return error_mark_node;
2730 tree gen_tmpl = most_general_template (tmpl);
2732 if (explicit_instantiation)
2734 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2735 is done by do_decl_instantiation later. */
2737 int arg_depth = TMPL_ARGS_DEPTH (targs);
2738 int parm_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
2740 if (arg_depth > parm_depth)
2742 /* If TMPL is not the most general template (for
2743 example, if TMPL is a friend template that is
2744 injected into namespace scope), then there will
2745 be too many levels of TARGS. Remove some of them
2750 new_targs = make_tree_vec (parm_depth);
2751 for (i = arg_depth - parm_depth; i < arg_depth; ++i)
2752 TREE_VEC_ELT (new_targs, i - (arg_depth - parm_depth))
2753 = TREE_VEC_ELT (targs, i);
2757 return instantiate_template (tmpl, targs, tf_error);
2760 /* If we thought that the DECL was a member function, but it
2761 turns out to be specializing a static member function,
2762 make DECL a static member function as well. */
2763 if (DECL_FUNCTION_TEMPLATE_P (tmpl)
2764 && DECL_STATIC_FUNCTION_P (tmpl)
2765 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
2766 revert_static_member_fn (decl);
2768 /* If this is a specialization of a member template of a
2769 template class, we want to return the TEMPLATE_DECL, not
2770 the specialization of it. */
2771 if (tsk == tsk_template && !was_template_id)
2773 tree result = DECL_TEMPLATE_RESULT (tmpl);
2774 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
2775 DECL_INITIAL (result) = NULL_TREE;
2779 DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
2780 DECL_SOURCE_LOCATION (result)
2781 = DECL_SOURCE_LOCATION (decl);
2782 /* We want to use the argument list specified in the
2783 definition, not in the original declaration. */
2784 DECL_ARGUMENTS (result) = DECL_ARGUMENTS (decl);
2785 for (parm = DECL_ARGUMENTS (result); parm;
2786 parm = DECL_CHAIN (parm))
2787 DECL_CONTEXT (parm) = result;
2789 return register_specialization (tmpl, gen_tmpl, targs,
2793 /* Set up the DECL_TEMPLATE_INFO for DECL. */
2794 DECL_TEMPLATE_INFO (decl) = build_template_info (tmpl, targs);
2796 if (was_template_id)
2797 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl)) = true;
2799 /* Inherit default function arguments from the template
2800 DECL is specializing. */
2801 if (DECL_FUNCTION_TEMPLATE_P (tmpl))
2802 copy_default_args_to_explicit_spec (decl);
2804 /* This specialization has the same protection as the
2805 template it specializes. */
2806 TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
2807 TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
2809 /* 7.1.1-1 [dcl.stc]
2811 A storage-class-specifier shall not be specified in an
2812 explicit specialization...
2814 The parser rejects these, so unless action is taken here,
2815 explicit function specializations will always appear with
2818 The action recommended by the C++ CWG in response to C++
2819 defect report 605 is to make the storage class and linkage
2820 of the explicit specialization match the templated function:
2822 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
2824 if (tsk == tsk_expl_spec && DECL_FUNCTION_TEMPLATE_P (gen_tmpl))
2826 tree tmpl_func = DECL_TEMPLATE_RESULT (gen_tmpl);
2827 gcc_assert (TREE_CODE (tmpl_func) == FUNCTION_DECL);
2829 /* This specialization has the same linkage and visibility as
2830 the function template it specializes. */
2831 TREE_PUBLIC (decl) = TREE_PUBLIC (tmpl_func);
2832 if (! TREE_PUBLIC (decl))
2834 DECL_INTERFACE_KNOWN (decl) = 1;
2835 DECL_NOT_REALLY_EXTERN (decl) = 1;
2837 DECL_THIS_STATIC (decl) = DECL_THIS_STATIC (tmpl_func);
2838 if (DECL_VISIBILITY_SPECIFIED (tmpl_func))
2840 DECL_VISIBILITY_SPECIFIED (decl) = 1;
2841 DECL_VISIBILITY (decl) = DECL_VISIBILITY (tmpl_func);
2845 /* If DECL is a friend declaration, declared using an
2846 unqualified name, the namespace associated with DECL may
2847 have been set incorrectly. For example, in:
2849 template <typename T> void f(T);
2851 struct S { friend void f<int>(int); }
2854 we will have set the DECL_CONTEXT for the friend
2855 declaration to N, rather than to the global namespace. */
2856 if (DECL_NAMESPACE_SCOPE_P (decl))
2857 DECL_CONTEXT (decl) = DECL_CONTEXT (tmpl);
2859 if (is_friend && !have_def)
2860 /* This is not really a declaration of a specialization.
2861 It's just the name of an instantiation. But, it's not
2862 a request for an instantiation, either. */
2863 SET_DECL_IMPLICIT_INSTANTIATION (decl);
2864 else if (TREE_CODE (decl) == FUNCTION_DECL)
2865 /* A specialization is not necessarily COMDAT. */
2866 DECL_COMDAT (decl) = (TREE_PUBLIC (decl)
2867 && DECL_DECLARED_INLINE_P (decl));
2868 else if (TREE_CODE (decl) == VAR_DECL)
2869 DECL_COMDAT (decl) = false;
2871 /* Register this specialization so that we can find it
2873 decl = register_specialization (decl, gen_tmpl, targs, is_friend, 0);
2875 /* A 'structor should already have clones. */
2876 gcc_assert (decl == error_mark_node
2877 || variable_template_p (tmpl)
2878 || !(DECL_CONSTRUCTOR_P (decl)
2879 || DECL_DESTRUCTOR_P (decl))
2880 || DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl)));
2887 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
2888 parameters. These are represented in the same format used for
2889 DECL_TEMPLATE_PARMS. */
2892 comp_template_parms (const_tree parms1, const_tree parms2)
2897 if (parms1 == parms2)
2900 for (p1 = parms1, p2 = parms2;
2901 p1 != NULL_TREE && p2 != NULL_TREE;
2902 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2))
2904 tree t1 = TREE_VALUE (p1);
2905 tree t2 = TREE_VALUE (p2);
2908 gcc_assert (TREE_CODE (t1) == TREE_VEC);
2909 gcc_assert (TREE_CODE (t2) == TREE_VEC);
2911 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
2914 for (i = 0; i < TREE_VEC_LENGTH (t2); ++i)
2916 tree parm1 = TREE_VALUE (TREE_VEC_ELT (t1, i));
2917 tree parm2 = TREE_VALUE (TREE_VEC_ELT (t2, i));
2919 /* If either of the template parameters are invalid, assume
2920 they match for the sake of error recovery. */
2921 if (error_operand_p (parm1) || error_operand_p (parm2))
2924 if (TREE_CODE (parm1) != TREE_CODE (parm2))
2927 if (TREE_CODE (parm1) == TEMPLATE_TYPE_PARM
2928 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1)
2929 == TEMPLATE_TYPE_PARAMETER_PACK (parm2)))
2931 else if (!same_type_p (TREE_TYPE (parm1), TREE_TYPE (parm2)))
2936 if ((p1 != NULL_TREE) != (p2 != NULL_TREE))
2937 /* One set of parameters has more parameters lists than the
2944 /* Determine whether PARM is a parameter pack. */
2947 template_parameter_pack_p (const_tree parm)
2949 /* Determine if we have a non-type template parameter pack. */
2950 if (TREE_CODE (parm) == PARM_DECL)
2951 return (DECL_TEMPLATE_PARM_P (parm)
2952 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)));
2953 if (TREE_CODE (parm) == TEMPLATE_PARM_INDEX)
2954 return TEMPLATE_PARM_PARAMETER_PACK (parm);
2956 /* If this is a list of template parameters, we could get a
2957 TYPE_DECL or a TEMPLATE_DECL. */
2958 if (TREE_CODE (parm) == TYPE_DECL || TREE_CODE (parm) == TEMPLATE_DECL)
2959 parm = TREE_TYPE (parm);
2961 /* Otherwise it must be a type template parameter. */
2962 return ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
2963 || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM)
2964 && TEMPLATE_TYPE_PARAMETER_PACK (parm));
2967 /* Determine if T is a function parameter pack. */
2970 function_parameter_pack_p (const_tree t)
2972 if (t && TREE_CODE (t) == PARM_DECL)
2973 return DECL_PACK_P (t);
2977 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
2978 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
2981 get_function_template_decl (const_tree primary_func_tmpl_inst)
2983 if (! primary_func_tmpl_inst
2984 || TREE_CODE (primary_func_tmpl_inst) != FUNCTION_DECL
2985 || ! primary_template_instantiation_p (primary_func_tmpl_inst))
2988 return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst));
2991 /* Return true iff the function parameter PARAM_DECL was expanded
2992 from the function parameter pack PACK. */
2995 function_parameter_expanded_from_pack_p (tree param_decl, tree pack)
2997 if (DECL_ARTIFICIAL (param_decl)
2998 || !function_parameter_pack_p (pack))
3001 /* The parameter pack and its pack arguments have the same
3003 return DECL_PARM_INDEX (pack) == DECL_PARM_INDEX (param_decl);
3006 /* Determine whether ARGS describes a variadic template args list,
3007 i.e., one that is terminated by a template argument pack. */
3010 template_args_variadic_p (tree args)
3015 if (args == NULL_TREE)
3018 args = INNERMOST_TEMPLATE_ARGS (args);
3019 nargs = TREE_VEC_LENGTH (args);
3024 last_parm = TREE_VEC_ELT (args, nargs - 1);
3026 return ARGUMENT_PACK_P (last_parm);
3029 /* Generate a new name for the parameter pack name NAME (an
3030 IDENTIFIER_NODE) that incorporates its */
3033 make_ith_pack_parameter_name (tree name, int i)
3035 /* Munge the name to include the parameter index. */
3036 #define NUMBUF_LEN 128
3037 char numbuf[NUMBUF_LEN];
3041 if (name == NULL_TREE)
3043 snprintf (numbuf, NUMBUF_LEN, "%i", i);
3044 newname_len = IDENTIFIER_LENGTH (name)
3045 + strlen (numbuf) + 2;
3046 newname = (char*)alloca (newname_len);
3047 snprintf (newname, newname_len,
3048 "%s#%i", IDENTIFIER_POINTER (name), i);
3049 return get_identifier (newname);
3052 /* Return true if T is a primary function, class or alias template
3056 primary_template_instantiation_p (const_tree t)
3061 if (TREE_CODE (t) == FUNCTION_DECL)
3062 return DECL_LANG_SPECIFIC (t)
3063 && DECL_TEMPLATE_INSTANTIATION (t)
3064 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t));
3065 else if (CLASS_TYPE_P (t) && !TYPE_DECL_ALIAS_P (TYPE_NAME (t)))
3066 return CLASSTYPE_TEMPLATE_INSTANTIATION (t)
3067 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t));
3068 else if (alias_template_specialization_p (t))
3073 /* Return true if PARM is a template template parameter. */
3076 template_template_parameter_p (const_tree parm)
3078 return DECL_TEMPLATE_TEMPLATE_PARM_P (parm);
3081 /* Return true iff PARM is a DECL representing a type template
3085 template_type_parameter_p (const_tree parm)
3088 && (TREE_CODE (parm) == TYPE_DECL
3089 || TREE_CODE (parm) == TEMPLATE_DECL)
3090 && DECL_TEMPLATE_PARM_P (parm));
3093 /* Return the template parameters of T if T is a
3094 primary template instantiation, NULL otherwise. */
3097 get_primary_template_innermost_parameters (const_tree t)
3099 tree parms = NULL, template_info = NULL;
3101 if ((template_info = get_template_info (t))
3102 && primary_template_instantiation_p (t))
3103 parms = INNERMOST_TEMPLATE_PARMS
3104 (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info)));
3109 /* Return the template parameters of the LEVELth level from the full list
3110 of template parameters PARMS. */
3113 get_template_parms_at_level (tree parms, int level)
3117 || TREE_CODE (parms) != TREE_LIST
3118 || level > TMPL_PARMS_DEPTH (parms))
3121 for (p = parms; p; p = TREE_CHAIN (p))
3122 if (TMPL_PARMS_DEPTH (p) == level)
3128 /* Returns the template arguments of T if T is a template instantiation,
3132 get_template_innermost_arguments (const_tree t)
3134 tree args = NULL, template_info = NULL;
3136 if ((template_info = get_template_info (t))
3137 && TI_ARGS (template_info))
3138 args = INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info));
3143 /* Return the argument pack elements of T if T is a template argument pack,
3147 get_template_argument_pack_elems (const_tree t)
3149 if (TREE_CODE (t) != TYPE_ARGUMENT_PACK
3150 && TREE_CODE (t) != NONTYPE_ARGUMENT_PACK)
3153 return ARGUMENT_PACK_ARGS (t);
3156 /* Structure used to track the progress of find_parameter_packs_r. */
3157 struct find_parameter_pack_data
3159 /* TREE_LIST that will contain all of the parameter packs found by
3161 tree* parameter_packs;
3163 /* Set of AST nodes that have been visited by the traversal. */
3164 hash_set<tree> *visited;
3167 /* Identifies all of the argument packs that occur in a template
3168 argument and appends them to the TREE_LIST inside DATA, which is a
3169 find_parameter_pack_data structure. This is a subroutine of
3170 make_pack_expansion and uses_parameter_packs. */
3172 find_parameter_packs_r (tree *tp, int *walk_subtrees, void* data)
3175 struct find_parameter_pack_data* ppd =
3176 (struct find_parameter_pack_data*)data;
3177 bool parameter_pack_p = false;
3179 /* Handle type aliases/typedefs. */
3180 if (TYPE_ALIAS_P (t))
3182 if (TYPE_TEMPLATE_INFO (t))
3183 cp_walk_tree (&TYPE_TI_ARGS (t),
3184 &find_parameter_packs_r,
3190 /* Identify whether this is a parameter pack or not. */
3191 switch (TREE_CODE (t))
3193 case TEMPLATE_PARM_INDEX:
3194 if (TEMPLATE_PARM_PARAMETER_PACK (t))
3195 parameter_pack_p = true;
3198 case TEMPLATE_TYPE_PARM:
3199 t = TYPE_MAIN_VARIANT (t);
3200 case TEMPLATE_TEMPLATE_PARM:
3201 if (TEMPLATE_TYPE_PARAMETER_PACK (t))
3202 parameter_pack_p = true;
3207 if (DECL_PACK_P (t))
3209 /* We don't want to walk into the type of a PARM_DECL,
3210 because we don't want to see the type parameter pack. */
3212 parameter_pack_p = true;
3216 /* Look through a lambda capture proxy to the field pack. */
3218 if (DECL_HAS_VALUE_EXPR_P (t))
3220 tree v = DECL_VALUE_EXPR (t);
3222 &find_parameter_packs_r,
3226 else if (variable_template_specialization_p (t))
3228 cp_walk_tree (&DECL_TI_ARGS (t),
3229 find_parameter_packs_r,
3236 parameter_pack_p = true;
3239 /* Not a parameter pack. */
3243 if (parameter_pack_p)
3245 /* Add this parameter pack to the list. */
3246 *ppd->parameter_packs = tree_cons (NULL_TREE, t, *ppd->parameter_packs);
3250 cp_walk_tree (&TYPE_CONTEXT (t),
3251 &find_parameter_packs_r, ppd, ppd->visited);
3253 /* This switch statement will return immediately if we don't find a
3255 switch (TREE_CODE (t))
3257 case TEMPLATE_PARM_INDEX:
3260 case BOUND_TEMPLATE_TEMPLATE_PARM:
3261 /* Check the template itself. */
3262 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t)),
3263 &find_parameter_packs_r, ppd, ppd->visited);
3264 /* Check the template arguments. */
3265 cp_walk_tree (&TYPE_TI_ARGS (t), &find_parameter_packs_r, ppd,
3270 case TEMPLATE_TYPE_PARM:
3271 case TEMPLATE_TEMPLATE_PARM:
3278 if (TYPE_PTRMEMFUNC_P (t))
3284 if (TYPE_TEMPLATE_INFO (t))
3285 cp_walk_tree (&TYPE_TI_ARGS (t),
3286 &find_parameter_packs_r, ppd, ppd->visited);
3293 cp_walk_tree (&TREE_TYPE (t),
3294 &find_parameter_packs_r, ppd, ppd->visited);
3298 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t), &find_parameter_packs_r,
3303 case TYPE_PACK_EXPANSION:
3304 case EXPR_PACK_EXPANSION:
3309 cp_walk_tree (&TYPE_MAX_VALUE (t), &find_parameter_packs_r,
3314 case IDENTIFIER_NODE:
3315 cp_walk_tree (&TREE_TYPE (t), &find_parameter_packs_r, ppd,
3327 /* Determines if the expression or type T uses any parameter packs. */
3329 uses_parameter_packs (tree t)
3331 tree parameter_packs = NULL_TREE;
3332 struct find_parameter_pack_data ppd;
3333 ppd.parameter_packs = ¶meter_packs;
3334 ppd.visited = new hash_set<tree>;
3335 cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
3337 return parameter_packs != NULL_TREE;
3340 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3341 representation a base-class initializer into a parameter pack
3342 expansion. If all goes well, the resulting node will be an
3343 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3346 make_pack_expansion (tree arg)
3349 tree parameter_packs = NULL_TREE;
3350 bool for_types = false;
3351 struct find_parameter_pack_data ppd;
3353 if (!arg || arg == error_mark_node)
3356 if (TREE_CODE (arg) == TREE_LIST && TREE_PURPOSE (arg))
3358 /* A TREE_LIST with a non-null TREE_PURPOSE is for a base
3359 class initializer. In this case, the TREE_PURPOSE will be a
3360 _TYPE node (representing the base class expansion we're
3361 initializing) and the TREE_VALUE will be a TREE_LIST
3362 containing the initialization arguments.
3364 The resulting expansion looks somewhat different from most
3365 expansions. Rather than returning just one _EXPANSION, we
3366 return a TREE_LIST whose TREE_PURPOSE is a
3367 TYPE_PACK_EXPANSION containing the bases that will be
3368 initialized. The TREE_VALUE will be identical to the
3369 original TREE_VALUE, which is a list of arguments that will
3370 be passed to each base. We do not introduce any new pack
3371 expansion nodes into the TREE_VALUE (although it is possible
3372 that some already exist), because the TREE_PURPOSE and
3373 TREE_VALUE all need to be expanded together with the same
3374 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3375 resulting TREE_PURPOSE will mention the parameter packs in
3376 both the bases and the arguments to the bases. */
3379 tree parameter_packs = NULL_TREE;
3381 /* Determine which parameter packs will be used by the base
3383 ppd.visited = new hash_set<tree>;
3384 ppd.parameter_packs = ¶meter_packs;
3385 cp_walk_tree (&TREE_PURPOSE (arg), &find_parameter_packs_r,
3388 if (parameter_packs == NULL_TREE)
3390 error ("base initializer expansion %<%T%> contains no parameter packs", arg);
3392 return error_mark_node;
3395 if (TREE_VALUE (arg) != void_type_node)
3397 /* Collect the sets of parameter packs used in each of the
3398 initialization arguments. */
3399 for (value = TREE_VALUE (arg); value; value = TREE_CHAIN (value))
3401 /* Determine which parameter packs will be expanded in this
3403 cp_walk_tree (&TREE_VALUE (value), &find_parameter_packs_r,
3410 /* Create the pack expansion type for the base type. */
3411 purpose = cxx_make_type (TYPE_PACK_EXPANSION);
3412 SET_PACK_EXPANSION_PATTERN (purpose, TREE_PURPOSE (arg));
3413 PACK_EXPANSION_PARAMETER_PACKS (purpose) = parameter_packs;
3415 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3416 they will rarely be compared to anything. */
3417 SET_TYPE_STRUCTURAL_EQUALITY (purpose);
3419 return tree_cons (purpose, TREE_VALUE (arg), NULL_TREE);
3422 if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
3425 /* Build the PACK_EXPANSION_* node. */
3427 ? cxx_make_type (TYPE_PACK_EXPANSION)
3428 : make_node (EXPR_PACK_EXPANSION);
3429 SET_PACK_EXPANSION_PATTERN (result, arg);
3430 if (TREE_CODE (result) == EXPR_PACK_EXPANSION)
3432 /* Propagate type and const-expression information. */
3433 TREE_TYPE (result) = TREE_TYPE (arg);
3434 TREE_CONSTANT (result) = TREE_CONSTANT (arg);
3437 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3438 they will rarely be compared to anything. */
3439 SET_TYPE_STRUCTURAL_EQUALITY (result);
3441 /* Determine which parameter packs will be expanded. */
3442 ppd.parameter_packs = ¶meter_packs;
3443 ppd.visited = new hash_set<tree>;
3444 cp_walk_tree (&arg, &find_parameter_packs_r, &ppd, ppd.visited);
3447 /* Make sure we found some parameter packs. */
3448 if (parameter_packs == NULL_TREE)
3451 error ("expansion pattern %<%T%> contains no argument packs", arg);
3453 error ("expansion pattern %<%E%> contains no argument packs", arg);
3454 return error_mark_node;
3456 PACK_EXPANSION_PARAMETER_PACKS (result) = parameter_packs;
3458 PACK_EXPANSION_LOCAL_P (result) = at_function_scope_p ();
3463 /* Checks T for any "bare" parameter packs, which have not yet been
3464 expanded, and issues an error if any are found. This operation can
3465 only be done on full expressions or types (e.g., an expression
3466 statement, "if" condition, etc.), because we could have expressions like:
3468 foo(f(g(h(args)))...)
3470 where "args" is a parameter pack. check_for_bare_parameter_packs
3471 should not be called for the subexpressions args, h(args),
3472 g(h(args)), or f(g(h(args))), because we would produce erroneous
3475 Returns TRUE and emits an error if there were bare parameter packs,
3476 returns FALSE otherwise. */
3478 check_for_bare_parameter_packs (tree t)
3480 tree parameter_packs = NULL_TREE;
3481 struct find_parameter_pack_data ppd;
3483 if (!processing_template_decl || !t || t == error_mark_node)
3486 if (TREE_CODE (t) == TYPE_DECL)
3489 ppd.parameter_packs = ¶meter_packs;
3490 ppd.visited = new hash_set<tree>;
3491 cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited);
3494 if (parameter_packs)
3496 error ("parameter packs not expanded with %<...%>:");
3497 while (parameter_packs)
3499 tree pack = TREE_VALUE (parameter_packs);
3500 tree name = NULL_TREE;
3502 if (TREE_CODE (pack) == TEMPLATE_TYPE_PARM
3503 || TREE_CODE (pack) == TEMPLATE_TEMPLATE_PARM)
3504 name = TYPE_NAME (pack);
3505 else if (TREE_CODE (pack) == TEMPLATE_PARM_INDEX)
3506 name = DECL_NAME (TEMPLATE_PARM_DECL (pack));
3508 name = DECL_NAME (pack);
3511 inform (input_location, " %qD", name);
3513 inform (input_location, " <anonymous>");
3515 parameter_packs = TREE_CHAIN (parameter_packs);
3524 /* Expand any parameter packs that occur in the template arguments in
3527 expand_template_argument_pack (tree args)
3529 tree result_args = NULL_TREE;
3530 int in_arg, out_arg = 0, nargs = args ? TREE_VEC_LENGTH (args) : 0;
3531 int num_result_args = -1;
3532 int non_default_args_count = -1;
3534 /* First, determine if we need to expand anything, and the number of
3535 slots we'll need. */
3536 for (in_arg = 0; in_arg < nargs; ++in_arg)
3538 tree arg = TREE_VEC_ELT (args, in_arg);
3539 if (arg == NULL_TREE)
3541 if (ARGUMENT_PACK_P (arg))
3543 int num_packed = TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg));
3544 if (num_result_args < 0)
3545 num_result_args = in_arg + num_packed;
3547 num_result_args += num_packed;
3551 if (num_result_args >= 0)
3556 /* If no expansion is necessary, we're done. */
3557 if (num_result_args < 0)
3560 /* Expand arguments. */
3561 result_args = make_tree_vec (num_result_args);
3562 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args))
3563 non_default_args_count =
3564 GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args);
3565 for (in_arg = 0; in_arg < nargs; ++in_arg)
3567 tree arg = TREE_VEC_ELT (args, in_arg);
3568 if (ARGUMENT_PACK_P (arg))
3570 tree packed = ARGUMENT_PACK_ARGS (arg);
3571 int i, num_packed = TREE_VEC_LENGTH (packed);
3572 for (i = 0; i < num_packed; ++i, ++out_arg)
3573 TREE_VEC_ELT (result_args, out_arg) = TREE_VEC_ELT(packed, i);
3574 if (non_default_args_count > 0)
3575 non_default_args_count += num_packed - 1;
3579 TREE_VEC_ELT (result_args, out_arg) = arg;
3583 if (non_default_args_count >= 0)
3584 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args, non_default_args_count);
3588 /* Checks if DECL shadows a template parameter.
3590 [temp.local]: A template-parameter shall not be redeclared within its
3591 scope (including nested scopes).
3593 Emits an error and returns TRUE if the DECL shadows a parameter,
3594 returns FALSE otherwise. */
3597 check_template_shadow (tree decl)
3601 /* If we're not in a template, we can't possibly shadow a template
3603 if (!current_template_parms)
3606 /* Figure out what we're shadowing. */
3607 if (TREE_CODE (decl) == OVERLOAD)
3608 decl = OVL_CURRENT (decl);
3609 olddecl = innermost_non_namespace_value (DECL_NAME (decl));
3611 /* If there's no previous binding for this name, we're not shadowing
3612 anything, let alone a template parameter. */
3616 /* If we're not shadowing a template parameter, we're done. Note
3617 that OLDDECL might be an OVERLOAD (or perhaps even an
3618 ERROR_MARK), so we can't just blithely assume it to be a _DECL
3620 if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
3623 /* We check for decl != olddecl to avoid bogus errors for using a
3624 name inside a class. We check TPFI to avoid duplicate errors for
3625 inline member templates. */
3627 || (DECL_TEMPLATE_PARM_P (decl)
3628 && TEMPLATE_PARMS_FOR_INLINE (current_template_parms)))
3631 /* Don't complain about the injected class name, as we've already
3632 complained about the class itself. */
3633 if (DECL_SELF_REFERENCE_P (decl))
3636 error ("declaration of %q+#D", decl);
3637 error (" shadows template parm %q+#D", olddecl);
3641 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
3642 ORIG_LEVEL, DECL, and TYPE. */
3645 build_template_parm_index (int index,
3651 tree t = make_node (TEMPLATE_PARM_INDEX);
3652 TEMPLATE_PARM_IDX (t) = index;
3653 TEMPLATE_PARM_LEVEL (t) = level;
3654 TEMPLATE_PARM_ORIG_LEVEL (t) = orig_level;
3655 TEMPLATE_PARM_DECL (t) = decl;
3656 TREE_TYPE (t) = type;
3657 TREE_CONSTANT (t) = TREE_CONSTANT (decl);
3658 TREE_READONLY (t) = TREE_READONLY (decl);
3663 /* Find the canonical type parameter for the given template type
3664 parameter. Returns the canonical type parameter, which may be TYPE
3665 if no such parameter existed. */
3668 canonical_type_parameter (tree type)
3671 int idx = TEMPLATE_TYPE_IDX (type);
3672 if (!canonical_template_parms)
3673 vec_alloc (canonical_template_parms, idx+1);
3675 while (canonical_template_parms->length () <= (unsigned)idx)
3676 vec_safe_push (canonical_template_parms, NULL_TREE);
3678 list = (*canonical_template_parms)[idx];
3679 while (list && !comptypes (type, TREE_VALUE (list), COMPARE_STRUCTURAL))
3680 list = TREE_CHAIN (list);
3683 return TREE_VALUE (list);
3686 (*canonical_template_parms)[idx]
3687 = tree_cons (NULL_TREE, type,
3688 (*canonical_template_parms)[idx]);
3693 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
3694 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
3695 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
3696 new one is created. */
3699 reduce_template_parm_level (tree index, tree type, int levels, tree args,
3700 tsubst_flags_t complain)
3702 if (TEMPLATE_PARM_DESCENDANTS (index) == NULL_TREE
3703 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index))
3704 != TEMPLATE_PARM_LEVEL (index) - levels)
3705 || !same_type_p (type, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index))))
3707 tree orig_decl = TEMPLATE_PARM_DECL (index);
3710 decl = build_decl (DECL_SOURCE_LOCATION (orig_decl),
3711 TREE_CODE (orig_decl), DECL_NAME (orig_decl), type);
3712 TREE_CONSTANT (decl) = TREE_CONSTANT (orig_decl);
3713 TREE_READONLY (decl) = TREE_READONLY (orig_decl);
3714 DECL_ARTIFICIAL (decl) = 1;
3715 SET_DECL_TEMPLATE_PARM_P (decl);
3717 t = build_template_parm_index (TEMPLATE_PARM_IDX (index),
3718 TEMPLATE_PARM_LEVEL (index) - levels,
3719 TEMPLATE_PARM_ORIG_LEVEL (index),
3721 TEMPLATE_PARM_DESCENDANTS (index) = t;
3722 TEMPLATE_PARM_PARAMETER_PACK (t)
3723 = TEMPLATE_PARM_PARAMETER_PACK (index);
3725 /* Template template parameters need this. */
3726 if (TREE_CODE (decl) == TEMPLATE_DECL)
3727 DECL_TEMPLATE_PARMS (decl) = tsubst_template_parms
3728 (DECL_TEMPLATE_PARMS (TEMPLATE_PARM_DECL (index)),
3732 return TEMPLATE_PARM_DESCENDANTS (index);
3735 /* Process information from new template parameter PARM and append it
3736 to the LIST being built. This new parameter is a non-type
3737 parameter iff IS_NON_TYPE is true. This new parameter is a
3738 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
3742 process_template_parm (tree list, location_t parm_loc, tree parm,
3743 bool is_non_type, bool is_parameter_pack)
3749 gcc_assert (TREE_CODE (parm) == TREE_LIST);
3750 defval = TREE_PURPOSE (parm);
3754 tree p = tree_last (list);
3756 if (p && TREE_VALUE (p) != error_mark_node)
3759 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
3760 idx = TEMPLATE_TYPE_IDX (TREE_TYPE (p));
3762 idx = TEMPLATE_PARM_IDX (DECL_INITIAL (p));
3770 parm = TREE_VALUE (parm);
3772 SET_DECL_TEMPLATE_PARM_P (parm);
3774 if (TREE_TYPE (parm) != error_mark_node)
3778 The top-level cv-qualifiers on the template-parameter are
3779 ignored when determining its type. */
3780 TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
3781 if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
3782 TREE_TYPE (parm) = error_mark_node;
3783 else if (uses_parameter_packs (TREE_TYPE (parm))
3784 && !is_parameter_pack
3785 /* If we're in a nested template parameter list, the template
3786 template parameter could be a parameter pack. */
3787 && processing_template_parmlist == 1)
3789 /* This template parameter is not a parameter pack, but it
3790 should be. Complain about "bare" parameter packs. */
3791 check_for_bare_parameter_packs (TREE_TYPE (parm));
3793 /* Recover by calling this a parameter pack. */
3794 is_parameter_pack = true;
3798 /* A template parameter is not modifiable. */
3799 TREE_CONSTANT (parm) = 1;
3800 TREE_READONLY (parm) = 1;
3801 decl = build_decl (parm_loc,
3802 CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
3803 TREE_CONSTANT (decl) = 1;
3804 TREE_READONLY (decl) = 1;
3805 DECL_INITIAL (parm) = DECL_INITIAL (decl)
3806 = build_template_parm_index (idx, processing_template_decl,
3807 processing_template_decl,
3808 decl, TREE_TYPE (parm));
3810 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm))
3811 = is_parameter_pack;
3816 parm = TREE_VALUE (TREE_VALUE (parm));
3818 if (parm && TREE_CODE (parm) == TEMPLATE_DECL)
3820 t = cxx_make_type (TEMPLATE_TEMPLATE_PARM);
3821 /* This is for distinguishing between real templates and template
3822 template parameters */
3823 TREE_TYPE (parm) = t;
3824 TREE_TYPE (DECL_TEMPLATE_RESULT (parm)) = t;
3829 t = cxx_make_type (TEMPLATE_TYPE_PARM);
3830 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
3831 decl = build_decl (parm_loc,
3832 TYPE_DECL, parm, t);
3835 TYPE_NAME (t) = decl;
3836 TYPE_STUB_DECL (t) = decl;
3838 TEMPLATE_TYPE_PARM_INDEX (t)
3839 = build_template_parm_index (idx, processing_template_decl,
3840 processing_template_decl,
3841 decl, TREE_TYPE (parm));
3842 TEMPLATE_TYPE_PARAMETER_PACK (t) = is_parameter_pack;
3843 TYPE_CANONICAL (t) = canonical_type_parameter (t);
3845 DECL_ARTIFICIAL (decl) = 1;
3846 SET_DECL_TEMPLATE_PARM_P (decl);
3848 parm = build_tree_list (defval, parm);
3849 return chainon (list, parm);
3852 /* The end of a template parameter list has been reached. Process the
3853 tree list into a parameter vector, converting each parameter into a more
3854 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
3858 end_template_parm_list (tree parms)
3862 tree saved_parmlist = make_tree_vec (list_length (parms));
3864 current_template_parms
3865 = tree_cons (size_int (processing_template_decl),
3866 saved_parmlist, current_template_parms);
3868 for (parm = parms, nparms = 0; parm; parm = next, nparms++)
3870 next = TREE_CHAIN (parm);
3871 TREE_VEC_ELT (saved_parmlist, nparms) = parm;
3872 TREE_CHAIN (parm) = NULL_TREE;
3875 --processing_template_parmlist;
3877 return saved_parmlist;
3880 /* end_template_decl is called after a template declaration is seen. */
3883 end_template_decl (void)
3885 reset_specialization ();
3887 if (! processing_template_decl)
3890 /* This matches the pushlevel in begin_template_parm_list. */
3893 --processing_template_decl;
3894 current_template_parms = TREE_CHAIN (current_template_parms);
3897 /* Takes a TREE_LIST representing a template parameter and convert it
3898 into an argument suitable to be passed to the type substitution
3899 functions. Note that If the TREE_LIST contains an error_mark
3900 node, the returned argument is error_mark_node. */
3903 template_parm_to_arg (tree t)
3907 || TREE_CODE (t) != TREE_LIST)
3910 if (error_operand_p (TREE_VALUE (t)))
3911 return error_mark_node;
3915 if (TREE_CODE (t) == TYPE_DECL
3916 || TREE_CODE (t) == TEMPLATE_DECL)
3920 if (TEMPLATE_TYPE_PARAMETER_PACK (t))
3922 /* Turn this argument into a TYPE_ARGUMENT_PACK
3923 with a single element, which expands T. */
3924 tree vec = make_tree_vec (1);
3925 #ifdef ENABLE_CHECKING
3926 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3927 (vec, TREE_VEC_LENGTH (vec));
3929 TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
3931 t = cxx_make_type (TYPE_ARGUMENT_PACK);
3932 SET_ARGUMENT_PACK_ARGS (t, vec);
3937 t = DECL_INITIAL (t);
3939 if (TEMPLATE_PARM_PARAMETER_PACK (t))
3941 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
3942 with a single element, which expands T. */
3943 tree vec = make_tree_vec (1);
3944 tree type = TREE_TYPE (TEMPLATE_PARM_DECL (t));
3945 #ifdef ENABLE_CHECKING
3946 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
3947 (vec, TREE_VEC_LENGTH (vec));
3949 t = convert_from_reference (t);
3950 TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
3952 t = make_node (NONTYPE_ARGUMENT_PACK);
3953 SET_ARGUMENT_PACK_ARGS (t, vec);
3954 TREE_TYPE (t) = type;
3957 t = convert_from_reference (t);
3962 /* Given a set of template parameters, return them as a set of template
3963 arguments. The template parameters are represented as a TREE_VEC, in
3964 the form documented in cp-tree.h for template arguments. */
3967 template_parms_to_args (tree parms)
3970 tree args = NULL_TREE;
3971 int length = TMPL_PARMS_DEPTH (parms);
3974 /* If there is only one level of template parameters, we do not
3975 create a TREE_VEC of TREE_VECs. Instead, we return a single
3976 TREE_VEC containing the arguments. */
3978 args = make_tree_vec (length);
3980 for (header = parms; header; header = TREE_CHAIN (header))
3982 tree a = copy_node (TREE_VALUE (header));
3985 TREE_TYPE (a) = NULL_TREE;
3986 for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
3987 TREE_VEC_ELT (a, i) = template_parm_to_arg (TREE_VEC_ELT (a, i));
3989 #ifdef ENABLE_CHECKING
3990 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a, TREE_VEC_LENGTH (a));
3994 TREE_VEC_ELT (args, --l) = a;
3999 if (length > 1 && TREE_VEC_ELT (args, 0) == NULL_TREE)
4000 /* This can happen for template parms of a template template
4003 template<template<class T, class U> class TT> struct S;
4005 Consider the level of the parms of TT; T and U both have
4006 level 2; TT has no template parm of level 1. So in this case
4007 the first element of full_template_args is NULL_TREE. If we
4008 leave it like this TMPL_ARGS_DEPTH on args returns 1 instead
4009 of 2. This will make tsubst wrongly consider that T and U
4010 have level 1. Instead, let's create a dummy vector as the
4011 first element of full_template_args so that TMPL_ARGS_DEPTH
4012 returns the correct depth for args. */
4013 TREE_VEC_ELT (args, 0) = make_tree_vec (1);
4017 /* Within the declaration of a template, return the currently active
4018 template parameters as an argument TREE_VEC. */
4021 current_template_args (void)
4023 return template_parms_to_args (current_template_parms);
4026 /* Update the declared TYPE by doing any lookups which were thought to be
4027 dependent, but are not now that we know the SCOPE of the declarator. */
4030 maybe_update_decl_type (tree orig_type, tree scope)
4032 tree type = orig_type;
4034 if (type == NULL_TREE)
4037 if (TREE_CODE (orig_type) == TYPE_DECL)
4038 type = TREE_TYPE (type);
4040 if (scope && TYPE_P (scope) && dependent_type_p (scope)
4041 && dependent_type_p (type)
4042 /* Don't bother building up the args in this case. */
4043 && TREE_CODE (type) != TEMPLATE_TYPE_PARM)
4045 /* tsubst in the args corresponding to the template parameters,
4046 including auto if present. Most things will be unchanged, but
4047 make_typename_type and tsubst_qualified_id will resolve
4048 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
4049 tree args = current_template_args ();
4050 tree auto_node = type_uses_auto (type);
4054 tree auto_vec = make_tree_vec (1);
4055 TREE_VEC_ELT (auto_vec, 0) = auto_node;
4056 args = add_to_template_args (args, auto_vec);
4058 pushed = push_scope (scope);
4059 type = tsubst (type, args, tf_warning_or_error, NULL_TREE);
4064 if (type == error_mark_node)
4067 if (TREE_CODE (orig_type) == TYPE_DECL)
4069 if (same_type_p (type, TREE_TYPE (orig_type)))
4072 type = TYPE_NAME (type);
4077 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
4078 template PARMS. If MEMBER_TEMPLATE_P is true, the new template is
4079 a member template. Used by push_template_decl below. */
4082 build_template_decl (tree decl, tree parms, bool member_template_p)
4084 tree tmpl = build_lang_decl (TEMPLATE_DECL, DECL_NAME (decl), NULL_TREE);
4085 DECL_TEMPLATE_PARMS (tmpl) = parms;
4086 DECL_CONTEXT (tmpl) = DECL_CONTEXT (decl);
4087 DECL_SOURCE_LOCATION (tmpl) = DECL_SOURCE_LOCATION (decl);
4088 DECL_MEMBER_TEMPLATE_P (tmpl) = member_template_p;
4093 struct template_parm_data
4095 /* The level of the template parameters we are currently
4099 /* The index of the specialization argument we are currently
4103 /* An array whose size is the number of template parameters. The
4104 elements are nonzero if the parameter has been used in any one
4105 of the arguments processed so far. */
4108 /* An array whose size is the number of template arguments. The
4109 elements are nonzero if the argument makes use of template
4110 parameters of this level. */
4111 int* arg_uses_template_parms;
4114 /* Subroutine of push_template_decl used to see if each template
4115 parameter in a partial specialization is used in the explicit
4116 argument list. If T is of the LEVEL given in DATA (which is
4117 treated as a template_parm_data*), then DATA->PARMS is marked
4121 mark_template_parm (tree t, void* data)
4125 struct template_parm_data* tpd = (struct template_parm_data*) data;
4127 template_parm_level_and_index (t, &level, &idx);
4129 if (level == tpd->level)
4131 tpd->parms[idx] = 1;
4132 tpd->arg_uses_template_parms[tpd->current_arg] = 1;
4135 /* Return zero so that for_each_template_parm will continue the
4136 traversal of the tree; we want to mark *every* template parm. */
4140 /* Process the partial specialization DECL. */
4143 process_partial_specialization (tree decl)
4145 tree type = TREE_TYPE (decl);
4146 tree tinfo = get_template_info (decl);
4147 tree maintmpl = TI_TEMPLATE (tinfo);
4148 tree specargs = TI_ARGS (tinfo);
4149 tree inner_args = INNERMOST_TEMPLATE_ARGS (specargs);
4150 tree main_inner_parms = DECL_INNERMOST_TEMPLATE_PARMS (maintmpl);
4153 int nargs = TREE_VEC_LENGTH (inner_args);
4156 bool did_error_intro = false;
4157 struct template_parm_data tpd;
4158 struct template_parm_data tpd2;
4160 gcc_assert (current_template_parms);
4162 inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
4163 ntparms = TREE_VEC_LENGTH (inner_parms);
4165 /* We check that each of the template parameters given in the
4166 partial specialization is used in the argument list to the
4167 specialization. For example:
4169 template <class T> struct S;
4170 template <class T> struct S<T*>;
4172 The second declaration is OK because `T*' uses the template
4173 parameter T, whereas
4175 template <class T> struct S<int>;
4177 is no good. Even trickier is:
4188 The S2<T> declaration is actually invalid; it is a
4189 full-specialization. Of course,
4192 struct S2<T (*)(U)>;
4194 or some such would have been OK. */
4195 tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
4196 tpd.parms = XALLOCAVEC (int, ntparms);
4197 memset (tpd.parms, 0, sizeof (int) * ntparms);
4199 tpd.arg_uses_template_parms = XALLOCAVEC (int, nargs);
4200 memset (tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
4201 for (i = 0; i < nargs; ++i)
4203 tpd.current_arg = i;
4204 for_each_template_parm (TREE_VEC_ELT (inner_args, i),
4205 &mark_template_parm,
4208 /*include_nondeduced_p=*/false);
4210 for (i = 0; i < ntparms; ++i)
4211 if (tpd.parms[i] == 0)
4213 /* One of the template parms was not used in a deduced context in the
4215 if (!did_error_intro)
4217 error ("template parameters not deducible in "
4218 "partial specialization:");
4219 did_error_intro = true;
4222 inform (input_location, " %qD",
4223 TREE_VALUE (TREE_VEC_ELT (inner_parms, i)));
4226 if (did_error_intro)
4227 return error_mark_node;
4229 /* [temp.class.spec]
4231 The argument list of the specialization shall not be identical to
4232 the implicit argument list of the primary template. */
4234 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (maintmpl)));
4235 if (comp_template_args (inner_args, INNERMOST_TEMPLATE_ARGS (main_args)))
4236 error ("partial specialization %qD does not specialize "
4237 "any template arguments", decl);
4239 /* A partial specialization that replaces multiple parameters of the
4240 primary template with a pack expansion is less specialized for those
4242 if (nargs < DECL_NTPARMS (maintmpl))
4244 error ("partial specialization is not more specialized than the "
4245 "primary template because it replaces multiple parameters "
4246 "with a pack expansion");
4247 inform (DECL_SOURCE_LOCATION (maintmpl), "primary template here");
4251 /* [temp.class.spec]
4253 A partially specialized non-type argument expression shall not
4254 involve template parameters of the partial specialization except
4255 when the argument expression is a simple identifier.
4257 The type of a template parameter corresponding to a specialized
4258 non-type argument shall not be dependent on a parameter of the
4261 Also, we verify that pack expansions only occur at the
4262 end of the argument list. */
4263 gcc_assert (nargs == DECL_NTPARMS (maintmpl));
4265 for (i = 0; i < nargs; ++i)
4267 tree parm = TREE_VALUE (TREE_VEC_ELT (main_inner_parms, i));
4268 tree arg = TREE_VEC_ELT (inner_args, i);
4269 tree packed_args = NULL_TREE;
4272 if (ARGUMENT_PACK_P (arg))
4274 /* Extract the arguments from the argument pack. We'll be
4275 iterating over these in the following loop. */
4276 packed_args = ARGUMENT_PACK_ARGS (arg);
4277 len = TREE_VEC_LENGTH (packed_args);
4280 for (j = 0; j < len; j++)
4283 /* Get the Jth argument in the parameter pack. */
4284 arg = TREE_VEC_ELT (packed_args, j);
4286 if (PACK_EXPANSION_P (arg))
4288 /* Pack expansions must come at the end of the
4290 if ((packed_args && j < len - 1)
4291 || (!packed_args && i < nargs - 1))
4293 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
4294 error ("parameter pack argument %qE must be at the "
4295 "end of the template argument list", arg);
4297 error ("parameter pack argument %qT must be at the "
4298 "end of the template argument list", arg);
4302 if (TREE_CODE (arg) == EXPR_PACK_EXPANSION)
4303 /* We only care about the pattern. */
4304 arg = PACK_EXPANSION_PATTERN (arg);
4306 if (/* These first two lines are the `non-type' bit. */
4308 && TREE_CODE (arg) != TEMPLATE_DECL
4309 /* This next two lines are the `argument expression is not just a
4310 simple identifier' condition and also the `specialized
4311 non-type argument' bit. */
4312 && TREE_CODE (arg) != TEMPLATE_PARM_INDEX
4313 && !(REFERENCE_REF_P (arg)
4314 && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_PARM_INDEX))
4316 if ((!packed_args && tpd.arg_uses_template_parms[i])
4317 || (packed_args && uses_template_parms (arg)))
4318 error ("template argument %qE involves template parameter(s)",
4322 /* Look at the corresponding template parameter,
4323 marking which template parameters its type depends
4325 tree type = TREE_TYPE (parm);
4329 /* We haven't yet initialized TPD2. Do so now. */
4330 tpd2.arg_uses_template_parms = XALLOCAVEC (int, nargs);
4331 /* The number of parameters here is the number in the
4332 main template, which, as checked in the assertion
4334 tpd2.parms = XALLOCAVEC (int, nargs);
4336 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl));
4339 /* Mark the template parameters. But this time, we're
4340 looking for the template parameters of the main
4341 template, not in the specialization. */
4342 tpd2.current_arg = i;
4343 tpd2.arg_uses_template_parms[i] = 0;
4344 memset (tpd2.parms, 0, sizeof (int) * nargs);
4345 for_each_template_parm (type,
4346 &mark_template_parm,
4349 /*include_nondeduced_p=*/false);
4351 if (tpd2.arg_uses_template_parms [i])
4353 /* The type depended on some template parameters.
4354 If they are fully specialized in the
4355 specialization, that's OK. */
4358 for (j = 0; j < nargs; ++j)
4359 if (tpd2.parms[j] != 0
4360 && tpd.arg_uses_template_parms [j])
4363 error_n (input_location, count,
4364 "type %qT of template argument %qE depends "
4365 "on a template parameter",
4366 "type %qT of template argument %qE depends "
4367 "on template parameters",
4376 /* We should only get here once. */
4377 if (TREE_CODE (decl) == TYPE_DECL)
4378 gcc_assert (!COMPLETE_TYPE_P (type));
4380 tree tmpl = build_template_decl (decl, current_template_parms,
4381 DECL_MEMBER_TEMPLATE_P (maintmpl));
4382 TREE_TYPE (tmpl) = type;
4383 DECL_TEMPLATE_RESULT (tmpl) = decl;
4384 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
4385 DECL_TEMPLATE_INFO (tmpl) = build_template_info (maintmpl, specargs);
4386 DECL_PRIMARY_TEMPLATE (tmpl) = maintmpl;
4388 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)
4389 = tree_cons (specargs, tmpl,
4390 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl));
4391 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl)) = type;
4393 for (inst = DECL_TEMPLATE_INSTANTIATIONS (maintmpl); inst;
4394 inst = TREE_CHAIN (inst))
4396 tree instance = TREE_VALUE (inst);
4397 if (TYPE_P (instance)
4398 ? (COMPLETE_TYPE_P (instance)
4399 && CLASSTYPE_IMPLICIT_INSTANTIATION (instance))
4400 : DECL_TEMPLATE_INSTANTIATION (instance))
4402 tree spec = most_specialized_partial_spec (instance, tf_none);
4403 if (spec && TREE_VALUE (spec) == tmpl)
4405 tree inst_decl = (DECL_P (instance)
4406 ? instance : TYPE_NAME (instance));
4407 permerror (input_location,
4408 "partial specialization of %qD after instantiation "
4409 "of %qD", decl, inst_decl);
4417 /* PARM is a template parameter of some form; return the corresponding
4418 TEMPLATE_PARM_INDEX. */
4421 get_template_parm_index (tree parm)
4423 if (TREE_CODE (parm) == PARM_DECL
4424 || TREE_CODE (parm) == CONST_DECL)
4425 parm = DECL_INITIAL (parm);
4426 else if (TREE_CODE (parm) == TYPE_DECL
4427 || TREE_CODE (parm) == TEMPLATE_DECL)
4428 parm = TREE_TYPE (parm);
4429 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
4430 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM
4431 || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM)
4432 parm = TEMPLATE_TYPE_PARM_INDEX (parm);
4433 gcc_assert (TREE_CODE (parm) == TEMPLATE_PARM_INDEX);
4437 /* Subroutine of fixed_parameter_pack_p below. Look for any template
4438 parameter packs used by the template parameter PARM. */
4441 fixed_parameter_pack_p_1 (tree parm, struct find_parameter_pack_data *ppd)
4443 /* A type parm can't refer to another parm. */
4444 if (TREE_CODE (parm) == TYPE_DECL)
4446 else if (TREE_CODE (parm) == PARM_DECL)
4448 cp_walk_tree (&TREE_TYPE (parm), &find_parameter_packs_r,
4453 gcc_assert (TREE_CODE (parm) == TEMPLATE_DECL);
4455 tree vec = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (parm));
4456 for (int i = 0; i < TREE_VEC_LENGTH (vec); ++i)
4457 fixed_parameter_pack_p_1 (TREE_VALUE (TREE_VEC_ELT (vec, i)), ppd);
4460 /* PARM is a template parameter pack. Return any parameter packs used in
4461 its type or the type of any of its template parameters. If there are
4462 any such packs, it will be instantiated into a fixed template parameter
4463 list by partial instantiation rather than be fully deduced. */
4466 fixed_parameter_pack_p (tree parm)
4468 /* This can only be true in a member template. */
4469 if (TEMPLATE_PARM_ORIG_LEVEL (get_template_parm_index (parm)) < 2)
4471 /* This can only be true for a parameter pack. */
4472 if (!template_parameter_pack_p (parm))
4474 /* A type parm can't refer to another parm. */
4475 if (TREE_CODE (parm) == TYPE_DECL)
4478 tree parameter_packs = NULL_TREE;
4479 struct find_parameter_pack_data ppd;
4480 ppd.parameter_packs = ¶meter_packs;
4481 ppd.visited = new hash_set<tree>;
4483 fixed_parameter_pack_p_1 (parm, &ppd);
4486 return parameter_packs;
4489 /* Check that a template declaration's use of default arguments and
4490 parameter packs is not invalid. Here, PARMS are the template
4491 parameters. IS_PRIMARY is true if DECL is the thing declared by
4492 a primary template. IS_PARTIAL is true if DECL is a partial
4495 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4496 declaration (but not a definition); 1 indicates a declaration, 2
4497 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4498 emitted for extraneous default arguments.
4500 Returns TRUE if there were no errors found, FALSE otherwise. */
4503 check_default_tmpl_args (tree decl, tree parms, bool is_primary,
4504 bool is_partial, int is_friend_decl)
4507 int last_level_to_check;
4509 bool no_errors = true;
4513 A default template-argument shall not be specified in a
4514 function template declaration or a function template definition, nor
4515 in the template-parameter-list of the definition of a member of a
4518 if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL
4519 || (TREE_CODE (decl) == FUNCTION_DECL && DECL_LOCAL_FUNCTION_P (decl)))
4520 /* You can't have a function template declaration in a local
4521 scope, nor you can you define a member of a class template in a
4525 if ((TREE_CODE (decl) == TYPE_DECL
4527 && LAMBDA_TYPE_P (TREE_TYPE (decl)))
4528 || (TREE_CODE (decl) == FUNCTION_DECL
4529 && LAMBDA_FUNCTION_P (decl)))
4530 /* A lambda doesn't have an explicit declaration; don't complain
4531 about the parms of the enclosing class. */
4534 if (current_class_type
4535 && !TYPE_BEING_DEFINED (current_class_type)
4536 && DECL_LANG_SPECIFIC (decl)
4537 && DECL_DECLARES_FUNCTION_P (decl)
4538 /* If this is either a friend defined in the scope of the class
4539 or a member function. */
4540 && (DECL_FUNCTION_MEMBER_P (decl)
4541 ? same_type_p (DECL_CONTEXT (decl), current_class_type)
4542 : DECL_FRIEND_CONTEXT (decl)
4543 ? same_type_p (DECL_FRIEND_CONTEXT (decl), current_class_type)
4545 /* And, if it was a member function, it really was defined in
4546 the scope of the class. */
4547 && (!DECL_FUNCTION_MEMBER_P (decl)
4548 || DECL_INITIALIZED_IN_CLASS_P (decl)))
4549 /* We already checked these parameters when the template was
4550 declared, so there's no need to do it again now. This function
4551 was defined in class scope, but we're processing its body now
4552 that the class is complete. */
4555 /* Core issue 226 (C++0x only): the following only applies to class
4558 && ((cxx_dialect == cxx98) || TREE_CODE (decl) != FUNCTION_DECL))
4562 If a template-parameter has a default template-argument, all
4563 subsequent template-parameters shall have a default
4564 template-argument supplied. */
4565 for (parm_level = parms; parm_level; parm_level = TREE_CHAIN (parm_level))
4567 tree inner_parms = TREE_VALUE (parm_level);
4568 int ntparms = TREE_VEC_LENGTH (inner_parms);
4569 int seen_def_arg_p = 0;
4572 for (i = 0; i < ntparms; ++i)
4574 tree parm = TREE_VEC_ELT (inner_parms, i);
4576 if (parm == error_mark_node)
4579 if (TREE_PURPOSE (parm))
4581 else if (seen_def_arg_p
4582 && !template_parameter_pack_p (TREE_VALUE (parm)))
4584 error ("no default argument for %qD", TREE_VALUE (parm));
4585 /* For better subsequent error-recovery, we indicate that
4586 there should have been a default argument. */
4587 TREE_PURPOSE (parm) = error_mark_node;
4590 else if (!is_partial
4592 /* Don't complain about an enclosing partial
4594 && parm_level == parms
4595 && TREE_CODE (decl) == TYPE_DECL
4597 && template_parameter_pack_p (TREE_VALUE (parm))
4598 /* A fixed parameter pack will be partially
4599 instantiated into a fixed length list. */
4600 && !fixed_parameter_pack_p (TREE_VALUE (parm)))
4602 /* A primary class template can only have one
4603 parameter pack, at the end of the template
4606 error ("parameter pack %q+D must be at the end of the"
4607 " template parameter list", TREE_VALUE (parm));
4609 TREE_VALUE (TREE_VEC_ELT (inner_parms, i))
4617 if (((cxx_dialect == cxx98) && TREE_CODE (decl) != TYPE_DECL)
4621 /* For an ordinary class template, default template arguments are
4622 allowed at the innermost level, e.g.:
4623 template <class T = int>
4625 but, in a partial specialization, they're not allowed even
4626 there, as we have in [temp.class.spec]:
4628 The template parameter list of a specialization shall not
4629 contain default template argument values.
4631 So, for a partial specialization, or for a function template
4632 (in C++98/C++03), we look at all of them. */
4635 /* But, for a primary class template that is not a partial
4636 specialization we look at all template parameters except the
4638 parms = TREE_CHAIN (parms);
4640 /* Figure out what error message to issue. */
4641 if (is_friend_decl == 2)
4642 msg = G_("default template arguments may not be used in function template "
4643 "friend re-declaration");
4644 else if (is_friend_decl)
4645 msg = G_("default template arguments may not be used in function template "
4646 "friend declarations");
4647 else if (TREE_CODE (decl) == FUNCTION_DECL && (cxx_dialect == cxx98))
4648 msg = G_("default template arguments may not be used in function templates "
4649 "without -std=c++11 or -std=gnu++11");
4650 else if (is_partial)
4651 msg = G_("default template arguments may not be used in "
4652 "partial specializations");
4654 msg = G_("default argument for template parameter for class enclosing %qD");
4656 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
4657 /* If we're inside a class definition, there's no need to
4658 examine the parameters to the class itself. On the one
4659 hand, they will be checked when the class is defined, and,
4660 on the other, default arguments are valid in things like:
4661 template <class T = double>
4662 struct S { template <class U> void f(U); };
4663 Here the default argument for `S' has no bearing on the
4664 declaration of `f'. */
4665 last_level_to_check = template_class_depth (current_class_type) + 1;
4667 /* Check everything. */
4668 last_level_to_check = 0;
4670 for (parm_level = parms;
4671 parm_level && TMPL_PARMS_DEPTH (parm_level) >= last_level_to_check;
4672 parm_level = TREE_CHAIN (parm_level))
4674 tree inner_parms = TREE_VALUE (parm_level);
4678 ntparms = TREE_VEC_LENGTH (inner_parms);
4679 for (i = 0; i < ntparms; ++i)
4681 if (TREE_VEC_ELT (inner_parms, i) == error_mark_node)
4684 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)))
4689 if (is_friend_decl == 2)
4696 /* Clear out the default argument so that we are not
4698 TREE_PURPOSE (TREE_VEC_ELT (inner_parms, i)) = NULL_TREE;
4702 /* At this point, if we're still interested in issuing messages,
4703 they must apply to classes surrounding the object declared. */
4705 msg = G_("default argument for template parameter for class "
4712 /* Worker for push_template_decl_real, called via
4713 for_each_template_parm. DATA is really an int, indicating the
4714 level of the parameters we are interested in. If T is a template
4715 parameter of that level, return nonzero. */
4718 template_parm_this_level_p (tree t, void* data)
4720 int this_level = *(int *)data;
4723 if (TREE_CODE (t) == TEMPLATE_PARM_INDEX)
4724 level = TEMPLATE_PARM_LEVEL (t);
4726 level = TEMPLATE_TYPE_LEVEL (t);
4727 return level == this_level;
4730 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
4731 parameters given by current_template_args, or reuses a
4732 previously existing one, if appropriate. Returns the DECL, or an
4733 equivalent one, if it is replaced via a call to duplicate_decls.
4735 If IS_FRIEND is true, DECL is a friend declaration. */
4738 push_template_decl_real (tree decl, bool is_friend)
4746 int new_template_p = 0;
4747 /* True if the template is a member template, in the sense of
4749 bool member_template_p = false;
4751 if (decl == error_mark_node || !current_template_parms)
4752 return error_mark_node;
4754 /* See if this is a partial specialization. */
4755 is_partial = ((DECL_IMPLICIT_TYPEDEF_P (decl)
4756 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
4757 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
4758 || (TREE_CODE (decl) == VAR_DECL
4759 && DECL_LANG_SPECIFIC (decl)
4760 && DECL_TEMPLATE_SPECIALIZATION (decl)
4761 && TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl))));
4763 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl))
4767 /* For a friend, we want the context of the friend function, not
4768 the type of which it is a friend. */
4769 ctx = CP_DECL_CONTEXT (decl);
4770 else if (CP_DECL_CONTEXT (decl)
4771 && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4772 /* In the case of a virtual function, we want the class in which
4774 ctx = CP_DECL_CONTEXT (decl);
4776 /* Otherwise, if we're currently defining some class, the DECL
4777 is assumed to be a member of the class. */
4778 ctx = current_scope ();
4780 if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
4783 if (!DECL_CONTEXT (decl))
4784 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
4786 /* See if this is a primary template. */
4787 if (is_friend && ctx
4788 && uses_template_parms_level (ctx, processing_template_decl))
4789 /* A friend template that specifies a class context, i.e.
4790 template <typename T> friend void A<T>::f();
4793 else if (TREE_CODE (decl) == TYPE_DECL
4794 && LAMBDA_TYPE_P (TREE_TYPE (decl)))
4797 is_primary = template_parm_scope_p ();
4801 if (DECL_CLASS_SCOPE_P (decl))
4802 member_template_p = true;
4803 if (TREE_CODE (decl) == TYPE_DECL
4804 && ANON_AGGRNAME_P (DECL_NAME (decl)))
4806 error ("template class without a name");
4807 return error_mark_node;
4809 else if (TREE_CODE (decl) == FUNCTION_DECL)
4811 if (member_template_p)
4813 if (DECL_OVERRIDE_P (decl) || DECL_FINAL_P (decl))
4814 error ("member template %qD may not have virt-specifiers", decl);
4816 if (DECL_DESTRUCTOR_P (decl))
4820 A destructor shall not be a member template. */
4821 error ("destructor %qD declared as member template", decl);
4822 return error_mark_node;
4824 if (NEW_DELETE_OPNAME_P (DECL_NAME (decl))
4825 && (!prototype_p (TREE_TYPE (decl))
4826 || TYPE_ARG_TYPES (TREE_TYPE (decl)) == void_list_node
4827 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
4828 || (TREE_CHAIN (TYPE_ARG_TYPES ((TREE_TYPE (decl))))
4829 == void_list_node)))
4831 /* [basic.stc.dynamic.allocation]
4833 An allocation function can be a function
4834 template. ... Template allocation functions shall
4835 have two or more parameters. */
4836 error ("invalid template declaration of %qD", decl);
4837 return error_mark_node;
4840 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
4841 && CLASS_TYPE_P (TREE_TYPE (decl)))
4843 else if (TREE_CODE (decl) == TYPE_DECL
4844 && TYPE_DECL_ALIAS_P (decl))
4845 /* alias-declaration */
4846 gcc_assert (!DECL_ARTIFICIAL (decl));
4847 else if (VAR_P (decl))
4848 /* C++14 variable template. */;
4851 error ("template declaration of %q#D", decl);
4852 return error_mark_node;
4856 /* Check to see that the rules regarding the use of default
4857 arguments are not being violated. */
4858 check_default_tmpl_args (decl, current_template_parms,
4859 is_primary, is_partial, /*is_friend_decl=*/0);
4861 /* Ensure that there are no parameter packs in the type of this
4862 declaration that have not been expanded. */
4863 if (TREE_CODE (decl) == FUNCTION_DECL)
4865 /* Check each of the arguments individually to see if there are
4866 any bare parameter packs. */
4867 tree type = TREE_TYPE (decl);
4868 tree arg = DECL_ARGUMENTS (decl);
4869 tree argtype = TYPE_ARG_TYPES (type);
4871 while (arg && argtype)
4873 if (!DECL_PACK_P (arg)
4874 && check_for_bare_parameter_packs (TREE_TYPE (arg)))
4876 /* This is a PARM_DECL that contains unexpanded parameter
4877 packs. We have already complained about this in the
4878 check_for_bare_parameter_packs call, so just replace
4879 these types with ERROR_MARK_NODE. */
4880 TREE_TYPE (arg) = error_mark_node;
4881 TREE_VALUE (argtype) = error_mark_node;
4884 arg = DECL_CHAIN (arg);
4885 argtype = TREE_CHAIN (argtype);
4888 /* Check for bare parameter packs in the return type and the
4889 exception specifiers. */
4890 if (check_for_bare_parameter_packs (TREE_TYPE (type)))
4891 /* Errors were already issued, set return type to int
4892 as the frontend doesn't expect error_mark_node as
4894 TREE_TYPE (type) = integer_type_node;
4895 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type)))
4896 TYPE_RAISES_EXCEPTIONS (type) = NULL_TREE;
4898 else if (check_for_bare_parameter_packs ((TREE_CODE (decl) == TYPE_DECL
4899 && TYPE_DECL_ALIAS_P (decl))
4900 ? DECL_ORIGINAL_TYPE (decl)
4901 : TREE_TYPE (decl)))
4903 TREE_TYPE (decl) = error_mark_node;
4904 return error_mark_node;
4908 return process_partial_specialization (decl);
4910 args = current_template_args ();
4913 || TREE_CODE (ctx) == FUNCTION_DECL
4914 || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
4915 || (TREE_CODE (decl) == TYPE_DECL
4916 && LAMBDA_TYPE_P (TREE_TYPE (decl)))
4917 || (is_friend && !DECL_TEMPLATE_INFO (decl)))
4919 if (DECL_LANG_SPECIFIC (decl)
4920 && DECL_TEMPLATE_INFO (decl)
4921 && DECL_TI_TEMPLATE (decl))
4922 tmpl = DECL_TI_TEMPLATE (decl);
4923 /* If DECL is a TYPE_DECL for a class-template, then there won't
4924 be DECL_LANG_SPECIFIC. The information equivalent to
4925 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
4926 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
4927 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
4928 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
4930 /* Since a template declaration already existed for this
4931 class-type, we must be redeclaring it here. Make sure
4932 that the redeclaration is valid. */
4933 redeclare_class_template (TREE_TYPE (decl),
4934 current_template_parms);
4935 /* We don't need to create a new TEMPLATE_DECL; just use the
4936 one we already had. */
4937 tmpl = TYPE_TI_TEMPLATE (TREE_TYPE (decl));
4941 tmpl = build_template_decl (decl, current_template_parms,
4945 if (DECL_LANG_SPECIFIC (decl)
4946 && DECL_TEMPLATE_SPECIALIZATION (decl))
4948 /* A specialization of a member template of a template
4950 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
4951 DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
4952 DECL_TEMPLATE_INFO (decl) = NULL_TREE;
4958 tree a, t, current, parms;
4960 tree tinfo = get_template_info (decl);
4964 error ("template definition of non-template %q#D", decl);
4965 return error_mark_node;
4968 tmpl = TI_TEMPLATE (tinfo);
4970 if (DECL_FUNCTION_TEMPLATE_P (tmpl)
4971 && DECL_TEMPLATE_INFO (decl) && DECL_TI_ARGS (decl)
4972 && DECL_TEMPLATE_SPECIALIZATION (decl)
4973 && DECL_MEMBER_TEMPLATE_P (tmpl))
4977 /* The declaration is a specialization of a member
4978 template, declared outside the class. Therefore, the
4979 innermost template arguments will be NULL, so we
4980 replace them with the arguments determined by the
4981 earlier call to check_explicit_specialization. */
4982 args = DECL_TI_ARGS (decl);
4985 = build_template_decl (decl, current_template_parms,
4987 DECL_TEMPLATE_RESULT (new_tmpl) = decl;
4988 TREE_TYPE (new_tmpl) = TREE_TYPE (decl);
4989 DECL_TI_TEMPLATE (decl) = new_tmpl;
4990 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl);
4991 DECL_TEMPLATE_INFO (new_tmpl)
4992 = build_template_info (tmpl, args);
4994 register_specialization (new_tmpl,
4995 most_general_template (tmpl),
5001 /* Make sure the template headers we got make sense. */
5003 parms = DECL_TEMPLATE_PARMS (tmpl);
5004 i = TMPL_PARMS_DEPTH (parms);
5005 if (TMPL_ARGS_DEPTH (args) != i)
5007 error ("expected %d levels of template parms for %q#D, got %d",
5008 i, decl, TMPL_ARGS_DEPTH (args));
5009 DECL_INTERFACE_KNOWN (decl) = 1;
5010 return error_mark_node;
5013 for (current = decl; i > 0; --i, parms = TREE_CHAIN (parms))
5015 a = TMPL_ARGS_LEVEL (args, i);
5016 t = INNERMOST_TEMPLATE_PARMS (parms);
5018 if (TREE_VEC_LENGTH (t) != TREE_VEC_LENGTH (a))
5020 if (current == decl)
5021 error ("got %d template parameters for %q#D",
5022 TREE_VEC_LENGTH (a), decl);
5024 error ("got %d template parameters for %q#T",
5025 TREE_VEC_LENGTH (a), current);
5026 error (" but %d required", TREE_VEC_LENGTH (t));
5027 /* Avoid crash in import_export_decl. */
5028 DECL_INTERFACE_KNOWN (decl) = 1;
5029 return error_mark_node;
5032 if (current == decl)
5034 else if (current == NULL_TREE)
5035 /* Can happen in erroneous input. */
5038 current = get_containing_scope (current);
5041 /* Check that the parms are used in the appropriate qualifying scopes
5042 in the declarator. */
5043 if (!comp_template_args
5045 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl)))))
5048 template arguments to %qD do not match original template %qD",
5049 decl, DECL_TEMPLATE_RESULT (tmpl));
5050 if (!uses_template_parms (TI_ARGS (tinfo)))
5051 inform (input_location, "use template<> for an explicit specialization");
5052 /* Avoid crash in import_export_decl. */
5053 DECL_INTERFACE_KNOWN (decl) = 1;
5054 return error_mark_node;
5058 DECL_TEMPLATE_RESULT (tmpl) = decl;
5059 TREE_TYPE (tmpl) = TREE_TYPE (decl);
5061 /* Push template declarations for global functions and types. Note
5062 that we do not try to push a global template friend declared in a
5063 template class; such a thing may well depend on the template
5064 parameters of the class. */
5065 if (new_template_p && !ctx
5066 && !(is_friend && template_class_depth (current_class_type) > 0))
5068 tmpl = pushdecl_namespace_level (tmpl, is_friend);
5069 if (tmpl == error_mark_node)
5070 return error_mark_node;
5072 /* Hide template friend classes that haven't been declared yet. */
5073 if (is_friend && TREE_CODE (decl) == TYPE_DECL)
5075 DECL_ANTICIPATED (tmpl) = 1;
5076 DECL_FRIEND_P (tmpl) = 1;
5082 tree parms = DECL_TEMPLATE_PARMS (tmpl);
5085 DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
5086 if (DECL_CONV_FN_P (tmpl))
5088 int depth = TMPL_PARMS_DEPTH (parms);
5090 /* It is a conversion operator. See if the type converted to
5091 depends on innermost template operands. */
5093 if (uses_template_parms_level (TREE_TYPE (TREE_TYPE (tmpl)),
5095 DECL_TEMPLATE_CONV_FN_P (tmpl) = 1;
5098 /* Give template template parms a DECL_CONTEXT of the template
5099 for which they are a parameter. */
5100 parms = INNERMOST_TEMPLATE_PARMS (parms);
5101 for (i = TREE_VEC_LENGTH (parms) - 1; i >= 0; --i)
5103 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
5104 if (TREE_CODE (parm) == TEMPLATE_DECL)
5105 DECL_CONTEXT (parm) = tmpl;
5108 if (TREE_CODE (decl) == TYPE_DECL
5109 && TYPE_DECL_ALIAS_P (decl)
5110 && complex_alias_template_p (tmpl))
5111 TEMPLATE_DECL_COMPLEX_ALIAS_P (tmpl) = true;
5114 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5115 back to its most general template. If TMPL is a specialization,
5116 ARGS may only have the innermost set of arguments. Add the missing
5117 argument levels if necessary. */
5118 if (DECL_TEMPLATE_INFO (tmpl))
5119 args = add_outermost_template_args (DECL_TI_ARGS (tmpl), args);
5121 info = build_template_info (tmpl, args);
5123 if (DECL_IMPLICIT_TYPEDEF_P (decl))
5124 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl), info);
5127 if (is_primary && !DECL_LANG_SPECIFIC (decl))
5128 retrofit_lang_decl (decl);
5129 if (DECL_LANG_SPECIFIC (decl))
5130 DECL_TEMPLATE_INFO (decl) = info;
5133 if (flag_implicit_templates
5135 && TREE_PUBLIC (decl)
5136 && VAR_OR_FUNCTION_DECL_P (decl))
5137 /* Set DECL_COMDAT on template instantiations; if we force
5138 them to be emitted by explicit instantiation or -frepo,
5139 mark_needed will tell cgraph to do the right thing. */
5140 DECL_COMDAT (decl) = true;
5142 return DECL_TEMPLATE_RESULT (tmpl);
5146 push_template_decl (tree decl)
5148 return push_template_decl_real (decl, false);
5151 /* FN is an inheriting constructor that inherits from the constructor
5152 template INHERITED; turn FN into a constructor template with a matching
5156 add_inherited_template_parms (tree fn, tree inherited)
5159 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited));
5160 inner_parms = copy_node (inner_parms);
5162 = tree_cons (size_int (processing_template_decl + 1),
5163 inner_parms, current_template_parms);
5164 tree tmpl = build_template_decl (fn, parms, /*member*/true);
5165 tree args = template_parms_to_args (parms);
5166 DECL_TEMPLATE_INFO (fn) = build_template_info (tmpl, args);
5167 TREE_TYPE (tmpl) = TREE_TYPE (fn);
5168 DECL_TEMPLATE_RESULT (tmpl) = fn;
5169 DECL_ARTIFICIAL (tmpl) = true;
5170 DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
5174 /* Called when a class template TYPE is redeclared with the indicated
5175 template PARMS, e.g.:
5177 template <class T> struct S;
5178 template <class T> struct S {}; */
5181 redeclare_class_template (tree type, tree parms)
5187 if (!TYPE_TEMPLATE_INFO (type))
5189 error ("%qT is not a template type", type);
5193 tmpl = TYPE_TI_TEMPLATE (type);
5194 if (!PRIMARY_TEMPLATE_P (tmpl))
5195 /* The type is nested in some template class. Nothing to worry
5196 about here; there are no new template parameters for the nested
5202 error ("template specifiers not specified in declaration of %qD",
5207 parms = INNERMOST_TEMPLATE_PARMS (parms);
5208 tmpl_parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
5210 if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms))
5212 error_n (input_location, TREE_VEC_LENGTH (parms),
5213 "redeclared with %d template parameter",
5214 "redeclared with %d template parameters",
5215 TREE_VEC_LENGTH (parms));
5216 inform_n (input_location, TREE_VEC_LENGTH (tmpl_parms),
5217 "previous declaration %q+D used %d template parameter",
5218 "previous declaration %q+D used %d template parameters",
5219 tmpl, TREE_VEC_LENGTH (tmpl_parms));
5223 for (i = 0; i < TREE_VEC_LENGTH (tmpl_parms); ++i)
5230 if (TREE_VEC_ELT (tmpl_parms, i) == error_mark_node
5231 || TREE_VEC_ELT (parms, i) == error_mark_node)
5234 tmpl_parm = TREE_VALUE (TREE_VEC_ELT (tmpl_parms, i));
5235 if (error_operand_p (tmpl_parm))
5238 parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
5239 tmpl_default = TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i));
5240 parm_default = TREE_PURPOSE (TREE_VEC_ELT (parms, i));
5242 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5244 if (TREE_CODE (tmpl_parm) != TREE_CODE (parm)
5245 || (TREE_CODE (tmpl_parm) != TYPE_DECL
5246 && !same_type_p (TREE_TYPE (tmpl_parm), TREE_TYPE (parm)))
5247 || (TREE_CODE (tmpl_parm) != PARM_DECL
5248 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm))
5249 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm))))
5250 || (TREE_CODE (tmpl_parm) == PARM_DECL
5251 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm))
5252 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))))
5254 error ("template parameter %q+#D", tmpl_parm);
5255 error ("redeclared here as %q#D", parm);
5259 if (tmpl_default != NULL_TREE && parm_default != NULL_TREE)
5261 /* We have in [temp.param]:
5263 A template-parameter may not be given default arguments
5264 by two different declarations in the same scope. */
5265 error_at (input_location, "redefinition of default argument for %q#D", parm);
5266 inform (DECL_SOURCE_LOCATION (tmpl_parm),
5267 "original definition appeared here");
5271 if (parm_default != NULL_TREE)
5272 /* Update the previous template parameters (which are the ones
5273 that will really count) with the new default value. */
5274 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms, i)) = parm_default;
5275 else if (tmpl_default != NULL_TREE)
5276 /* Update the new parameters, too; they'll be used as the
5277 parameters for any members. */
5278 TREE_PURPOSE (TREE_VEC_ELT (parms, i)) = tmpl_default;
5284 /* The actual substitution part of instantiate_non_dependent_expr_sfinae,
5285 to be used when the caller has already checked
5286 (processing_template_decl
5287 && !instantiation_dependent_expression_p (expr)
5288 && potential_constant_expression (expr))
5289 and cleared processing_template_decl. */
5292 instantiate_non_dependent_expr_internal (tree expr, tsubst_flags_t complain)
5294 return tsubst_copy_and_build (expr,
5297 /*in_decl=*/NULL_TREE,
5298 /*function_p=*/false,
5299 /*integral_constant_expression_p=*/true);
5302 /* Simplify EXPR if it is a non-dependent expression. Returns the
5303 (possibly simplified) expression. */
5306 instantiate_non_dependent_expr_sfinae (tree expr, tsubst_flags_t complain)
5308 if (expr == NULL_TREE)
5311 /* If we're in a template, but EXPR isn't value dependent, simplify
5312 it. We're supposed to treat:
5314 template <typename T> void f(T[1 + 1]);
5315 template <typename T> void f(T[2]);
5317 as two declarations of the same function, for example. */
5318 if (processing_template_decl
5319 && !instantiation_dependent_expression_p (expr)
5320 && potential_constant_expression (expr))
5322 processing_template_decl_sentinel s;
5323 expr = instantiate_non_dependent_expr_internal (expr, complain);
5329 instantiate_non_dependent_expr (tree expr)
5331 return instantiate_non_dependent_expr_sfinae (expr, tf_error);
5334 /* True iff T is a specialization of a variable template. */
5337 variable_template_specialization_p (tree t)
5339 if (!VAR_P (t) || !DECL_LANG_SPECIFIC (t) || !DECL_TEMPLATE_INFO (t))
5341 tree tmpl = DECL_TI_TEMPLATE (t);
5342 return variable_template_p (tmpl);
5345 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
5346 template declaration, or a TYPE_DECL for an alias declaration. */
5349 alias_type_or_template_p (tree t)
5353 return ((TREE_CODE (t) == TYPE_DECL && TYPE_DECL_ALIAS_P (t))
5356 && TYPE_DECL_ALIAS_P (TYPE_NAME (t)))
5357 || DECL_ALIAS_TEMPLATE_P (t));
5360 /* Return TRUE iff T is a specialization of an alias template. */
5363 alias_template_specialization_p (const_tree t)
5365 /* It's an alias template specialization if it's an alias and its
5366 TYPE_NAME is a specialization of a primary template. */
5367 if (TYPE_ALIAS_P (t))
5369 tree name = TYPE_NAME (t);
5370 if (DECL_LANG_SPECIFIC (name))
5371 if (tree ti = DECL_TEMPLATE_INFO (name))
5373 tree tmpl = TI_TEMPLATE (ti);
5374 return PRIMARY_TEMPLATE_P (tmpl);
5380 /* An alias template is complex from a SFINAE perspective if a template-id
5381 using that alias can be ill-formed when the expansion is not, as with
5382 the void_t template. We determine this by checking whether the
5383 expansion for the alias template uses all its template parameters. */
5385 struct uses_all_template_parms_data
5392 uses_all_template_parms_r (tree t, void *data_)
5394 struct uses_all_template_parms_data &data
5395 = *(struct uses_all_template_parms_data*)data_;
5396 tree idx = get_template_parm_index (t);
5398 if (TEMPLATE_PARM_LEVEL (idx) == data.level)
5399 data.seen[TEMPLATE_PARM_IDX (idx)] = true;
5404 complex_alias_template_p (const_tree tmpl)
5406 struct uses_all_template_parms_data data;
5407 tree pat = DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl));
5408 tree parms = DECL_TEMPLATE_PARMS (tmpl);
5409 data.level = TMPL_PARMS_DEPTH (parms);
5410 int len = TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS (parms));
5411 data.seen = XALLOCAVEC (bool, len);
5412 for (int i = 0; i < len; ++i)
5413 data.seen[i] = false;
5415 for_each_template_parm (pat, uses_all_template_parms_r, &data, NULL, true);
5416 for (int i = 0; i < len; ++i)
5422 /* Return TRUE iff T is a specialization of a complex alias template with
5423 dependent template-arguments. */
5426 dependent_alias_template_spec_p (const_tree t)
5428 return (alias_template_specialization_p (t)
5429 && TEMPLATE_DECL_COMPLEX_ALIAS_P (DECL_TI_TEMPLATE (TYPE_NAME (t)))
5430 && (any_dependent_template_arguments_p
5431 (INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (t)))));
5434 /* Return the number of innermost template parameters in TMPL. */
5437 num_innermost_template_parms (tree tmpl)
5439 tree parms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl));
5440 return TREE_VEC_LENGTH (parms);
5443 /* Return either TMPL or another template that it is equivalent to under DR
5444 1286: An alias that just changes the name of a template is equivalent to
5445 the other template. */
5448 get_underlying_template (tree tmpl)
5450 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
5451 while (DECL_ALIAS_TEMPLATE_P (tmpl))
5453 tree result = DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl));
5454 if (TYPE_TEMPLATE_INFO (result))
5456 tree sub = TYPE_TI_TEMPLATE (result);
5457 if (PRIMARY_TEMPLATE_P (sub)
5458 && (num_innermost_template_parms (tmpl)
5459 == num_innermost_template_parms (sub)))
5461 tree alias_args = INNERMOST_TEMPLATE_ARGS
5462 (template_parms_to_args (DECL_TEMPLATE_PARMS (tmpl)));
5463 if (!comp_template_args (TYPE_TI_ARGS (result), alias_args))
5465 /* The alias type is equivalent to the pattern of the
5466 underlying template, so strip the alias. */
5476 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
5477 must be a function or a pointer-to-function type, as specified
5478 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
5479 and check that the resulting function has external linkage. */
5482 convert_nontype_argument_function (tree type, tree expr,
5483 tsubst_flags_t complain)
5487 linkage_kind linkage;
5489 fn = instantiate_type (type, fns, tf_none);
5490 if (fn == error_mark_node)
5491 return error_mark_node;
5494 if (TREE_CODE (fn_no_ptr) == ADDR_EXPR)
5495 fn_no_ptr = TREE_OPERAND (fn_no_ptr, 0);
5496 if (BASELINK_P (fn_no_ptr))
5497 fn_no_ptr = BASELINK_FUNCTIONS (fn_no_ptr);
5499 /* [temp.arg.nontype]/1
5501 A template-argument for a non-type, non-template template-parameter
5504 -- the address of an object or function with external [C++11: or
5505 internal] linkage. */
5507 if (TREE_CODE (fn_no_ptr) != FUNCTION_DECL)
5509 if (complain & tf_error)
5511 error ("%qE is not a valid template argument for type %qT",
5513 if (TYPE_PTR_P (type))
5514 error ("it must be the address of a function with "
5515 "external linkage");
5517 error ("it must be the name of a function with "
5518 "external linkage");
5523 linkage = decl_linkage (fn_no_ptr);
5524 if (cxx_dialect >= cxx11 ? linkage == lk_none : linkage != lk_external)
5526 if (complain & tf_error)
5528 if (cxx_dialect >= cxx11)
5529 error ("%qE is not a valid template argument for type %qT "
5530 "because %qD has no linkage",
5531 expr, type, fn_no_ptr);
5533 error ("%qE is not a valid template argument for type %qT "
5534 "because %qD does not have external linkage",
5535 expr, type, fn_no_ptr);
5543 /* Subroutine of convert_nontype_argument.
5544 Check if EXPR of type TYPE is a valid pointer-to-member constant.
5545 Emit an error otherwise. */
5548 check_valid_ptrmem_cst_expr (tree type, tree expr,
5549 tsubst_flags_t complain)
5552 if (expr && (null_ptr_cst_p (expr) || TREE_CODE (expr) == PTRMEM_CST))
5554 if (cxx_dialect >= cxx11 && null_member_pointer_value_p (expr))
5556 if (processing_template_decl
5557 && TREE_CODE (expr) == ADDR_EXPR
5558 && TREE_CODE (TREE_OPERAND (expr, 0)) == OFFSET_REF)
5560 if (complain & tf_error)
5562 error ("%qE is not a valid template argument for type %qT",
5564 error ("it must be a pointer-to-member of the form %<&X::Y%>");
5569 /* Returns TRUE iff the address of OP is value-dependent.
5571 14.6.2.4 [temp.dep.temp]:
5572 A non-integral non-type template-argument is dependent if its type is
5573 dependent or it has either of the following forms
5576 and contains a nested-name-specifier which specifies a class-name that
5577 names a dependent type.
5579 We generalize this to just say that the address of a member of a
5580 dependent class is value-dependent; the above doesn't cover the
5581 address of a static data member named with an unqualified-id. */
5584 has_value_dependent_address (tree op)
5586 /* We could use get_inner_reference here, but there's no need;
5587 this is only relevant for template non-type arguments, which
5588 can only be expressed as &id-expression. */
5591 tree ctx = CP_DECL_CONTEXT (op);
5592 if (TYPE_P (ctx) && dependent_type_p (ctx))
5599 /* The next set of functions are used for providing helpful explanatory
5600 diagnostics for failed overload resolution. Their messages should be
5601 indented by two spaces for consistency with the messages in
5605 unify_success (bool /*explain_p*/)
5611 unify_parameter_deduction_failure (bool explain_p, tree parm)
5614 inform (input_location,
5615 " couldn't deduce template parameter %qD", parm);
5620 unify_invalid (bool /*explain_p*/)
5626 unify_cv_qual_mismatch (bool explain_p, tree parm, tree arg)
5629 inform (input_location,
5630 " types %qT and %qT have incompatible cv-qualifiers",
5636 unify_type_mismatch (bool explain_p, tree parm, tree arg)
5639 inform (input_location, " mismatched types %qT and %qT", parm, arg);
5644 unify_parameter_pack_mismatch (bool explain_p, tree parm, tree arg)
5647 inform (input_location,
5648 " template parameter %qD is not a parameter pack, but "
5655 unify_ptrmem_cst_mismatch (bool explain_p, tree parm, tree arg)
5658 inform (input_location,
5659 " template argument %qE does not match "
5660 "pointer-to-member constant %qE",
5666 unify_expression_unequal (bool explain_p, tree parm, tree arg)
5669 inform (input_location, " %qE is not equivalent to %qE", parm, arg);
5674 unify_parameter_pack_inconsistent (bool explain_p, tree old_arg, tree new_arg)
5677 inform (input_location,
5678 " inconsistent parameter pack deduction with %qT and %qT",
5684 unify_inconsistency (bool explain_p, tree parm, tree first, tree second)
5689 inform (input_location,
5690 " deduced conflicting types for parameter %qT (%qT and %qT)",
5691 parm, first, second);
5693 inform (input_location,
5694 " deduced conflicting values for non-type parameter "
5695 "%qE (%qE and %qE)", parm, first, second);
5701 unify_vla_arg (bool explain_p, tree arg)
5704 inform (input_location,
5705 " variable-sized array type %qT is not "
5706 "a valid template argument",
5712 unify_method_type_error (bool explain_p, tree arg)
5715 inform (input_location,
5716 " member function type %qT is not a valid template argument",
5722 unify_arity (bool explain_p, int have, int wanted, bool least_p = false)
5727 inform_n (input_location, wanted,
5728 " candidate expects at least %d argument, %d provided",
5729 " candidate expects at least %d arguments, %d provided",
5732 inform_n (input_location, wanted,
5733 " candidate expects %d argument, %d provided",
5734 " candidate expects %d arguments, %d provided",
5741 unify_too_many_arguments (bool explain_p, int have, int wanted)
5743 return unify_arity (explain_p, have, wanted);
5747 unify_too_few_arguments (bool explain_p, int have, int wanted,
5748 bool least_p = false)
5750 return unify_arity (explain_p, have, wanted, least_p);
5754 unify_arg_conversion (bool explain_p, tree to_type,
5755 tree from_type, tree arg)
5758 inform (EXPR_LOC_OR_LOC (arg, input_location),
5759 " cannot convert %qE (type %qT) to type %qT",
5760 arg, from_type, to_type);
5765 unify_no_common_base (bool explain_p, enum template_base_result r,
5766 tree parm, tree arg)
5771 case tbr_ambiguous_baseclass:
5772 inform (input_location, " %qT is an ambiguous base class of %qT",
5776 inform (input_location, " %qT is not derived from %qT", arg, parm);
5783 unify_inconsistent_template_template_parameters (bool explain_p)
5786 inform (input_location,
5787 " template parameters of a template template argument are "
5788 "inconsistent with other deduced template arguments");
5793 unify_template_deduction_failure (bool explain_p, tree parm, tree arg)
5796 inform (input_location,
5797 " can't deduce a template for %qT from non-template type %qT",
5803 unify_template_argument_mismatch (bool explain_p, tree parm, tree arg)
5806 inform (input_location,
5807 " template argument %qE does not match %qD", arg, parm);
5812 unify_overload_resolution_failure (bool explain_p, tree arg)
5815 inform (input_location,
5816 " could not resolve address from overloaded function %qE",
5821 /* Attempt to convert the non-type template parameter EXPR to the
5822 indicated TYPE. If the conversion is successful, return the
5823 converted value. If the conversion is unsuccessful, return
5824 NULL_TREE if we issued an error message, or error_mark_node if we
5825 did not. We issue error messages for out-and-out bad template
5826 parameters, but not simply because the conversion failed, since we
5827 might be just trying to do argument deduction. Both TYPE and EXPR
5828 must be non-dependent.
5830 The conversion follows the special rules described in
5831 [temp.arg.nontype], and it is much more strict than an implicit
5834 This function is called twice for each template argument (see
5835 lookup_template_class for a more accurate description of this
5836 problem). This means that we need to handle expressions which
5837 are not valid in a C++ source, but can be created from the
5838 first call (for instance, casts to perform conversions). These
5839 hacks can go away after we fix the double coercion problem. */
5842 convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain)
5846 /* Detect immediately string literals as invalid non-type argument.
5847 This special-case is not needed for correctness (we would easily
5848 catch this later), but only to provide better diagnostic for this
5849 common user mistake. As suggested by DR 100, we do not mention
5850 linkage issues in the diagnostic as this is not the point. */
5851 /* FIXME we're making this OK. */
5852 if (TREE_CODE (expr) == STRING_CST)
5854 if (complain & tf_error)
5855 error ("%qE is not a valid template argument for type %qT "
5856 "because string literals can never be used in this context",
5861 /* Add the ADDR_EXPR now for the benefit of
5862 value_dependent_expression_p. */
5863 if (TYPE_PTROBV_P (type)
5864 && TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE)
5866 expr = decay_conversion (expr, complain);
5867 if (expr == error_mark_node)
5868 return error_mark_node;
5871 /* If we are in a template, EXPR may be non-dependent, but still
5872 have a syntactic, rather than semantic, form. For example, EXPR
5873 might be a SCOPE_REF, rather than the VAR_DECL to which the
5874 SCOPE_REF refers. Preserving the qualifying scope is necessary
5875 so that access checking can be performed when the template is
5876 instantiated -- but here we need the resolved form so that we can
5877 convert the argument. */
5878 bool non_dep = false;
5879 if (TYPE_REF_OBJ_P (type)
5880 && has_value_dependent_address (expr))
5881 /* If we want the address and it's value-dependent, don't fold. */;
5882 else if (!type_unknown_p (expr)
5883 && processing_template_decl
5884 && !instantiation_dependent_expression_p (expr)
5885 && potential_constant_expression (expr))
5887 if (error_operand_p (expr))
5888 return error_mark_node;
5889 expr_type = TREE_TYPE (expr);
5890 if (TREE_CODE (type) == REFERENCE_TYPE)
5891 expr = mark_lvalue_use (expr);
5893 expr = mark_rvalue_use (expr);
5895 /* If the argument is non-dependent, perform any conversions in
5896 non-dependent context as well. */
5897 processing_template_decl_sentinel s (non_dep);
5899 expr = instantiate_non_dependent_expr_internal (expr, complain);
5901 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
5902 to a non-type argument of "nullptr". */
5903 if (expr == nullptr_node && TYPE_PTR_OR_PTRMEM_P (type))
5904 expr = convert (type, expr);
5906 /* In C++11, integral or enumeration non-type template arguments can be
5907 arbitrary constant expressions. Pointer and pointer to
5908 member arguments can be general constant expressions that evaluate
5909 to a null value, but otherwise still need to be of a specific form. */
5910 if (cxx_dialect >= cxx11)
5912 if (TREE_CODE (expr) == PTRMEM_CST)
5913 /* A PTRMEM_CST is already constant, and a valid template
5914 argument for a parameter of pointer to member type, we just want
5915 to leave it in that form rather than lower it to a
5917 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type))
5918 expr = maybe_constant_value (expr);
5919 else if (TYPE_PTR_OR_PTRMEM_P (type))
5921 tree folded = maybe_constant_value (expr);
5922 if (TYPE_PTR_P (type) ? integer_zerop (folded)
5923 : null_member_pointer_value_p (folded))
5928 /* HACK: Due to double coercion, we can get a
5929 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
5930 which is the tree that we built on the first call (see
5931 below when coercing to reference to object or to reference to
5932 function). We just strip everything and get to the arg.
5933 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
5935 if (TYPE_REF_OBJ_P (type) || TYPE_REFFN_P (type))
5937 tree probe_type, probe = expr;
5938 if (REFERENCE_REF_P (probe))
5939 probe = TREE_OPERAND (probe, 0);
5940 probe_type = TREE_TYPE (probe);
5941 if (TREE_CODE (probe) == NOP_EXPR)
5943 /* ??? Maybe we could use convert_from_reference here, but we
5944 would need to relax its constraints because the NOP_EXPR
5945 could actually change the type to something more cv-qualified,
5946 and this is not folded by convert_from_reference. */
5947 tree addr = TREE_OPERAND (probe, 0);
5948 if (TREE_CODE (probe_type) == REFERENCE_TYPE
5949 && TREE_CODE (addr) == ADDR_EXPR
5950 && TYPE_PTR_P (TREE_TYPE (addr))
5951 && (same_type_ignoring_top_level_qualifiers_p
5952 (TREE_TYPE (probe_type),
5953 TREE_TYPE (TREE_TYPE (addr)))))
5955 expr = TREE_OPERAND (addr, 0);
5956 expr_type = TREE_TYPE (probe_type);
5961 /* We could also generate a NOP_EXPR(ADDR_EXPR()) when the
5962 parameter is a pointer to object, through decay and
5963 qualification conversion. Let's strip everything. */
5964 else if (TREE_CODE (expr) == NOP_EXPR && TYPE_PTROBV_P (type))
5968 if (TREE_CODE (probe) == ADDR_EXPR
5969 && TYPE_PTR_P (TREE_TYPE (probe)))
5971 /* Skip the ADDR_EXPR only if it is part of the decay for
5972 an array. Otherwise, it is part of the original argument
5973 in the source code. */
5974 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (probe, 0))) == ARRAY_TYPE)
5975 probe = TREE_OPERAND (probe, 0);
5977 expr_type = TREE_TYPE (expr);
5981 /* [temp.arg.nontype]/5, bullet 1
5983 For a non-type template-parameter of integral or enumeration type,
5984 integral promotions (_conv.prom_) and integral conversions
5985 (_conv.integral_) are applied. */
5986 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type))
5988 tree t = build_integral_nontype_arg_conv (type, expr, complain);
5989 t = maybe_constant_value (t);
5990 if (t != error_mark_node)
5993 if (!same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (expr)))
5994 return error_mark_node;
5996 /* Notice that there are constant expressions like '4 % 0' which
5997 do not fold into integer constants. */
5998 if (TREE_CODE (expr) != INTEGER_CST)
6000 if (complain & tf_error)
6002 int errs = errorcount, warns = warningcount + werrorcount;
6003 if (processing_template_decl
6004 && !require_potential_constant_expression (expr))
6006 expr = cxx_constant_value (expr);
6007 if (errorcount > errs || warningcount + werrorcount > warns)
6008 inform (EXPR_LOC_OR_LOC (expr, input_location),
6009 "in template argument for type %qT ", type);
6010 if (expr == error_mark_node)
6012 /* else cxx_constant_value complained but gave us
6013 a real constant, so go ahead. */
6014 gcc_assert (TREE_CODE (expr) == INTEGER_CST);
6020 /* Avoid typedef problems. */
6021 if (TREE_TYPE (expr) != type)
6022 expr = fold_convert (type, expr);
6024 /* [temp.arg.nontype]/5, bullet 2
6026 For a non-type template-parameter of type pointer to object,
6027 qualification conversions (_conv.qual_) and the array-to-pointer
6028 conversion (_conv.array_) are applied. */
6029 else if (TYPE_PTROBV_P (type))
6031 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
6033 A template-argument for a non-type, non-template template-parameter
6034 shall be one of: [...]
6036 -- the name of a non-type template-parameter;
6037 -- the address of an object or function with external linkage, [...]
6038 expressed as "& id-expression" where the & is optional if the name
6039 refers to a function or array, or if the corresponding
6040 template-parameter is a reference.
6042 Here, we do not care about functions, as they are invalid anyway
6043 for a parameter of type pointer-to-object. */
6045 if (DECL_P (expr) && DECL_TEMPLATE_PARM_P (expr))
6046 /* Non-type template parameters are OK. */
6048 else if (cxx_dialect >= cxx11 && integer_zerop (expr))
6049 /* Null pointer values are OK in C++11. */;
6050 else if (TREE_CODE (expr) != ADDR_EXPR
6051 && TREE_CODE (expr_type) != ARRAY_TYPE)
6055 if (complain & tf_error)
6056 error ("%qD is not a valid template argument "
6057 "because %qD is a variable, not the address of "
6058 "a variable", expr, expr);
6061 if (POINTER_TYPE_P (expr_type))
6063 if (complain & tf_error)
6064 error ("%qE is not a valid template argument for %qT "
6065 "because it is not the address of a variable",
6069 /* Other values, like integer constants, might be valid
6070 non-type arguments of some other type. */
6071 return error_mark_node;
6077 decl = ((TREE_CODE (expr) == ADDR_EXPR)
6078 ? TREE_OPERAND (expr, 0) : expr);
6081 if (complain & tf_error)
6082 error ("%qE is not a valid template argument of type %qT "
6083 "because %qE is not a variable", expr, type, decl);
6086 else if (cxx_dialect < cxx11 && !DECL_EXTERNAL_LINKAGE_P (decl))
6088 if (complain & tf_error)
6089 error ("%qE is not a valid template argument of type %qT "
6090 "because %qD does not have external linkage",
6094 else if (cxx_dialect >= cxx11 && decl_linkage (decl) == lk_none)
6096 if (complain & tf_error)
6097 error ("%qE is not a valid template argument of type %qT "
6098 "because %qD has no linkage", expr, type, decl);
6103 expr = decay_conversion (expr, complain);
6104 if (expr == error_mark_node)
6105 return error_mark_node;
6107 expr = perform_qualification_conversions (type, expr);
6108 if (expr == error_mark_node)
6109 return error_mark_node;
6111 /* [temp.arg.nontype]/5, bullet 3
6113 For a non-type template-parameter of type reference to object, no
6114 conversions apply. The type referred to by the reference may be more
6115 cv-qualified than the (otherwise identical) type of the
6116 template-argument. The template-parameter is bound directly to the
6117 template-argument, which must be an lvalue. */
6118 else if (TYPE_REF_OBJ_P (type))
6120 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type),
6122 return error_mark_node;
6124 if (!at_least_as_qualified_p (TREE_TYPE (type), expr_type))
6126 if (complain & tf_error)
6127 error ("%qE is not a valid template argument for type %qT "
6128 "because of conflicts in cv-qualification", expr, type);
6132 if (!real_lvalue_p (expr))
6134 if (complain & tf_error)
6135 error ("%qE is not a valid template argument for type %qT "
6136 "because it is not an lvalue", expr, type);
6140 /* [temp.arg.nontype]/1
6142 A template-argument for a non-type, non-template template-parameter
6143 shall be one of: [...]
6145 -- the address of an object or function with external linkage. */
6146 if (INDIRECT_REF_P (expr)
6147 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr, 0))))
6149 expr = TREE_OPERAND (expr, 0);
6152 if (complain & tf_error)
6153 error ("%q#D is not a valid template argument for type %qT "
6154 "because a reference variable does not have a constant "
6155 "address", expr, type);
6162 if (complain & tf_error)
6163 error ("%qE is not a valid template argument for type %qT "
6164 "because it is not an object with external linkage",
6169 if (!DECL_EXTERNAL_LINKAGE_P (expr))
6171 if (complain & tf_error)
6172 error ("%qE is not a valid template argument for type %qT "
6173 "because object %qD has not external linkage",
6178 expr = build_nop (type, build_address (expr));
6180 /* [temp.arg.nontype]/5, bullet 4
6182 For a non-type template-parameter of type pointer to function, only
6183 the function-to-pointer conversion (_conv.func_) is applied. If the
6184 template-argument represents a set of overloaded functions (or a
6185 pointer to such), the matching function is selected from the set
6187 else if (TYPE_PTRFN_P (type))
6189 /* If the argument is a template-id, we might not have enough
6190 context information to decay the pointer. */
6191 if (!type_unknown_p (expr_type))
6193 expr = decay_conversion (expr, complain);
6194 if (expr == error_mark_node)
6195 return error_mark_node;
6198 if (cxx_dialect >= cxx11 && integer_zerop (expr))
6199 /* Null pointer values are OK in C++11. */
6200 return perform_qualification_conversions (type, expr);
6202 expr = convert_nontype_argument_function (type, expr, complain);
6203 if (!expr || expr == error_mark_node)
6206 /* [temp.arg.nontype]/5, bullet 5
6208 For a non-type template-parameter of type reference to function, no
6209 conversions apply. If the template-argument represents a set of
6210 overloaded functions, the matching function is selected from the set
6212 else if (TYPE_REFFN_P (type))
6214 if (TREE_CODE (expr) == ADDR_EXPR)
6216 if (complain & tf_error)
6218 error ("%qE is not a valid template argument for type %qT "
6219 "because it is a pointer", expr, type);
6220 inform (input_location, "try using %qE instead",
6221 TREE_OPERAND (expr, 0));
6226 expr = convert_nontype_argument_function (type, expr, complain);
6227 if (!expr || expr == error_mark_node)
6230 expr = build_nop (type, build_address (expr));
6232 /* [temp.arg.nontype]/5, bullet 6
6234 For a non-type template-parameter of type pointer to member function,
6235 no conversions apply. If the template-argument represents a set of
6236 overloaded member functions, the matching member function is selected
6237 from the set (_over.over_). */
6238 else if (TYPE_PTRMEMFUNC_P (type))
6240 expr = instantiate_type (type, expr, tf_none);
6241 if (expr == error_mark_node)
6242 return error_mark_node;
6244 /* [temp.arg.nontype] bullet 1 says the pointer to member
6245 expression must be a pointer-to-member constant. */
6246 if (!check_valid_ptrmem_cst_expr (type, expr, complain))
6247 return error_mark_node;
6249 /* There is no way to disable standard conversions in
6250 resolve_address_of_overloaded_function (called by
6251 instantiate_type). It is possible that the call succeeded by
6252 converting &B::I to &D::I (where B is a base of D), so we need
6253 to reject this conversion here.
6255 Actually, even if there was a way to disable standard conversions,
6256 it would still be better to reject them here so that we can
6257 provide a superior diagnostic. */
6258 if (!same_type_p (TREE_TYPE (expr), type))
6260 if (complain & tf_error)
6262 error ("%qE is not a valid template argument for type %qT "
6263 "because it is of type %qT", expr, type,
6265 /* If we are just one standard conversion off, explain. */
6266 if (can_convert_standard (type, TREE_TYPE (expr), complain))
6267 inform (input_location,
6268 "standard conversions are not allowed in this context");
6273 /* [temp.arg.nontype]/5, bullet 7
6275 For a non-type template-parameter of type pointer to data member,
6276 qualification conversions (_conv.qual_) are applied. */
6277 else if (TYPE_PTRDATAMEM_P (type))
6279 /* [temp.arg.nontype] bullet 1 says the pointer to member
6280 expression must be a pointer-to-member constant. */
6281 if (!check_valid_ptrmem_cst_expr (type, expr, complain))
6282 return error_mark_node;
6284 expr = perform_qualification_conversions (type, expr);
6285 if (expr == error_mark_node)
6288 else if (NULLPTR_TYPE_P (type))
6290 if (expr != nullptr_node)
6292 if (complain & tf_error)
6293 error ("%qE is not a valid template argument for type %qT "
6294 "because it is of type %qT", expr, type, TREE_TYPE (expr));
6299 /* A template non-type parameter must be one of the above. */
6303 /* Sanity check: did we actually convert the argument to the
6305 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6306 (type, TREE_TYPE (expr)));
6307 return convert_from_reference (expr);
6310 /* Subroutine of coerce_template_template_parms, which returns 1 if
6311 PARM_PARM and ARG_PARM match using the rule for the template
6312 parameters of template template parameters. Both PARM and ARG are
6313 template parameters; the rest of the arguments are the same as for
6314 coerce_template_template_parms.
6317 coerce_template_template_parm (tree parm,
6319 tsubst_flags_t complain,
6323 if (arg == NULL_TREE || error_operand_p (arg)
6324 || parm == NULL_TREE || error_operand_p (parm))
6327 if (TREE_CODE (arg) != TREE_CODE (parm))
6330 switch (TREE_CODE (parm))
6333 /* We encounter instantiations of templates like
6334 template <template <template <class> class> class TT>
6337 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
6338 tree argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
6340 if (!coerce_template_template_parms
6341 (parmparm, argparm, complain, in_decl, outer_args))
6347 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg))
6348 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm)))
6349 /* Argument is a parameter pack but parameter is not. */
6354 /* The tsubst call is used to handle cases such as
6356 template <int> class C {};
6357 template <class T, template <T> class TT> class D {};
6360 i.e. the parameter list of TT depends on earlier parameters. */
6361 if (!uses_template_parms (TREE_TYPE (arg))
6363 (tsubst (TREE_TYPE (parm), outer_args, complain, in_decl),
6367 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg))
6368 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))
6369 /* Argument is a parameter pack but parameter is not. */
6382 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
6383 template template parameters. Both PARM_PARMS and ARG_PARMS are
6384 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
6387 Consider the example:
6388 template <class T> class A;
6389 template<template <class U> class TT> class B;
6391 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
6392 the parameters to A, and OUTER_ARGS contains A. */
6395 coerce_template_template_parms (tree parm_parms,
6397 tsubst_flags_t complain,
6401 int nparms, nargs, i;
6405 gcc_assert (TREE_CODE (parm_parms) == TREE_VEC);
6406 gcc_assert (TREE_CODE (arg_parms) == TREE_VEC);
6408 nparms = TREE_VEC_LENGTH (parm_parms);
6409 nargs = TREE_VEC_LENGTH (arg_parms);
6411 /* Determine whether we have a parameter pack at the end of the
6412 template template parameter's template parameter list. */
6413 if (TREE_VEC_ELT (parm_parms, nparms - 1) != error_mark_node)
6415 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, nparms - 1));
6417 if (error_operand_p (parm))
6420 switch (TREE_CODE (parm))
6424 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm)))
6429 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))
6439 && !(variadic_p && nargs >= nparms - 1))
6442 /* Check all of the template parameters except the parameter pack at
6443 the end (if any). */
6444 for (i = 0; i < nparms - variadic_p; ++i)
6446 if (TREE_VEC_ELT (parm_parms, i) == error_mark_node
6447 || TREE_VEC_ELT (arg_parms, i) == error_mark_node)
6450 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
6451 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
6453 if (!coerce_template_template_parm (parm, arg, complain, in_decl,
6461 /* Check each of the template parameters in the template
6462 argument against the template parameter pack at the end of
6463 the template template parameter. */
6464 if (TREE_VEC_ELT (parm_parms, i) == error_mark_node)
6467 parm = TREE_VALUE (TREE_VEC_ELT (parm_parms, i));
6469 for (; i < nargs; ++i)
6471 if (TREE_VEC_ELT (arg_parms, i) == error_mark_node)
6474 arg = TREE_VALUE (TREE_VEC_ELT (arg_parms, i));
6476 if (!coerce_template_template_parm (parm, arg, complain, in_decl,
6485 /* Verifies that the deduced template arguments (in TARGS) for the
6486 template template parameters (in TPARMS) represent valid bindings,
6487 by comparing the template parameter list of each template argument
6488 to the template parameter list of its corresponding template
6489 template parameter, in accordance with DR150. This
6490 routine can only be called after all template arguments have been
6491 deduced. It will return TRUE if all of the template template
6492 parameter bindings are okay, FALSE otherwise. */
6494 template_template_parm_bindings_ok_p (tree tparms, tree targs)
6496 int i, ntparms = TREE_VEC_LENGTH (tparms);
6499 /* We're dealing with template parms in this process. */
6500 ++processing_template_decl;
6502 targs = INNERMOST_TEMPLATE_ARGS (targs);
6504 for (i = 0; i < ntparms; ++i)
6506 tree tparm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
6507 tree targ = TREE_VEC_ELT (targs, i);
6509 if (TREE_CODE (tparm) == TEMPLATE_DECL && targ)
6511 tree packed_args = NULL_TREE;
6514 if (ARGUMENT_PACK_P (targ))
6516 /* Look inside the argument pack. */
6517 packed_args = ARGUMENT_PACK_ARGS (targ);
6518 len = TREE_VEC_LENGTH (packed_args);
6521 for (idx = 0; idx < len; ++idx)
6523 tree targ_parms = NULL_TREE;
6526 /* Extract the next argument from the argument
6528 targ = TREE_VEC_ELT (packed_args, idx);
6530 if (PACK_EXPANSION_P (targ))
6531 /* Look at the pattern of the pack expansion. */
6532 targ = PACK_EXPANSION_PATTERN (targ);
6534 /* Extract the template parameters from the template
6536 if (TREE_CODE (targ) == TEMPLATE_DECL)
6537 targ_parms = DECL_INNERMOST_TEMPLATE_PARMS (targ);
6538 else if (TREE_CODE (targ) == TEMPLATE_TEMPLATE_PARM)
6539 targ_parms = DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ));
6541 /* Verify that we can coerce the template template
6542 parameters from the template argument to the template
6543 parameter. This requires an exact match. */
6545 && !coerce_template_template_parms
6546 (DECL_INNERMOST_TEMPLATE_PARMS (tparm),
6561 --processing_template_decl;
6565 /* Since type attributes aren't mangled, we need to strip them from
6566 template type arguments. */
6569 canonicalize_type_argument (tree arg, tsubst_flags_t complain)
6572 if (!arg || arg == error_mark_node || arg == TYPE_CANONICAL (arg))
6574 mv = TYPE_MAIN_VARIANT (arg);
6575 arg = strip_typedefs (arg);
6576 if (TYPE_ALIGN (arg) != TYPE_ALIGN (mv)
6577 || TYPE_ATTRIBUTES (arg) != TYPE_ATTRIBUTES (mv))
6579 if (complain & tf_warning)
6580 warning (0, "ignoring attributes on template argument %qT", arg);
6581 arg = build_aligned_type (arg, TYPE_ALIGN (mv));
6582 arg = cp_build_type_attribute_variant (arg, TYPE_ATTRIBUTES (mv));
6587 /* Convert the indicated template ARG as necessary to match the
6588 indicated template PARM. Returns the converted ARG, or
6589 error_mark_node if the conversion was unsuccessful. Error and
6590 warning messages are issued under control of COMPLAIN. This
6591 conversion is for the Ith parameter in the parameter list. ARGS is
6592 the full set of template arguments deduced so far. */
6595 convert_template_argument (tree parm,
6598 tsubst_flags_t complain,
6604 int is_type, requires_type, is_tmpl_type, requires_tmpl_type;
6606 if (parm == error_mark_node)
6607 return error_mark_node;
6609 if (TREE_CODE (arg) == TREE_LIST
6610 && TREE_CODE (TREE_VALUE (arg)) == OFFSET_REF)
6612 /* The template argument was the name of some
6613 member function. That's usually
6614 invalid, but static members are OK. In any
6615 case, grab the underlying fields/functions
6616 and issue an error later if required. */
6617 orig_arg = TREE_VALUE (arg);
6618 TREE_TYPE (arg) = unknown_type_node;
6623 requires_tmpl_type = TREE_CODE (parm) == TEMPLATE_DECL;
6624 requires_type = (TREE_CODE (parm) == TYPE_DECL
6625 || requires_tmpl_type);
6627 /* When determining whether an argument pack expansion is a template,
6628 look at the pattern. */
6629 if (TREE_CODE (arg) == TYPE_PACK_EXPANSION)
6630 arg = PACK_EXPANSION_PATTERN (arg);
6632 /* Deal with an injected-class-name used as a template template arg. */
6633 if (requires_tmpl_type && CLASS_TYPE_P (arg))
6635 tree t = maybe_get_template_decl_from_type_decl (TYPE_NAME (arg));
6636 if (TREE_CODE (t) == TEMPLATE_DECL)
6638 if (cxx_dialect >= cxx11)
6639 /* OK under DR 1004. */;
6640 else if (complain & tf_warning_or_error)
6641 pedwarn (input_location, OPT_Wpedantic, "injected-class-name %qD"
6642 " used as template template argument", TYPE_NAME (arg));
6643 else if (flag_pedantic_errors)
6651 ((TREE_CODE (arg) == TEMPLATE_DECL
6652 && TREE_CODE (DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)
6653 || (requires_tmpl_type && TREE_CODE (arg) == TYPE_ARGUMENT_PACK)
6654 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
6655 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
6658 && (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
6659 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE))
6660 arg = TYPE_STUB_DECL (arg);
6662 is_type = TYPE_P (arg) || is_tmpl_type;
6664 if (requires_type && ! is_type && TREE_CODE (arg) == SCOPE_REF
6665 && TREE_CODE (TREE_OPERAND (arg, 0)) == TEMPLATE_TYPE_PARM)
6667 if (TREE_CODE (TREE_OPERAND (arg, 1)) == BIT_NOT_EXPR)
6669 if (complain & tf_error)
6670 error ("invalid use of destructor %qE as a type", orig_arg);
6671 return error_mark_node;
6674 permerror (input_location,
6675 "to refer to a type member of a template parameter, "
6676 "use %<typename %E%>", orig_arg);
6678 orig_arg = make_typename_type (TREE_OPERAND (arg, 0),
6679 TREE_OPERAND (arg, 1),
6685 if (is_type != requires_type)
6689 if (complain & tf_error)
6691 error ("type/value mismatch at argument %d in template "
6692 "parameter list for %qD",
6695 inform (input_location,
6696 " expected a constant of type %qT, got %qT",
6698 (DECL_P (arg) ? DECL_NAME (arg) : orig_arg));
6699 else if (requires_tmpl_type)
6700 inform (input_location,
6701 " expected a class template, got %qE", orig_arg);
6703 inform (input_location,
6704 " expected a type, got %qE", orig_arg);
6707 return error_mark_node;
6709 if (is_tmpl_type ^ requires_tmpl_type)
6711 if (in_decl && (complain & tf_error))
6713 error ("type/value mismatch at argument %d in template "
6714 "parameter list for %qD",
6717 inform (input_location,
6718 " expected a type, got %qT", DECL_NAME (arg));
6720 inform (input_location,
6721 " expected a class template, got %qT", orig_arg);
6723 return error_mark_node;
6728 if (requires_tmpl_type)
6730 if (template_parameter_pack_p (parm) && ARGUMENT_PACK_P (orig_arg))
6732 else if (TREE_CODE (TREE_TYPE (arg)) == UNBOUND_CLASS_TEMPLATE)
6733 /* The number of argument required is not known yet.
6734 Just accept it for now. */
6735 val = TREE_TYPE (arg);
6738 tree parmparm = DECL_INNERMOST_TEMPLATE_PARMS (parm);
6741 /* Strip alias templates that are equivalent to another
6743 arg = get_underlying_template (arg);
6744 argparm = DECL_INNERMOST_TEMPLATE_PARMS (arg);
6746 if (coerce_template_template_parms (parmparm, argparm,
6752 /* TEMPLATE_TEMPLATE_PARM node is preferred over
6754 if (val != error_mark_node)
6756 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val))
6757 val = TREE_TYPE (val);
6758 if (TREE_CODE (orig_arg) == TYPE_PACK_EXPANSION)
6759 val = make_pack_expansion (val);
6764 if (in_decl && (complain & tf_error))
6766 error ("type/value mismatch at argument %d in "
6767 "template parameter list for %qD",
6769 inform (input_location,
6770 " expected a template of type %qD, got %qT",
6774 val = error_mark_node;
6780 /* We only form one instance of each template specialization.
6781 Therefore, if we use a non-canonical variant (i.e., a
6782 typedef), any future messages referring to the type will use
6783 the typedef, which is confusing if those future uses do not
6784 themselves also use the typedef. */
6786 val = canonicalize_type_argument (val, complain);
6790 tree t = tsubst (TREE_TYPE (parm), args, complain, in_decl);
6792 if (invalid_nontype_parm_type_p (t, complain))
6793 return error_mark_node;
6795 if (template_parameter_pack_p (parm) && ARGUMENT_PACK_P (orig_arg))
6797 if (same_type_p (t, TREE_TYPE (orig_arg)))
6801 /* Not sure if this is reachable, but it doesn't hurt
6803 error ("type mismatch in nontype parameter pack");
6804 val = error_mark_node;
6807 else if (!dependent_template_arg_p (orig_arg)
6808 && !uses_template_parms (t))
6809 /* We used to call digest_init here. However, digest_init
6810 will report errors, which we don't want when complain
6811 is zero. More importantly, digest_init will try too
6812 hard to convert things: for example, `0' should not be
6813 converted to pointer type at this point according to
6814 the standard. Accepting this is not merely an
6815 extension, since deciding whether or not these
6816 conversions can occur is part of determining which
6817 function template to call, or whether a given explicit
6818 argument specification is valid. */
6819 val = convert_nontype_argument (t, orig_arg, complain);
6821 val = strip_typedefs_expr (orig_arg);
6823 if (val == NULL_TREE)
6824 val = error_mark_node;
6825 else if (val == error_mark_node && (complain & tf_error))
6826 error ("could not convert template argument %qE to %qT", orig_arg, t);
6828 if (TREE_CODE (val) == SCOPE_REF)
6830 /* Strip typedefs from the SCOPE_REF. */
6831 tree type = canonicalize_type_argument (TREE_TYPE (val), complain);
6832 tree scope = canonicalize_type_argument (TREE_OPERAND (val, 0),
6834 val = build_qualified_name (type, scope, TREE_OPERAND (val, 1),
6835 QUALIFIED_NAME_IS_TEMPLATE (val));
6842 /* Coerces the remaining template arguments in INNER_ARGS (from
6843 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
6844 Returns the coerced argument pack. PARM_IDX is the position of this
6845 parameter in the template parameter list. ARGS is the original
6846 template argument list. */
6848 coerce_template_parameter_pack (tree parms,
6856 tsubst_flags_t complain)
6858 tree parm = TREE_VEC_ELT (parms, parm_idx);
6859 int nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
6862 tree packed_parms = NULL_TREE;
6864 if (arg_idx > nargs)
6867 if (tree packs = fixed_parameter_pack_p (TREE_VALUE (parm)))
6869 /* When the template parameter is a non-type template parameter pack
6870 or template template parameter pack whose type or template
6871 parameters use parameter packs, we know exactly how many arguments
6872 we are looking for. Build a vector of the instantiated decls for
6873 these template parameters in PACKED_PARMS. */
6874 /* We can't use make_pack_expansion here because it would interpret a
6875 _DECL as a use rather than a declaration. */
6876 tree decl = TREE_VALUE (parm);
6877 tree exp = cxx_make_type (TYPE_PACK_EXPANSION);
6878 SET_PACK_EXPANSION_PATTERN (exp, decl);
6879 PACK_EXPANSION_PARAMETER_PACKS (exp) = packs;
6880 SET_TYPE_STRUCTURAL_EQUALITY (exp);
6882 TREE_VEC_LENGTH (args)--;
6883 packed_parms = tsubst_pack_expansion (exp, args, complain, decl);
6884 TREE_VEC_LENGTH (args)++;
6886 if (packed_parms == error_mark_node)
6887 return error_mark_node;
6889 /* If we're doing a partial instantiation of a member template,
6890 verify that all of the types used for the non-type
6891 template parameter pack are, in fact, valid for non-type
6892 template parameters. */
6894 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args, arg_idx)))
6896 int j, len = TREE_VEC_LENGTH (packed_parms);
6897 for (j = 0; j < len; ++j)
6899 tree t = TREE_TYPE (TREE_VEC_ELT (packed_parms, j));
6900 if (invalid_nontype_parm_type_p (t, complain))
6901 return error_mark_node;
6903 /* We don't know how many args we have yet, just
6904 use the unconverted ones for now. */
6908 packed_args = make_tree_vec (TREE_VEC_LENGTH (packed_parms));
6911 packed_args = make_tree_vec (nargs - arg_idx);
6913 /* Convert the remaining arguments, which will be a part of the
6914 parameter pack "parm". */
6915 int first_pack_arg = arg_idx;
6916 for (; arg_idx < nargs; ++arg_idx)
6918 tree arg = TREE_VEC_ELT (inner_args, arg_idx);
6919 tree actual_parm = TREE_VALUE (parm);
6920 int pack_idx = arg_idx - first_pack_arg;
6924 /* Once we've packed as many args as we have types, stop. */
6925 if (pack_idx >= TREE_VEC_LENGTH (packed_parms))
6927 else if (PACK_EXPANSION_P (arg))
6928 /* We don't know how many args we have yet, just
6929 use the unconverted ones for now. */
6932 actual_parm = TREE_VEC_ELT (packed_parms, pack_idx);
6935 if (arg == error_mark_node)
6937 if (complain & tf_error)
6938 error ("template argument %d is invalid", arg_idx + 1);
6941 arg = convert_template_argument (actual_parm,
6942 arg, new_args, complain, parm_idx,
6944 if (arg == error_mark_node)
6946 TREE_VEC_ELT (packed_args, pack_idx) = arg;
6949 if (arg_idx - first_pack_arg < TREE_VEC_LENGTH (packed_args)
6950 && TREE_VEC_LENGTH (packed_args) > 0)
6952 if (complain & tf_error)
6953 error ("wrong number of template arguments (%d, should be %d)",
6954 arg_idx - first_pack_arg, TREE_VEC_LENGTH (packed_args));
6955 return error_mark_node;
6958 if (TREE_CODE (TREE_VALUE (parm)) == TYPE_DECL
6959 || TREE_CODE (TREE_VALUE (parm)) == TEMPLATE_DECL)
6960 argument_pack = cxx_make_type (TYPE_ARGUMENT_PACK);
6963 argument_pack = make_node (NONTYPE_ARGUMENT_PACK);
6964 TREE_TYPE (argument_pack)
6965 = tsubst (TREE_TYPE (TREE_VALUE (parm)), new_args, complain, in_decl);
6966 TREE_CONSTANT (argument_pack) = 1;
6969 SET_ARGUMENT_PACK_ARGS (argument_pack, packed_args);
6970 #ifdef ENABLE_CHECKING
6971 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args,
6972 TREE_VEC_LENGTH (packed_args));
6974 return argument_pack;
6977 /* Returns the number of pack expansions in the template argument vector
6981 pack_expansion_args_count (tree args)
6986 for (i = 0; i < TREE_VEC_LENGTH (args); ++i)
6988 tree elt = TREE_VEC_ELT (args, i);
6989 if (elt && PACK_EXPANSION_P (elt))
6995 /* Convert all template arguments to their appropriate types, and
6996 return a vector containing the innermost resulting template
6997 arguments. If any error occurs, return error_mark_node. Error and
6998 warning messages are issued under control of COMPLAIN.
7000 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
7001 for arguments not specified in ARGS. Otherwise, if
7002 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
7003 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
7004 USE_DEFAULT_ARGS is false, then all arguments must be specified in
7008 coerce_template_parms (tree parms,
7011 tsubst_flags_t complain,
7012 bool require_all_args,
7013 bool use_default_args)
7015 int nparms, nargs, parm_idx, arg_idx, lost = 0;
7016 tree orig_inner_args;
7019 tree new_inner_args;
7020 int saved_unevaluated_operand;
7021 int saved_inhibit_evaluation_warnings;
7023 /* When used as a boolean value, indicates whether this is a
7024 variadic template parameter list. Since it's an int, we can also
7025 subtract it from nparms to get the number of non-variadic
7028 int variadic_args_p = 0;
7029 int post_variadic_parms = 0;
7031 /* Likewise for parameters with default arguments. */
7034 if (args == error_mark_node)
7035 return error_mark_node;
7037 nparms = TREE_VEC_LENGTH (parms);
7039 /* Determine if there are any parameter packs or default arguments. */
7040 for (parm_idx = 0; parm_idx < nparms; ++parm_idx)
7042 tree parm = TREE_VEC_ELT (parms, parm_idx);
7044 ++post_variadic_parms;
7045 if (template_parameter_pack_p (TREE_VALUE (parm)))
7047 if (TREE_PURPOSE (parm))
7051 inner_args = orig_inner_args = INNERMOST_TEMPLATE_ARGS (args);
7052 /* If there are no parameters that follow a parameter pack, we need to
7053 expand any argument packs so that we can deduce a parameter pack from
7054 some non-packed args followed by an argument pack, as in variadic85.C.
7055 If there are such parameters, we need to leave argument packs intact
7056 so the arguments are assigned properly. This can happen when dealing
7057 with a nested class inside a partial specialization of a class
7058 template, as in variadic92.C, or when deducing a template parameter pack
7059 from a sub-declarator, as in variadic114.C. */
7060 if (!post_variadic_parms)
7061 inner_args = expand_template_argument_pack (inner_args);
7063 /* Count any pack expansion args. */
7064 variadic_args_p = pack_expansion_args_count (inner_args);
7066 nargs = inner_args ? NUM_TMPL_ARGS (inner_args) : 0;
7067 if ((nargs > nparms && !variadic_p)
7068 || (nargs < nparms - variadic_p
7071 && (!use_default_args
7072 || (TREE_VEC_ELT (parms, nargs) != error_mark_node
7073 && !TREE_PURPOSE (TREE_VEC_ELT (parms, nargs))))))
7075 if (complain & tf_error)
7077 if (variadic_p || default_p)
7079 nparms -= variadic_p + default_p;
7080 error ("wrong number of template arguments "
7081 "(%d, should be at least %d)", nargs, nparms);
7084 error ("wrong number of template arguments "
7085 "(%d, should be %d)", nargs, nparms);
7088 inform (input_location, "provided for %q+D", in_decl);
7091 return error_mark_node;
7093 /* We can't pass a pack expansion to a non-pack parameter of an alias
7094 template (DR 1430). */
7095 else if (in_decl && DECL_ALIAS_TEMPLATE_P (in_decl)
7097 && nargs - variadic_args_p < nparms - variadic_p)
7099 if (complain & tf_error)
7101 for (int i = 0; i < TREE_VEC_LENGTH (inner_args); ++i)
7103 tree arg = TREE_VEC_ELT (inner_args, i);
7104 tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i));
7106 if (PACK_EXPANSION_P (arg)
7107 && !template_parameter_pack_p (parm))
7109 error ("pack expansion argument for non-pack parameter "
7110 "%qD of alias template %qD", parm, in_decl);
7111 inform (DECL_SOURCE_LOCATION (parm), "declared here");
7118 return error_mark_node;
7121 /* We need to evaluate the template arguments, even though this
7122 template-id may be nested within a "sizeof". */
7123 saved_unevaluated_operand = cp_unevaluated_operand;
7124 cp_unevaluated_operand = 0;
7125 saved_inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
7126 c_inhibit_evaluation_warnings = 0;
7127 new_inner_args = make_tree_vec (nparms);
7128 new_args = add_outermost_template_args (args, new_inner_args);
7129 int pack_adjust = 0;
7130 for (parm_idx = 0, arg_idx = 0; parm_idx < nparms; parm_idx++, arg_idx++)
7135 /* Get the Ith template parameter. */
7136 parm = TREE_VEC_ELT (parms, parm_idx);
7138 if (parm == error_mark_node)
7140 TREE_VEC_ELT (new_inner_args, arg_idx) = error_mark_node;
7144 /* Calculate the next argument. */
7145 if (arg_idx < nargs)
7146 arg = TREE_VEC_ELT (inner_args, arg_idx);
7150 if (template_parameter_pack_p (TREE_VALUE (parm))
7151 && !(arg && ARGUMENT_PACK_P (arg)))
7153 /* Some arguments will be placed in the
7154 template parameter pack PARM. */
7155 arg = coerce_template_parameter_pack (parms, parm_idx, args,
7156 inner_args, arg_idx,
7160 if (arg == NULL_TREE)
7162 /* We don't know how many args we have yet, just use the
7163 unconverted (and still packed) ones for now. */
7164 new_inner_args = orig_inner_args;
7169 TREE_VEC_ELT (new_inner_args, parm_idx) = arg;
7171 /* Store this argument. */
7172 if (arg == error_mark_node)
7175 /* We are done with all of the arguments. */
7180 pack_adjust = TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) - 1;
7181 arg_idx += pack_adjust;
7188 if (PACK_EXPANSION_P (arg))
7190 /* "If every valid specialization of a variadic template
7191 requires an empty template parameter pack, the template is
7192 ill-formed, no diagnostic required." So check that the
7193 pattern works with this parameter. */
7194 tree pattern = PACK_EXPANSION_PATTERN (arg);
7195 tree conv = convert_template_argument (TREE_VALUE (parm),
7199 if (conv == error_mark_node)
7201 inform (input_location, "so any instantiation with a "
7202 "non-empty parameter pack would be ill-formed");
7205 else if (TYPE_P (conv) && !TYPE_P (pattern))
7206 /* Recover from missing typename. */
7207 TREE_VEC_ELT (inner_args, arg_idx)
7208 = make_pack_expansion (conv);
7210 /* We don't know how many args we have yet, just
7211 use the unconverted ones for now. */
7212 new_inner_args = inner_args;
7217 else if (require_all_args)
7219 /* There must be a default arg in this case. */
7220 arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
7222 /* The position of the first default template argument,
7223 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
7225 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args))
7226 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args,
7227 arg_idx - pack_adjust);
7232 if (arg == error_mark_node)
7234 if (complain & tf_error)
7235 error ("template argument %d is invalid", arg_idx + 1);
7238 /* This only occurs if there was an error in the template
7239 parameter list itself (which we would already have
7240 reported) that we are trying to recover from, e.g., a class
7241 template with a parameter list such as
7242 template<typename..., typename>. */
7245 arg = convert_template_argument (TREE_VALUE (parm),
7246 arg, new_args, complain,
7249 if (arg == error_mark_node)
7251 TREE_VEC_ELT (new_inner_args, arg_idx - pack_adjust) = arg;
7253 cp_unevaluated_operand = saved_unevaluated_operand;
7254 c_inhibit_evaluation_warnings = saved_inhibit_evaluation_warnings;
7256 if (variadic_p && arg_idx < nargs)
7258 if (complain & tf_error)
7260 error ("wrong number of template arguments "
7261 "(%d, should be %d)", nargs, arg_idx);
7263 error ("provided for %q+D", in_decl);
7265 return error_mark_node;
7269 return error_mark_node;
7271 #ifdef ENABLE_CHECKING
7272 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args))
7273 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args,
7274 TREE_VEC_LENGTH (new_inner_args));
7277 return new_inner_args;
7280 /* Like coerce_template_parms. If PARMS represents all template
7281 parameters levels, this function returns a vector of vectors
7282 representing all the resulting argument levels. Note that in this
7283 case, only the innermost arguments are coerced because the
7284 outermost ones are supposed to have been coerced already.
7286 Otherwise, if PARMS represents only (the innermost) vector of
7287 parameters, this function returns a vector containing just the
7288 innermost resulting arguments. */
7291 coerce_innermost_template_parms (tree parms,
7294 tsubst_flags_t complain,
7295 bool require_all_args,
7296 bool use_default_args)
7298 int parms_depth = TMPL_PARMS_DEPTH (parms);
7299 int args_depth = TMPL_ARGS_DEPTH (args);
7302 if (parms_depth > 1)
7304 coerced_args = make_tree_vec (parms_depth);
7308 for (level = parms, cur_depth = parms_depth;
7309 parms_depth > 0 && level != NULL_TREE;
7310 level = TREE_CHAIN (level), --cur_depth)
7313 if (cur_depth == args_depth)
7314 l = coerce_template_parms (TREE_VALUE (level),
7315 args, in_decl, complain,
7319 l = TMPL_ARGS_LEVEL (args, cur_depth);
7321 if (l == error_mark_node)
7322 return error_mark_node;
7324 SET_TMPL_ARGS_LEVEL (coerced_args, cur_depth, l);
7328 coerced_args = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parms),
7329 args, in_decl, complain,
7332 return coerced_args;
7335 /* Returns 1 if template args OT and NT are equivalent. */
7338 template_args_equal (tree ot, tree nt)
7342 if (nt == NULL_TREE || ot == NULL_TREE)
7345 if (TREE_CODE (nt) == TREE_VEC)
7346 /* For member templates */
7347 return TREE_CODE (ot) == TREE_VEC && comp_template_args (ot, nt);
7348 else if (PACK_EXPANSION_P (ot))
7349 return (PACK_EXPANSION_P (nt)
7350 && template_args_equal (PACK_EXPANSION_PATTERN (ot),
7351 PACK_EXPANSION_PATTERN (nt))
7352 && template_args_equal (PACK_EXPANSION_EXTRA_ARGS (ot),
7353 PACK_EXPANSION_EXTRA_ARGS (nt)));
7354 else if (ARGUMENT_PACK_P (ot))
7359 if (!ARGUMENT_PACK_P (nt))
7362 opack = ARGUMENT_PACK_ARGS (ot);
7363 npack = ARGUMENT_PACK_ARGS (nt);
7364 len = TREE_VEC_LENGTH (opack);
7365 if (TREE_VEC_LENGTH (npack) != len)
7367 for (i = 0; i < len; ++i)
7368 if (!template_args_equal (TREE_VEC_ELT (opack, i),
7369 TREE_VEC_ELT (npack, i)))
7373 else if (ot && TREE_CODE (ot) == ARGUMENT_PACK_SELECT)
7375 /* We get here probably because we are in the middle of substituting
7376 into the pattern of a pack expansion. In that case the
7377 ARGUMENT_PACK_SELECT temporarily replaces the pack argument we are
7378 interested in. So we want to use the initial pack argument for
7380 ot = ARGUMENT_PACK_SELECT_FROM_PACK (ot);
7381 if (nt && TREE_CODE (nt) == ARGUMENT_PACK_SELECT)
7382 nt = ARGUMENT_PACK_SELECT_FROM_PACK (nt);
7383 return template_args_equal (ot, nt);
7385 else if (TYPE_P (nt))
7389 /* Don't treat an alias template specialization with dependent
7390 arguments as equivalent to its underlying type when used as a
7391 template argument; we need them to be distinct so that we
7392 substitute into the specialization arguments at instantiation
7393 time. And aliases can't be equivalent without being ==, so
7394 we don't need to look any deeper. */
7395 if (TYPE_ALIAS_P (nt) || TYPE_ALIAS_P (ot))
7398 return same_type_p (ot, nt);
7400 else if (TREE_CODE (ot) == TREE_VEC || TYPE_P (ot))
7404 /* Try to treat a template non-type argument that has been converted
7405 to the parameter type as equivalent to one that hasn't yet. */
7406 for (enum tree_code code1 = TREE_CODE (ot);
7407 CONVERT_EXPR_CODE_P (code1)
7408 || code1 == NON_LVALUE_EXPR;
7409 code1 = TREE_CODE (ot))
7410 ot = TREE_OPERAND (ot, 0);
7411 for (enum tree_code code2 = TREE_CODE (nt);
7412 CONVERT_EXPR_CODE_P (code2)
7413 || code2 == NON_LVALUE_EXPR;
7414 code2 = TREE_CODE (nt))
7415 nt = TREE_OPERAND (nt, 0);
7417 return cp_tree_equal (ot, nt);
7421 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
7422 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
7423 NEWARG_PTR with the offending arguments if they are non-NULL. */
7426 comp_template_args_with_info (tree oldargs, tree newargs,
7427 tree *oldarg_ptr, tree *newarg_ptr)
7431 if (oldargs == newargs)
7434 if (!oldargs || !newargs)
7437 if (TREE_VEC_LENGTH (oldargs) != TREE_VEC_LENGTH (newargs))
7440 for (i = 0; i < TREE_VEC_LENGTH (oldargs); ++i)
7442 tree nt = TREE_VEC_ELT (newargs, i);
7443 tree ot = TREE_VEC_ELT (oldargs, i);
7445 if (! template_args_equal (ot, nt))
7447 if (oldarg_ptr != NULL)
7449 if (newarg_ptr != NULL)
7457 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets
7458 of template arguments. Returns 0 otherwise. */
7461 comp_template_args (tree oldargs, tree newargs)
7463 return comp_template_args_with_info (oldargs, newargs, NULL, NULL);
7467 add_pending_template (tree d)
7469 tree ti = (TYPE_P (d)
7470 ? CLASSTYPE_TEMPLATE_INFO (d)
7471 : DECL_TEMPLATE_INFO (d));
7472 struct pending_template *pt;
7475 if (TI_PENDING_TEMPLATE_FLAG (ti))
7478 /* We are called both from instantiate_decl, where we've already had a
7479 tinst_level pushed, and instantiate_template, where we haven't.
7481 level = !current_tinst_level || current_tinst_level->decl != d;
7484 push_tinst_level (d);
7486 pt = ggc_alloc<pending_template> ();
7488 pt->tinst = current_tinst_level;
7489 if (last_pending_template)
7490 last_pending_template->next = pt;
7492 pending_templates = pt;
7494 last_pending_template = pt;
7496 TI_PENDING_TEMPLATE_FLAG (ti) = 1;
7503 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
7504 ARGLIST. Valid choices for FNS are given in the cp-tree.def
7505 documentation for TEMPLATE_ID_EXPR. */
7508 lookup_template_function (tree fns, tree arglist)
7512 if (fns == error_mark_node || arglist == error_mark_node)
7513 return error_mark_node;
7515 gcc_assert (!arglist || TREE_CODE (arglist) == TREE_VEC);
7517 if (!is_overloaded_fn (fns) && !identifier_p (fns))
7519 error ("%q#D is not a function template", fns);
7520 return error_mark_node;
7523 if (BASELINK_P (fns))
7525 BASELINK_FUNCTIONS (fns) = build2 (TEMPLATE_ID_EXPR,
7527 BASELINK_FUNCTIONS (fns),
7532 type = TREE_TYPE (fns);
7533 if (TREE_CODE (fns) == OVERLOAD || !type)
7534 type = unknown_type_node;
7536 return build2 (TEMPLATE_ID_EXPR, type, fns, arglist);
7539 /* Within the scope of a template class S<T>, the name S gets bound
7540 (in build_self_reference) to a TYPE_DECL for the class, not a
7541 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
7542 or one of its enclosing classes, and that type is a template,
7543 return the associated TEMPLATE_DECL. Otherwise, the original
7546 Also handle the case when DECL is a TREE_LIST of ambiguous
7547 injected-class-names from different bases. */
7550 maybe_get_template_decl_from_type_decl (tree decl)
7552 if (decl == NULL_TREE)
7555 /* DR 176: A lookup that finds an injected-class-name (10.2
7556 [class.member.lookup]) can result in an ambiguity in certain cases
7557 (for example, if it is found in more than one base class). If all of
7558 the injected-class-names that are found refer to specializations of
7559 the same class template, and if the name is followed by a
7560 template-argument-list, the reference refers to the class template
7561 itself and not a specialization thereof, and is not ambiguous. */
7562 if (TREE_CODE (decl) == TREE_LIST)
7564 tree t, tmpl = NULL_TREE;
7565 for (t = decl; t; t = TREE_CHAIN (t))
7567 tree elt = maybe_get_template_decl_from_type_decl (TREE_VALUE (t));
7570 else if (tmpl != elt)
7573 if (tmpl && t == NULL_TREE)
7579 return (decl != NULL_TREE
7580 && DECL_SELF_REFERENCE_P (decl)
7581 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
7582 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl)) : decl;
7585 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
7586 parameters, find the desired type.
7588 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
7590 IN_DECL, if non-NULL, is the template declaration we are trying to
7593 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
7594 the class we are looking up.
7596 Issue error and warning messages under control of COMPLAIN.
7598 If the template class is really a local class in a template
7599 function, then the FUNCTION_CONTEXT is the function in which it is
7602 ??? Note that this function is currently called *twice* for each
7603 template-id: the first time from the parser, while creating the
7604 incomplete type (finish_template_type), and the second type during the
7605 real instantiation (instantiate_template_class). This is surely something
7606 that we want to avoid. It also causes some problems with argument
7607 coercion (see convert_nontype_argument for more information on this). */
7610 lookup_template_class_1 (tree d1, tree arglist, tree in_decl, tree context,
7611 int entering_scope, tsubst_flags_t complain)
7613 tree templ = NULL_TREE, parmlist;
7620 if (identifier_p (d1))
7622 tree value = innermost_non_namespace_value (d1);
7623 if (value && DECL_TEMPLATE_TEMPLATE_PARM_P (value))
7628 push_decl_namespace (context);
7629 templ = lookup_name (d1);
7630 templ = maybe_get_template_decl_from_type_decl (templ);
7632 pop_decl_namespace ();
7635 context = DECL_CONTEXT (templ);
7637 else if (TREE_CODE (d1) == TYPE_DECL && MAYBE_CLASS_TYPE_P (TREE_TYPE (d1)))
7639 tree type = TREE_TYPE (d1);
7641 /* If we are declaring a constructor, say A<T>::A<T>, we will get
7642 an implicit typename for the second A. Deal with it. */
7643 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
7644 type = TREE_TYPE (type);
7646 if (CLASSTYPE_TEMPLATE_INFO (type))
7648 templ = CLASSTYPE_TI_TEMPLATE (type);
7649 d1 = DECL_NAME (templ);
7652 else if (TREE_CODE (d1) == ENUMERAL_TYPE
7653 || (TYPE_P (d1) && MAYBE_CLASS_TYPE_P (d1)))
7655 templ = TYPE_TI_TEMPLATE (d1);
7656 d1 = DECL_NAME (templ);
7658 else if (DECL_TYPE_TEMPLATE_P (d1))
7661 d1 = DECL_NAME (templ);
7662 context = DECL_CONTEXT (templ);
7664 else if (DECL_TEMPLATE_TEMPLATE_PARM_P (d1))
7667 d1 = DECL_NAME (templ);
7670 /* Issue an error message if we didn't find a template. */
7673 if (complain & tf_error)
7674 error ("%qT is not a template", d1);
7675 return error_mark_node;
7678 if (TREE_CODE (templ) != TEMPLATE_DECL
7679 /* Make sure it's a user visible template, if it was named by
7681 || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (templ)
7682 && !PRIMARY_TEMPLATE_P (templ)))
7684 if (complain & tf_error)
7686 error ("non-template type %qT used as a template", d1);
7688 error ("for template declaration %q+D", in_decl);
7690 return error_mark_node;
7693 complain &= ~tf_user;
7695 /* An alias that just changes the name of a template is equivalent to the
7696 other template, so if any of the arguments are pack expansions, strip
7697 the alias to avoid problems with a pack expansion passed to a non-pack
7698 alias template parameter (DR 1430). */
7699 if (pack_expansion_args_count (INNERMOST_TEMPLATE_ARGS (arglist)))
7700 templ = get_underlying_template (templ);
7702 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ))
7704 /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
7705 template arguments */
7711 parmlist = DECL_INNERMOST_TEMPLATE_PARMS (templ);
7713 /* Consider an example where a template template parameter declared as
7715 template <class T, class U = std::allocator<T> > class TT
7717 The template parameter level of T and U are one level larger than
7718 of TT. To proper process the default argument of U, say when an
7719 instantiation `TT<int>' is seen, we need to build the full
7720 arguments containing {int} as the innermost level. Outer levels,
7721 available when not appearing as default template argument, can be
7722 obtained from the arguments of the enclosing template.
7724 Suppose that TT is later substituted with std::vector. The above
7725 instantiation is `TT<int, std::allocator<T> >' with TT at
7726 level 1, and T at level 2, while the template arguments at level 1
7727 becomes {std::vector} and the inner level 2 is {int}. */
7729 outer = DECL_CONTEXT (templ);
7731 outer = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer)));
7732 else if (current_template_parms)
7733 /* This is an argument of the current template, so we haven't set
7734 DECL_CONTEXT yet. */
7735 outer = current_template_args ();
7738 arglist = add_to_template_args (outer, arglist);
7740 arglist2 = coerce_template_parms (parmlist, arglist, templ,
7742 /*require_all_args=*/true,
7743 /*use_default_args=*/true);
7744 if (arglist2 == error_mark_node
7745 || (!uses_template_parms (arglist2)
7746 && check_instantiated_args (templ, arglist2, complain)))
7747 return error_mark_node;
7749 parm = bind_template_template_parm (TREE_TYPE (templ), arglist2);
7754 tree template_type = TREE_TYPE (templ);
7757 tree found = NULL_TREE;
7760 int is_dependent_type;
7761 int use_partial_inst_tmpl = false;
7763 if (template_type == error_mark_node)
7764 /* An error occurred while building the template TEMPL, and a
7765 diagnostic has most certainly been emitted for that
7766 already. Let's propagate that error. */
7767 return error_mark_node;
7769 gen_tmpl = most_general_template (templ);
7770 parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
7771 parm_depth = TMPL_PARMS_DEPTH (parmlist);
7772 arg_depth = TMPL_ARGS_DEPTH (arglist);
7774 if (arg_depth == 1 && parm_depth > 1)
7776 /* We've been given an incomplete set of template arguments.
7779 template <class T> struct S1 {
7780 template <class U> struct S2 {};
7781 template <class U> struct S2<U*> {};
7784 we will be called with an ARGLIST of `U*', but the
7785 TEMPLATE will be `template <class T> template
7786 <class U> struct S1<T>::S2'. We must fill in the missing
7789 = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (templ)),
7791 arg_depth = TMPL_ARGS_DEPTH (arglist);
7794 /* Now we should have enough arguments. */
7795 gcc_assert (parm_depth == arg_depth);
7797 /* From here on, we're only interested in the most general
7800 /* Calculate the BOUND_ARGS. These will be the args that are
7801 actually tsubst'd into the definition to create the
7805 /* We have multiple levels of arguments to coerce, at once. */
7807 int saved_depth = TMPL_ARGS_DEPTH (arglist);
7809 tree bound_args = make_tree_vec (parm_depth);
7811 for (i = saved_depth,
7812 t = DECL_TEMPLATE_PARMS (gen_tmpl);
7813 i > 0 && t != NULL_TREE;
7814 --i, t = TREE_CHAIN (t))
7817 if (i == saved_depth)
7818 a = coerce_template_parms (TREE_VALUE (t),
7821 /*require_all_args=*/true,
7822 /*use_default_args=*/true);
7824 /* Outer levels should have already been coerced. */
7825 a = TMPL_ARGS_LEVEL (arglist, i);
7827 /* Don't process further if one of the levels fails. */
7828 if (a == error_mark_node)
7830 /* Restore the ARGLIST to its full size. */
7831 TREE_VEC_LENGTH (arglist) = saved_depth;
7832 return error_mark_node;
7835 SET_TMPL_ARGS_LEVEL (bound_args, i, a);
7837 /* We temporarily reduce the length of the ARGLIST so
7838 that coerce_template_parms will see only the arguments
7839 corresponding to the template parameters it is
7841 TREE_VEC_LENGTH (arglist)--;
7844 /* Restore the ARGLIST to its full size. */
7845 TREE_VEC_LENGTH (arglist) = saved_depth;
7847 arglist = bound_args;
7851 = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist),
7852 INNERMOST_TEMPLATE_ARGS (arglist),
7855 /*require_all_args=*/true,
7856 /*use_default_args=*/true);
7858 if (arglist == error_mark_node)
7859 /* We were unable to bind the arguments. */
7860 return error_mark_node;
7862 /* In the scope of a template class, explicit references to the
7863 template class refer to the type of the template, not any
7864 instantiation of it. For example, in:
7866 template <class T> class C { void f(C<T>); }
7868 the `C<T>' is just the same as `C'. Outside of the
7869 class, however, such a reference is an instantiation. */
7871 || !PRIMARY_TEMPLATE_P (gen_tmpl)
7872 || currently_open_class (template_type))
7873 /* comp_template_args is expensive, check it last. */
7874 && comp_template_args (TYPE_TI_ARGS (template_type),
7876 return template_type;
7878 /* If we already have this specialization, return it. */
7879 elt.tmpl = gen_tmpl;
7881 hash = spec_hasher::hash (&elt);
7882 entry = type_specializations->find_with_hash (&elt, hash);
7887 is_dependent_type = uses_template_parms (arglist);
7889 /* If the deduced arguments are invalid, then the binding
7891 if (!is_dependent_type
7892 && check_instantiated_args (gen_tmpl,
7893 INNERMOST_TEMPLATE_ARGS (arglist),
7895 return error_mark_node;
7897 if (!is_dependent_type
7898 && !PRIMARY_TEMPLATE_P (gen_tmpl)
7899 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl))
7900 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl)) == NAMESPACE_DECL)
7902 found = xref_tag_from_type (TREE_TYPE (gen_tmpl),
7903 DECL_NAME (gen_tmpl),
7904 /*tag_scope=*/ts_global);
7908 context = tsubst (DECL_CONTEXT (gen_tmpl), arglist,
7910 if (context == error_mark_node)
7911 return error_mark_node;
7914 context = global_namespace;
7916 /* Create the type. */
7917 if (DECL_ALIAS_TEMPLATE_P (gen_tmpl))
7919 /* The user referred to a specialization of an alias
7920 template represented by GEN_TMPL.
7922 [temp.alias]/2 says:
7924 When a template-id refers to the specialization of an
7925 alias template, it is equivalent to the associated
7926 type obtained by substitution of its
7927 template-arguments for the template-parameters in the
7928 type-id of the alias template. */
7930 t = tsubst (TREE_TYPE (gen_tmpl), arglist, complain, in_decl);
7931 /* Note that the call above (by indirectly calling
7932 register_specialization in tsubst_decl) registers the
7933 TYPE_DECL representing the specialization of the alias
7934 template. So next time someone substitutes ARGLIST for
7935 the template parms into the alias template (GEN_TMPL),
7936 she'll get that TYPE_DECL back. */
7938 if (t == error_mark_node)
7941 else if (TREE_CODE (template_type) == ENUMERAL_TYPE)
7943 if (!is_dependent_type)
7945 set_current_access_from_decl (TYPE_NAME (template_type));
7946 t = start_enum (TYPE_IDENTIFIER (template_type), NULL_TREE,
7947 tsubst (ENUM_UNDERLYING_TYPE (template_type),
7948 arglist, complain, in_decl),
7949 SCOPED_ENUM_P (template_type), NULL);
7951 if (t == error_mark_node)
7956 /* We don't want to call start_enum for this type, since
7957 the values for the enumeration constants may involve
7958 template parameters. And, no one should be interested
7959 in the enumeration constants for such a type. */
7960 t = cxx_make_type (ENUMERAL_TYPE);
7961 SET_SCOPED_ENUM_P (t, SCOPED_ENUM_P (template_type));
7963 SET_OPAQUE_ENUM_P (t, OPAQUE_ENUM_P (template_type));
7964 ENUM_FIXED_UNDERLYING_TYPE_P (t)
7965 = ENUM_FIXED_UNDERLYING_TYPE_P (template_type);
7967 else if (CLASS_TYPE_P (template_type))
7969 t = make_class_type (TREE_CODE (template_type));
7970 CLASSTYPE_DECLARED_CLASS (t)
7971 = CLASSTYPE_DECLARED_CLASS (template_type);
7972 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t);
7973 TYPE_FOR_JAVA (t) = TYPE_FOR_JAVA (template_type);
7975 /* A local class. Make sure the decl gets registered properly. */
7976 if (context == current_function_decl)
7977 pushtag (DECL_NAME (gen_tmpl), t, /*tag_scope=*/ts_current);
7979 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type), arglist))
7980 /* This instantiation is another name for the primary
7981 template type. Set the TYPE_CANONICAL field
7983 TYPE_CANONICAL (t) = template_type;
7984 else if (any_template_arguments_need_structural_equality_p (arglist))
7985 /* Some of the template arguments require structural
7986 equality testing, so this template class requires
7987 structural equality testing. */
7988 SET_TYPE_STRUCTURAL_EQUALITY (t);
7993 /* If we called start_enum or pushtag above, this information
7994 will already be set up. */
7997 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
7999 type_decl = create_implicit_typedef (DECL_NAME (gen_tmpl), t);
8000 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
8001 DECL_SOURCE_LOCATION (type_decl)
8002 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type));
8005 type_decl = TYPE_NAME (t);
8007 if (CLASS_TYPE_P (template_type))
8009 TREE_PRIVATE (type_decl)
8010 = TREE_PRIVATE (TYPE_MAIN_DECL (template_type));
8011 TREE_PROTECTED (type_decl)
8012 = TREE_PROTECTED (TYPE_MAIN_DECL (template_type));
8013 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type))
8015 DECL_VISIBILITY_SPECIFIED (type_decl) = 1;
8016 DECL_VISIBILITY (type_decl) = CLASSTYPE_VISIBILITY (template_type);
8020 if (OVERLOAD_TYPE_P (t)
8021 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl))
8024 = lookup_attribute ("abi_tag", TYPE_ATTRIBUTES (template_type)))
8026 if (!TREE_CHAIN (attributes))
8027 TYPE_ATTRIBUTES (t) = attributes;
8030 = build_tree_list (TREE_PURPOSE (attributes),
8031 TREE_VALUE (attributes));
8035 /* Let's consider the explicit specialization of a member
8036 of a class template specialization that is implicitly instantiated,
8041 template<class U> struct M {}; //#0
8046 struct S<int>::M<char> //#1
8050 [temp.expl.spec]/4 says this is valid.
8052 In this case, when we write:
8055 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
8058 When we encounter #1, we want to store the partial instantiation
8059 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
8061 For all cases other than this "explicit specialization of member of a
8062 class template", we just want to store the most general template into
8063 the CLASSTYPE_TI_TEMPLATE of M.
8065 This case of "explicit specialization of member of a class template"
8067 1/ the enclosing class is an instantiation of, and therefore not
8068 the same as, the context of the most general template, and
8069 2/ we aren't looking at the partial instantiation itself, i.e.
8070 the innermost arguments are not the same as the innermost parms of
8071 the most general template.
8073 So it's only when 1/ and 2/ happens that we want to use the partial
8074 instantiation of the member template in lieu of its most general
8077 if (PRIMARY_TEMPLATE_P (gen_tmpl)
8078 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist)
8079 /* the enclosing class must be an instantiation... */
8080 && CLASS_TYPE_P (context)
8081 && !same_type_p (context, DECL_CONTEXT (gen_tmpl)))
8083 tree partial_inst_args;
8084 TREE_VEC_LENGTH (arglist)--;
8085 ++processing_template_decl;
8087 tsubst (INNERMOST_TEMPLATE_ARGS
8088 (TYPE_TI_ARGS (TREE_TYPE (gen_tmpl))),
8089 arglist, complain, NULL_TREE);
8090 --processing_template_decl;
8091 TREE_VEC_LENGTH (arglist)++;
8092 use_partial_inst_tmpl =
8093 /*...and we must not be looking at the partial instantiation
8095 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist),
8099 if (!use_partial_inst_tmpl)
8100 /* This case is easy; there are no member templates involved. */
8104 /* This is a full instantiation of a member template. Find
8105 the partial instantiation of which this is an instance. */
8107 /* Temporarily reduce by one the number of levels in the ARGLIST
8108 so as to avoid comparing the last set of arguments. */
8109 TREE_VEC_LENGTH (arglist)--;
8110 found = tsubst (gen_tmpl, arglist, complain, NULL_TREE);
8111 TREE_VEC_LENGTH (arglist)++;
8112 /* FOUND is either a proper class type, or an alias
8113 template specialization. In the later case, it's a
8114 TYPE_DECL, resulting from the substituting of arguments
8115 for parameters in the TYPE_DECL of the alias template
8116 done earlier. So be careful while getting the template
8118 found = TREE_CODE (found) == TYPE_DECL
8119 ? TYPE_TI_TEMPLATE (TREE_TYPE (found))
8120 : CLASSTYPE_TI_TEMPLATE (found);
8123 SET_TYPE_TEMPLATE_INFO (t, build_template_info (found, arglist));
8126 slot = type_specializations->find_slot_with_hash (&elt, hash, INSERT);
8127 entry = ggc_alloc<spec_entry> ();
8131 /* Note this use of the partial instantiation so we can check it
8132 later in maybe_process_partial_specialization. */
8133 DECL_TEMPLATE_INSTANTIATIONS (found)
8134 = tree_cons (arglist, t,
8135 DECL_TEMPLATE_INSTANTIATIONS (found));
8137 if (TREE_CODE (template_type) == ENUMERAL_TYPE && !is_dependent_type
8138 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl))
8139 /* Now that the type has been registered on the instantiations
8140 list, we set up the enumerators. Because the enumeration
8141 constants may involve the enumeration type itself, we make
8142 sure to register the type first, and then create the
8143 constants. That way, doing tsubst_expr for the enumeration
8144 constants won't result in recursive calls here; we'll find
8145 the instantiation and exit above. */
8146 tsubst_enum (template_type, t, arglist);
8148 if (CLASS_TYPE_P (template_type) && is_dependent_type)
8149 /* If the type makes use of template parameters, the
8150 code that generates debugging information will crash. */
8151 DECL_IGNORED_P (TYPE_MAIN_DECL (t)) = 1;
8153 /* Possibly limit visibility based on template args. */
8154 TREE_PUBLIC (type_decl) = 1;
8155 determine_visibility (type_decl);
8157 inherit_targ_abi_tags (t);
8163 /* Wrapper for lookup_template_class_1. */
8166 lookup_template_class (tree d1, tree arglist, tree in_decl, tree context,
8167 int entering_scope, tsubst_flags_t complain)
8170 timevar_push (TV_TEMPLATE_INST);
8171 ret = lookup_template_class_1 (d1, arglist, in_decl, context,
8172 entering_scope, complain);
8173 timevar_pop (TV_TEMPLATE_INST);
8177 /* Return a TEMPLATE_ID_EXPR for the given variable template and ARGLIST.
8178 The type of the expression is the unknown_type_node since the
8179 template-id could refer to an explicit or partial specialization. */
8182 lookup_template_variable (tree templ, tree arglist)
8184 tree type = NULL_TREE;
8185 return build2 (TEMPLATE_ID_EXPR, type, templ, arglist);
8188 /* Instantiate a variable declaration from a TEMPLATE_ID_EXPR for use. */
8191 finish_template_variable (tree var, tsubst_flags_t complain)
8193 tree templ = TREE_OPERAND (var, 0);
8195 tree arglist = TREE_OPERAND (var, 1);
8196 tree tmpl_args = DECL_TI_ARGS (DECL_TEMPLATE_RESULT (templ));
8197 arglist = add_outermost_template_args (tmpl_args, arglist);
8199 tree parms = DECL_TEMPLATE_PARMS (templ);
8200 arglist = coerce_innermost_template_parms (parms, arglist, templ, complain,
8202 /*use_default*/true);
8204 return instantiate_template (templ, arglist, complain);
8211 /* True when we should also visit template parameters that occur in
8212 non-deduced contexts. */
8213 bool include_nondeduced_p;
8214 hash_set<tree> *visited;
8217 /* Called from for_each_template_parm via walk_tree. */
8220 for_each_template_parm_r (tree *tp, int *walk_subtrees, void *d)
8223 struct pair_fn_data *pfd = (struct pair_fn_data *) d;
8224 tree_fn_t fn = pfd->fn;
8225 void *data = pfd->data;
8228 && (pfd->include_nondeduced_p || TREE_CODE (t) != TYPENAME_TYPE)
8229 && for_each_template_parm (TYPE_CONTEXT (t), fn, data, pfd->visited,
8230 pfd->include_nondeduced_p))
8231 return error_mark_node;
8233 switch (TREE_CODE (t))
8236 if (TYPE_PTRMEMFUNC_P (t))
8242 if (!TYPE_TEMPLATE_INFO (t))
8244 else if (for_each_template_parm (TYPE_TI_ARGS (t),
8245 fn, data, pfd->visited,
8246 pfd->include_nondeduced_p))
8247 return error_mark_node;
8251 if (for_each_template_parm (TYPE_MIN_VALUE (t),
8252 fn, data, pfd->visited,
8253 pfd->include_nondeduced_p)
8254 || for_each_template_parm (TYPE_MAX_VALUE (t),
8255 fn, data, pfd->visited,
8256 pfd->include_nondeduced_p))
8257 return error_mark_node;
8261 /* Since we're not going to walk subtrees, we have to do this
8263 if (for_each_template_parm (TYPE_METHOD_BASETYPE (t), fn, data,
8264 pfd->visited, pfd->include_nondeduced_p))
8265 return error_mark_node;
8269 /* Check the return type. */
8270 if (for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited,
8271 pfd->include_nondeduced_p))
8272 return error_mark_node;
8274 /* Check the parameter types. Since default arguments are not
8275 instantiated until they are needed, the TYPE_ARG_TYPES may
8276 contain expressions that involve template parameters. But,
8277 no-one should be looking at them yet. And, once they're
8278 instantiated, they don't contain template parameters, so
8279 there's no point in looking at them then, either. */
8283 for (parm = TYPE_ARG_TYPES (t); parm; parm = TREE_CHAIN (parm))
8284 if (for_each_template_parm (TREE_VALUE (parm), fn, data,
8285 pfd->visited, pfd->include_nondeduced_p))
8286 return error_mark_node;
8288 /* Since we've already handled the TYPE_ARG_TYPES, we don't
8289 want walk_tree walking into them itself. */
8295 case UNDERLYING_TYPE:
8296 if (pfd->include_nondeduced_p
8297 && for_each_template_parm (TYPE_VALUES_RAW (t), fn, data,
8299 pfd->include_nondeduced_p))
8300 return error_mark_node;
8305 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t)
8306 && for_each_template_parm (DECL_TI_ARGS (t), fn, data,
8307 pfd->visited, pfd->include_nondeduced_p))
8308 return error_mark_node;
8313 if (TREE_CODE (t) == CONST_DECL && DECL_TEMPLATE_PARM_P (t)
8314 && for_each_template_parm (DECL_INITIAL (t), fn, data,
8315 pfd->visited, pfd->include_nondeduced_p))
8316 return error_mark_node;
8317 if (DECL_CONTEXT (t)
8318 && pfd->include_nondeduced_p
8319 && for_each_template_parm (DECL_CONTEXT (t), fn, data,
8320 pfd->visited, pfd->include_nondeduced_p))
8321 return error_mark_node;
8324 case BOUND_TEMPLATE_TEMPLATE_PARM:
8325 /* Record template parameters such as `T' inside `TT<T>'. */
8326 if (for_each_template_parm (TYPE_TI_ARGS (t), fn, data, pfd->visited,
8327 pfd->include_nondeduced_p))
8328 return error_mark_node;
8331 case TEMPLATE_TEMPLATE_PARM:
8332 case TEMPLATE_TYPE_PARM:
8333 case TEMPLATE_PARM_INDEX:
8334 if (fn && (*fn)(t, data))
8335 return error_mark_node;
8337 return error_mark_node;
8341 /* A template template parameter is encountered. */
8342 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)
8343 && for_each_template_parm (TREE_TYPE (t), fn, data, pfd->visited,
8344 pfd->include_nondeduced_p))
8345 return error_mark_node;
8347 /* Already substituted template template parameter */
8353 || for_each_template_parm (TYPENAME_TYPE_FULLNAME (t), fn,
8355 pfd->include_nondeduced_p))
8356 return error_mark_node;
8360 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))
8361 && pfd->include_nondeduced_p
8362 && for_each_template_parm (TYPE_PTRMEMFUNC_FN_TYPE
8363 (TREE_TYPE (t)), fn, data,
8364 pfd->visited, pfd->include_nondeduced_p))
8365 return error_mark_node;
8370 /* If there's no type, then this thing must be some expression
8371 involving template parameters. */
8372 if (!fn && !TREE_TYPE (t))
8373 return error_mark_node;
8378 case IMPLICIT_CONV_EXPR:
8379 case REINTERPRET_CAST_EXPR:
8380 case CONST_CAST_EXPR:
8381 case STATIC_CAST_EXPR:
8382 case DYNAMIC_CAST_EXPR:
8386 case PSEUDO_DTOR_EXPR:
8388 return error_mark_node;
8395 /* We didn't find any template parameters we liked. */
8399 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
8400 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
8401 call FN with the parameter and the DATA.
8402 If FN returns nonzero, the iteration is terminated, and
8403 for_each_template_parm returns 1. Otherwise, the iteration
8404 continues. If FN never returns a nonzero value, the value
8405 returned by for_each_template_parm is 0. If FN is NULL, it is
8406 considered to be the function which always returns 1.
8408 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
8409 parameters that occur in non-deduced contexts. When false, only
8410 visits those template parameters that can be deduced. */
8413 for_each_template_parm (tree t, tree_fn_t fn, void* data,
8414 hash_set<tree> *visited,
8415 bool include_nondeduced_p)
8417 struct pair_fn_data pfd;
8423 pfd.include_nondeduced_p = include_nondeduced_p;
8425 /* Walk the tree. (Conceptually, we would like to walk without
8426 duplicates, but for_each_template_parm_r recursively calls
8427 for_each_template_parm, so we would need to reorganize a fair
8428 bit to use walk_tree_without_duplicates, so we keep our own
8431 pfd.visited = visited;
8433 pfd.visited = new hash_set<tree>;
8434 result = cp_walk_tree (&t,
8435 for_each_template_parm_r,
8437 pfd.visited) != NULL_TREE;
8449 /* Returns true if T depends on any template parameter. */
8452 uses_template_parms (tree t)
8458 int saved_processing_template_decl;
8460 saved_processing_template_decl = processing_template_decl;
8461 if (!saved_processing_template_decl)
8462 processing_template_decl = 1;
8464 dependent_p = dependent_type_p (t);
8465 else if (TREE_CODE (t) == TREE_VEC)
8466 dependent_p = any_dependent_template_arguments_p (t);
8467 else if (TREE_CODE (t) == TREE_LIST)
8468 dependent_p = (uses_template_parms (TREE_VALUE (t))
8469 || uses_template_parms (TREE_CHAIN (t)));
8470 else if (TREE_CODE (t) == TYPE_DECL)
8471 dependent_p = dependent_type_p (TREE_TYPE (t));
8474 || TREE_CODE (t) == TEMPLATE_PARM_INDEX
8475 || TREE_CODE (t) == OVERLOAD
8478 || TREE_CODE (t) == TRAIT_EXPR
8479 || TREE_CODE (t) == CONSTRUCTOR
8480 || CONSTANT_CLASS_P (t))
8481 dependent_p = (type_dependent_expression_p (t)
8482 || value_dependent_expression_p (t));
8485 gcc_assert (t == error_mark_node);
8486 dependent_p = false;
8489 processing_template_decl = saved_processing_template_decl;
8494 /* Returns true iff current_function_decl is an incompletely instantiated
8495 template. Useful instead of processing_template_decl because the latter
8496 is set to 0 during instantiate_non_dependent_expr. */
8499 in_template_function (void)
8501 tree fn = current_function_decl;
8503 ++processing_template_decl;
8504 ret = (fn && DECL_LANG_SPECIFIC (fn)
8505 && DECL_TEMPLATE_INFO (fn)
8506 && any_dependent_template_arguments_p (DECL_TI_ARGS (fn)));
8507 --processing_template_decl;
8511 /* Returns true if T depends on any template parameter with level LEVEL. */
8514 uses_template_parms_level (tree t, int level)
8516 return for_each_template_parm (t, template_parm_this_level_p, &level, NULL,
8517 /*include_nondeduced_p=*/true);
8520 /* Returns TRUE iff INST is an instantiation we don't need to do in an
8521 ill-formed translation unit, i.e. a variable or function that isn't
8522 usable in a constant expression. */
8525 neglectable_inst_p (tree d)
8528 && !(TREE_CODE (d) == FUNCTION_DECL ? DECL_DECLARED_CONSTEXPR_P (d)
8529 : decl_maybe_constant_var_p (d)));
8532 /* Returns TRUE iff we should refuse to instantiate DECL because it's
8533 neglectable and instantiated from within an erroneous instantiation. */
8536 limit_bad_template_recursion (tree decl)
8538 struct tinst_level *lev = current_tinst_level;
8539 int errs = errorcount + sorrycount;
8540 if (lev == NULL || errs == 0 || !neglectable_inst_p (decl))
8543 for (; lev; lev = lev->next)
8544 if (neglectable_inst_p (lev->decl))
8547 return (lev && errs > lev->errors);
8550 static int tinst_depth;
8551 extern int max_tinst_depth;
8554 static GTY(()) struct tinst_level *last_error_tinst_level;
8556 /* We're starting to instantiate D; record the template instantiation context
8557 for diagnostics and to restore it later. */
8560 push_tinst_level (tree d)
8562 return push_tinst_level_loc (d, input_location);
8565 /* We're starting to instantiate D; record the template instantiation context
8566 at LOC for diagnostics and to restore it later. */
8569 push_tinst_level_loc (tree d, location_t loc)
8571 struct tinst_level *new_level;
8573 if (tinst_depth >= max_tinst_depth)
8575 fatal_error (input_location,
8576 "template instantiation depth exceeds maximum of %d"
8577 " (use -ftemplate-depth= to increase the maximum)",
8582 /* If the current instantiation caused problems, don't let it instantiate
8583 anything else. Do allow deduction substitution and decls usable in
8584 constant expressions. */
8585 if (limit_bad_template_recursion (d))
8588 new_level = ggc_alloc<tinst_level> ();
8589 new_level->decl = d;
8590 new_level->locus = loc;
8591 new_level->errors = errorcount+sorrycount;
8592 new_level->in_system_header_p = in_system_header_at (input_location);
8593 new_level->next = current_tinst_level;
8594 current_tinst_level = new_level;
8597 if (GATHER_STATISTICS && (tinst_depth > depth_reached))
8598 depth_reached = tinst_depth;
8603 /* We're done instantiating this template; return to the instantiation
8607 pop_tinst_level (void)
8609 /* Restore the filename and line number stashed away when we started
8610 this instantiation. */
8611 input_location = current_tinst_level->locus;
8612 current_tinst_level = current_tinst_level->next;
8616 /* We're instantiating a deferred template; restore the template
8617 instantiation context in which the instantiation was requested, which
8618 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
8621 reopen_tinst_level (struct tinst_level *level)
8623 struct tinst_level *t;
8626 for (t = level; t; t = t->next)
8629 current_tinst_level = level;
8631 if (current_tinst_level)
8632 current_tinst_level->errors = errorcount+sorrycount;
8636 /* Returns the TINST_LEVEL which gives the original instantiation
8639 struct tinst_level *
8640 outermost_tinst_level (void)
8642 struct tinst_level *level = current_tinst_level;
8645 level = level->next;
8649 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
8650 vector of template arguments, as for tsubst.
8652 Returns an appropriate tsubst'd friend declaration. */
8655 tsubst_friend_function (tree decl, tree args)
8659 if (TREE_CODE (decl) == FUNCTION_DECL
8660 && DECL_TEMPLATE_INSTANTIATION (decl)
8661 && TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
8662 /* This was a friend declared with an explicit template
8663 argument list, e.g.:
8667 to indicate that f was a template instantiation, not a new
8668 function declaration. Now, we have to figure out what
8669 instantiation of what template. */
8671 tree template_id, arglist, fns;
8674 tree ns = decl_namespace_context (TYPE_MAIN_DECL (current_class_type));
8676 /* Friend functions are looked up in the containing namespace scope.
8677 We must enter that scope, to avoid finding member functions of the
8678 current class with same name. */
8679 push_nested_namespace (ns);
8680 fns = tsubst_expr (DECL_TI_TEMPLATE (decl), args,
8681 tf_warning_or_error, NULL_TREE,
8682 /*integral_constant_expression_p=*/false);
8683 pop_nested_namespace (ns);
8684 arglist = tsubst (DECL_TI_ARGS (decl), args,
8685 tf_warning_or_error, NULL_TREE);
8686 template_id = lookup_template_function (fns, arglist);
8688 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
8689 tmpl = determine_specialization (template_id, new_friend,
8691 /*need_member_template=*/0,
8692 TREE_VEC_LENGTH (args),
8694 return instantiate_template (tmpl, new_args, tf_error);
8697 new_friend = tsubst (decl, args, tf_warning_or_error, NULL_TREE);
8699 /* The NEW_FRIEND will look like an instantiation, to the
8700 compiler, but is not an instantiation from the point of view of
8701 the language. For example, we might have had:
8703 template <class T> struct S {
8704 template <class U> friend void f(T, U);
8707 Then, in S<int>, template <class U> void f(int, U) is not an
8708 instantiation of anything. */
8709 if (new_friend == error_mark_node)
8710 return error_mark_node;
8712 DECL_USE_TEMPLATE (new_friend) = 0;
8713 if (TREE_CODE (decl) == TEMPLATE_DECL)
8715 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend)) = 0;
8716 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend))
8717 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
8720 /* The mangled name for the NEW_FRIEND is incorrect. The function
8721 is not a template instantiation and should not be mangled like
8722 one. Therefore, we forget the mangling here; we'll recompute it
8723 later if we need it. */
8724 if (TREE_CODE (new_friend) != TEMPLATE_DECL)
8726 SET_DECL_RTL (new_friend, NULL);
8727 SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE);
8730 if (DECL_NAMESPACE_SCOPE_P (new_friend))
8733 tree new_friend_template_info;
8734 tree new_friend_result_template_info;
8736 int new_friend_is_defn;
8738 /* We must save some information from NEW_FRIEND before calling
8739 duplicate decls since that function will free NEW_FRIEND if
8741 new_friend_template_info = DECL_TEMPLATE_INFO (new_friend);
8742 new_friend_is_defn =
8743 (DECL_INITIAL (DECL_TEMPLATE_RESULT
8744 (template_for_substitution (new_friend)))
8746 if (TREE_CODE (new_friend) == TEMPLATE_DECL)
8748 /* This declaration is a `primary' template. */
8749 DECL_PRIMARY_TEMPLATE (new_friend) = new_friend;
8751 new_friend_result_template_info
8752 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend));
8755 new_friend_result_template_info = NULL_TREE;
8757 /* Make the init_value nonzero so pushdecl knows this is a defn. */
8758 if (new_friend_is_defn)
8759 DECL_INITIAL (new_friend) = error_mark_node;
8761 /* Inside pushdecl_namespace_level, we will push into the
8762 current namespace. However, the friend function should go
8763 into the namespace of the template. */
8764 ns = decl_namespace_context (new_friend);
8765 push_nested_namespace (ns);
8766 old_decl = pushdecl_namespace_level (new_friend, /*is_friend=*/true);
8767 pop_nested_namespace (ns);
8769 if (old_decl == error_mark_node)
8770 return error_mark_node;
8772 if (old_decl != new_friend)
8774 /* This new friend declaration matched an existing
8775 declaration. For example, given:
8777 template <class T> void f(T);
8778 template <class U> class C {
8779 template <class T> friend void f(T) {}
8782 the friend declaration actually provides the definition
8783 of `f', once C has been instantiated for some type. So,
8784 old_decl will be the out-of-class template declaration,
8785 while new_friend is the in-class definition.
8787 But, if `f' was called before this point, the
8788 instantiation of `f' will have DECL_TI_ARGS corresponding
8789 to `T' but not to `U', references to which might appear
8790 in the definition of `f'. Previously, the most general
8791 template for an instantiation of `f' was the out-of-class
8792 version; now it is the in-class version. Therefore, we
8793 run through all specialization of `f', adding to their
8794 DECL_TI_ARGS appropriately. In particular, they need a
8795 new set of outer arguments, corresponding to the
8796 arguments for this class instantiation.
8798 The same situation can arise with something like this:
8801 template <class T> class C {
8805 when `C<int>' is instantiated. Now, `f(int)' is defined
8808 if (!new_friend_is_defn)
8809 /* On the other hand, if the in-class declaration does
8810 *not* provide a definition, then we don't want to alter
8811 existing definitions. We can just leave everything
8816 tree new_template = TI_TEMPLATE (new_friend_template_info);
8817 tree new_args = TI_ARGS (new_friend_template_info);
8819 /* Overwrite whatever template info was there before, if
8820 any, with the new template information pertaining to
8822 DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
8824 if (TREE_CODE (old_decl) != TEMPLATE_DECL)
8826 /* We should have called reregister_specialization in
8828 gcc_assert (retrieve_specialization (new_template,
8832 /* Instantiate it if the global has already been used. */
8833 if (DECL_ODR_USED (old_decl))
8834 instantiate_decl (old_decl, /*defer_ok=*/true,
8835 /*expl_inst_class_mem_p=*/false);
8841 /* Indicate that the old function template is a partial
8843 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl))
8844 = new_friend_result_template_info;
8846 gcc_assert (new_template
8847 == most_general_template (new_template));
8848 gcc_assert (new_template != old_decl);
8850 /* Reassign any specializations already in the hash table
8851 to the new more general template, and add the
8852 additional template args. */
8853 for (t = DECL_TEMPLATE_INSTANTIATIONS (old_decl);
8857 tree spec = TREE_VALUE (t);
8860 elt.tmpl = old_decl;
8861 elt.args = DECL_TI_ARGS (spec);
8862 elt.spec = NULL_TREE;
8864 decl_specializations->remove_elt (&elt);
8867 = add_outermost_template_args (new_args,
8868 DECL_TI_ARGS (spec));
8870 register_specialization
8871 (spec, new_template, DECL_TI_ARGS (spec), true, 0);
8874 DECL_TEMPLATE_INSTANTIATIONS (old_decl) = NULL_TREE;
8878 /* The information from NEW_FRIEND has been merged into OLD_DECL
8879 by duplicate_decls. */
8880 new_friend = old_decl;
8885 tree context = DECL_CONTEXT (new_friend);
8889 template <class T> class C {
8890 template <class U> friend void C1<U>::f (); // case 1
8891 friend void C2<T>::f (); // case 2
8893 we only need to make sure CONTEXT is a complete type for
8894 case 2. To distinguish between the two cases, we note that
8895 CONTEXT of case 1 remains dependent type after tsubst while
8896 this isn't true for case 2. */
8897 ++processing_template_decl;
8898 dependent_p = dependent_type_p (context);
8899 --processing_template_decl;
8902 && !complete_type_or_else (context, NULL_TREE))
8903 return error_mark_node;
8905 if (COMPLETE_TYPE_P (context))
8907 tree fn = new_friend;
8908 /* do_friend adds the TEMPLATE_DECL for any member friend
8909 template even if it isn't a member template, i.e.
8910 template <class T> friend A<T>::f();
8911 Look through it in that case. */
8912 if (TREE_CODE (fn) == TEMPLATE_DECL
8913 && !PRIMARY_TEMPLATE_P (fn))
8914 fn = DECL_TEMPLATE_RESULT (fn);
8915 /* Check to see that the declaration is really present, and,
8916 possibly obtain an improved declaration. */
8917 fn = check_classfn (context, fn, NULL_TREE);
8927 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
8928 template arguments, as for tsubst.
8930 Returns an appropriate tsubst'd friend type or error_mark_node on
8934 tsubst_friend_class (tree friend_tmpl, tree args)
8940 if (DECL_TEMPLATE_TEMPLATE_PARM_P (friend_tmpl))
8942 tree t = tsubst (TREE_TYPE (friend_tmpl), args, tf_none, NULL_TREE);
8943 return TREE_TYPE (t);
8946 context = CP_DECL_CONTEXT (friend_tmpl);
8948 if (context != global_namespace)
8950 if (TREE_CODE (context) == NAMESPACE_DECL)
8951 push_nested_namespace (context);
8953 push_nested_class (tsubst (context, args, tf_none, NULL_TREE));
8956 /* Look for a class template declaration. We look for hidden names
8957 because two friend declarations of the same template are the
8958 same. For example, in:
8961 template <typename> friend class F;
8963 template <typename> struct B {
8964 template <typename> friend class F;
8967 both F templates are the same. */
8968 tmpl = lookup_name_real (DECL_NAME (friend_tmpl), 0, 0,
8969 /*block_p=*/true, 0, LOOKUP_HIDDEN);
8971 /* But, if we don't find one, it might be because we're in a
8972 situation like this:
8980 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
8981 for `S<int>', not the TEMPLATE_DECL. */
8982 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
8984 tmpl = lookup_name_prefer_type (DECL_NAME (friend_tmpl), 1);
8985 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
8988 if (tmpl && DECL_CLASS_TEMPLATE_P (tmpl))
8990 /* The friend template has already been declared. Just
8991 check to see that the declarations match, and install any new
8992 default parameters. We must tsubst the default parameters,
8993 of course. We only need the innermost template parameters
8994 because that is all that redeclare_class_template will look
8996 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl))
8997 > TMPL_ARGS_DEPTH (args))
9000 location_t saved_input_location;
9001 parms = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl),
9002 args, tf_warning_or_error);
9004 saved_input_location = input_location;
9005 input_location = DECL_SOURCE_LOCATION (friend_tmpl);
9006 redeclare_class_template (TREE_TYPE (tmpl), parms);
9007 input_location = saved_input_location;
9011 friend_type = TREE_TYPE (tmpl);
9015 /* The friend template has not already been declared. In this
9016 case, the instantiation of the template class will cause the
9017 injection of this template into the global scope. */
9018 tmpl = tsubst (friend_tmpl, args, tf_warning_or_error, NULL_TREE);
9019 if (tmpl == error_mark_node)
9020 return error_mark_node;
9022 /* The new TMPL is not an instantiation of anything, so we
9023 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
9024 the new type because that is supposed to be the corresponding
9025 template decl, i.e., TMPL. */
9026 DECL_USE_TEMPLATE (tmpl) = 0;
9027 DECL_TEMPLATE_INFO (tmpl) = NULL_TREE;
9028 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl)) = 0;
9029 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl))
9030 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl)));
9032 /* Inject this template into the global scope. */
9033 friend_type = TREE_TYPE (pushdecl_top_level_maybe_friend (tmpl, true));
9036 if (context != global_namespace)
9038 if (TREE_CODE (context) == NAMESPACE_DECL)
9039 pop_nested_namespace (context);
9041 pop_nested_class ();
9047 /* Returns zero if TYPE cannot be completed later due to circularity.
9048 Otherwise returns one. */
9051 can_complete_type_without_circularity (tree type)
9053 if (type == NULL_TREE || type == error_mark_node)
9055 else if (COMPLETE_TYPE_P (type))
9057 else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
9058 return can_complete_type_without_circularity (TREE_TYPE (type));
9059 else if (CLASS_TYPE_P (type)
9060 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type)))
9066 static tree tsubst_omp_clauses (tree, bool, tree, tsubst_flags_t, tree);
9068 /* Apply any attributes which had to be deferred until instantiation
9069 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
9070 ARGS, COMPLAIN, IN_DECL are as tsubst. */
9073 apply_late_template_attributes (tree *decl_p, tree attributes, int attr_flags,
9074 tree args, tsubst_flags_t complain, tree in_decl)
9076 tree last_dep = NULL_TREE;
9080 for (t = attributes; t; t = TREE_CHAIN (t))
9081 if (ATTR_IS_DEPENDENT (t))
9084 attributes = copy_list (attributes);
9088 if (DECL_P (*decl_p))
9090 if (TREE_TYPE (*decl_p) == error_mark_node)
9092 p = &DECL_ATTRIBUTES (*decl_p);
9095 p = &TYPE_ATTRIBUTES (*decl_p);
9099 tree late_attrs = NULL_TREE;
9100 tree *q = &late_attrs;
9102 for (*p = attributes; *p; )
9105 if (ATTR_IS_DEPENDENT (t))
9107 *p = TREE_CHAIN (t);
9108 TREE_CHAIN (t) = NULL_TREE;
9109 if ((flag_openmp || flag_openmp_simd || flag_cilkplus)
9110 && is_attribute_p ("omp declare simd",
9111 get_attribute_name (t))
9114 tree clauses = TREE_VALUE (TREE_VALUE (t));
9115 clauses = tsubst_omp_clauses (clauses, true, args,
9117 c_omp_declare_simd_clauses_to_decls (*decl_p, clauses);
9118 clauses = finish_omp_clauses (clauses);
9119 tree parms = DECL_ARGUMENTS (*decl_p);
9121 = c_omp_declare_simd_clauses_to_numbers (parms, clauses);
9123 TREE_VALUE (TREE_VALUE (t)) = clauses;
9125 TREE_VALUE (t) = NULL_TREE;
9127 /* If the first attribute argument is an identifier, don't
9128 pass it through tsubst. Attributes like mode, format,
9129 cleanup and several target specific attributes expect it
9131 else if (attribute_takes_identifier_p (get_attribute_name (t))
9135 = tsubst_expr (TREE_CHAIN (TREE_VALUE (t)), args, complain,
9137 /*integral_constant_expression_p=*/false);
9138 if (chain != TREE_CHAIN (TREE_VALUE (t)))
9140 = tree_cons (NULL_TREE, TREE_VALUE (TREE_VALUE (t)),
9143 else if (TREE_VALUE (t) && PACK_EXPANSION_P (TREE_VALUE (t)))
9145 /* An attribute pack expansion. */
9146 tree purp = TREE_PURPOSE (t);
9147 tree pack = (tsubst_pack_expansion
9148 (TREE_VALUE (t), args, complain, in_decl));
9149 int len = TREE_VEC_LENGTH (pack);
9150 for (int i = 0; i < len; ++i)
9152 tree elt = TREE_VEC_ELT (pack, i);
9153 *q = build_tree_list (purp, elt);
9154 q = &TREE_CHAIN (*q);
9160 = tsubst_expr (TREE_VALUE (t), args, complain, in_decl,
9161 /*integral_constant_expression_p=*/false);
9163 q = &TREE_CHAIN (t);
9166 p = &TREE_CHAIN (t);
9169 cplus_decl_attributes (decl_p, late_attrs, attr_flags);
9173 /* Perform (or defer) access check for typedefs that were referenced
9174 from within the template TMPL code.
9175 This is a subroutine of instantiate_decl and instantiate_class_template.
9176 TMPL is the template to consider and TARGS is the list of arguments of
9180 perform_typedefs_access_check (tree tmpl, tree targs)
9182 location_t saved_location;
9184 qualified_typedef_usage_t *iter;
9187 || (!CLASS_TYPE_P (tmpl)
9188 && TREE_CODE (tmpl) != FUNCTION_DECL))
9191 saved_location = input_location;
9192 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (tmpl), i, iter)
9194 tree type_decl = iter->typedef_decl;
9195 tree type_scope = iter->context;
9197 if (!type_decl || !type_scope || !CLASS_TYPE_P (type_scope))
9200 if (uses_template_parms (type_decl))
9201 type_decl = tsubst (type_decl, targs, tf_error, NULL_TREE);
9202 if (uses_template_parms (type_scope))
9203 type_scope = tsubst (type_scope, targs, tf_error, NULL_TREE);
9205 /* Make access check error messages point to the location
9206 of the use of the typedef. */
9207 input_location = iter->locus;
9208 perform_or_defer_access_check (TYPE_BINFO (type_scope),
9209 type_decl, type_decl,
9210 tf_warning_or_error);
9212 input_location = saved_location;
9216 instantiate_class_template_1 (tree type)
9218 tree templ, args, pattern, t, member;
9222 unsigned int saved_maximum_field_alignment;
9225 if (type == error_mark_node)
9226 return error_mark_node;
9228 if (COMPLETE_OR_OPEN_TYPE_P (type)
9229 || uses_template_parms (type))
9232 /* Figure out which template is being instantiated. */
9233 templ = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
9234 gcc_assert (TREE_CODE (templ) == TEMPLATE_DECL);
9236 /* Determine what specialization of the original template to
9238 t = most_specialized_partial_spec (type, tf_warning_or_error);
9239 if (t == error_mark_node)
9241 TYPE_BEING_DEFINED (type) = 1;
9242 return error_mark_node;
9246 /* This TYPE is actually an instantiation of a partial
9247 specialization. We replace the innermost set of ARGS with
9248 the arguments appropriate for substitution. For example,
9251 template <class T> struct S {};
9252 template <class T> struct S<T*> {};
9254 and supposing that we are instantiating S<int*>, ARGS will
9255 presently be {int*} -- but we need {int}. */
9256 pattern = TREE_TYPE (t);
9257 args = TREE_PURPOSE (t);
9261 pattern = TREE_TYPE (templ);
9262 args = CLASSTYPE_TI_ARGS (type);
9265 /* If the template we're instantiating is incomplete, then clearly
9266 there's nothing we can do. */
9267 if (!COMPLETE_TYPE_P (pattern))
9270 /* If we've recursively instantiated too many templates, stop. */
9271 if (! push_tinst_level (type))
9274 /* Now we're really doing the instantiation. Mark the type as in
9275 the process of being defined. */
9276 TYPE_BEING_DEFINED (type) = 1;
9278 /* We may be in the middle of deferred access check. Disable
9280 push_deferring_access_checks (dk_no_deferred);
9282 int saved_unevaluated_operand = cp_unevaluated_operand;
9283 int saved_inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
9285 fn_context = decl_function_context (TYPE_MAIN_DECL (type));
9286 /* Also avoid push_to_top_level for a lambda in an NSDMI. */
9287 if (!fn_context && LAMBDA_TYPE_P (type) && TYPE_CLASS_SCOPE_P (type))
9288 fn_context = error_mark_node;
9290 push_to_top_level ();
9293 cp_unevaluated_operand = 0;
9294 c_inhibit_evaluation_warnings = 0;
9296 /* Use #pragma pack from the template context. */
9297 saved_maximum_field_alignment = maximum_field_alignment;
9298 maximum_field_alignment = TYPE_PRECISION (pattern);
9300 SET_CLASSTYPE_INTERFACE_UNKNOWN (type);
9302 /* Set the input location to the most specialized template definition.
9303 This is needed if tsubsting causes an error. */
9304 typedecl = TYPE_MAIN_DECL (pattern);
9305 input_location = DECL_SOURCE_LOCATION (TYPE_NAME (type)) =
9306 DECL_SOURCE_LOCATION (typedecl);
9308 TYPE_PACKED (type) = TYPE_PACKED (pattern);
9309 TYPE_ALIGN (type) = TYPE_ALIGN (pattern);
9310 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);
9311 TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */
9312 if (ANON_AGGR_TYPE_P (pattern))
9313 SET_ANON_AGGR_TYPE_P (type);
9314 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern))
9316 CLASSTYPE_VISIBILITY_SPECIFIED (type) = 1;
9317 CLASSTYPE_VISIBILITY (type) = CLASSTYPE_VISIBILITY (pattern);
9318 /* Adjust visibility for template arguments. */
9319 determine_visibility (TYPE_MAIN_DECL (type));
9321 if (CLASS_TYPE_P (type))
9322 CLASSTYPE_FINAL (type) = CLASSTYPE_FINAL (pattern);
9324 pbinfo = TYPE_BINFO (pattern);
9326 /* We should never instantiate a nested class before its enclosing
9327 class; we need to look up the nested class by name before we can
9328 instantiate it, and that lookup should instantiate the enclosing
9330 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))
9331 || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type)));
9333 base_list = NULL_TREE;
9334 if (BINFO_N_BASE_BINFOS (pbinfo))
9340 /* We must enter the scope containing the type, as that is where
9341 the accessibility of types named in dependent bases are
9343 pushed_scope = push_scope (CP_TYPE_CONTEXT (type));
9345 /* Substitute into each of the bases to determine the actual
9347 for (i = 0; BINFO_BASE_ITERATE (pbinfo, i, pbase_binfo); i++)
9350 tree access = BINFO_BASE_ACCESS (pbinfo, i);
9351 tree expanded_bases = NULL_TREE;
9354 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo)))
9357 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo),
9358 args, tf_error, NULL_TREE);
9359 if (expanded_bases == error_mark_node)
9362 len = TREE_VEC_LENGTH (expanded_bases);
9365 for (idx = 0; idx < len; idx++)
9368 /* Extract the already-expanded base class. */
9369 base = TREE_VEC_ELT (expanded_bases, idx);
9371 /* Substitute to figure out the base class. */
9372 base = tsubst (BINFO_TYPE (pbase_binfo), args, tf_error,
9375 if (base == error_mark_node)
9378 base_list = tree_cons (access, base, base_list);
9379 if (BINFO_VIRTUAL_P (pbase_binfo))
9380 TREE_TYPE (base_list) = integer_type_node;
9384 /* The list is now in reverse order; correct that. */
9385 base_list = nreverse (base_list);
9388 pop_scope (pushed_scope);
9390 /* Now call xref_basetypes to set up all the base-class
9392 xref_basetypes (type, base_list);
9394 apply_late_template_attributes (&type, TYPE_ATTRIBUTES (pattern),
9395 (int) ATTR_FLAG_TYPE_IN_PLACE,
9396 args, tf_error, NULL_TREE);
9397 fixup_attribute_variants (type);
9399 /* Now that our base classes are set up, enter the scope of the
9400 class, so that name lookups into base classes, etc. will work
9401 correctly. This is precisely analogous to what we do in
9402 begin_class_definition when defining an ordinary non-template
9403 class, except we also need to push the enclosing classes. */
9404 push_nested_class (type);
9406 /* Now members are processed in the order of declaration. */
9407 for (member = CLASSTYPE_DECL_LIST (pattern);
9408 member; member = TREE_CHAIN (member))
9410 tree t = TREE_VALUE (member);
9412 if (TREE_PURPOSE (member))
9416 /* Build new CLASSTYPE_NESTED_UTDS. */
9419 bool class_template_p;
9421 class_template_p = (TREE_CODE (t) != ENUMERAL_TYPE
9422 && TYPE_LANG_SPECIFIC (t)
9423 && CLASSTYPE_IS_TEMPLATE (t));
9424 /* If the member is a class template, then -- even after
9425 substitution -- there may be dependent types in the
9426 template argument list for the class. We increment
9427 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
9428 that function will assume that no types are dependent
9429 when outside of a template. */
9430 if (class_template_p)
9431 ++processing_template_decl;
9432 newtag = tsubst (t, args, tf_error, NULL_TREE);
9433 if (class_template_p)
9434 --processing_template_decl;
9435 if (newtag == error_mark_node)
9438 if (TREE_CODE (newtag) != ENUMERAL_TYPE)
9440 tree name = TYPE_IDENTIFIER (t);
9442 if (class_template_p)
9443 /* Unfortunately, lookup_template_class sets
9444 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
9445 instantiation (i.e., for the type of a member
9446 template class nested within a template class.)
9447 This behavior is required for
9448 maybe_process_partial_specialization to work
9449 correctly, but is not accurate in this case;
9450 the TAG is not an instantiation of anything.
9451 (The corresponding TEMPLATE_DECL is an
9452 instantiation, but the TYPE is not.) */
9453 CLASSTYPE_USE_TEMPLATE (newtag) = 0;
9455 /* Now, we call pushtag to put this NEWTAG into the scope of
9456 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
9457 pushtag calling push_template_decl. We don't have to do
9458 this for enums because it will already have been done in
9461 SET_IDENTIFIER_TYPE_VALUE (name, newtag);
9462 pushtag (name, newtag, /*tag_scope=*/ts_current);
9465 else if (DECL_DECLARES_FUNCTION_P (t))
9467 /* Build new TYPE_METHODS. */
9470 if (TREE_CODE (t) == TEMPLATE_DECL)
9471 ++processing_template_decl;
9472 r = tsubst (t, args, tf_error, NULL_TREE);
9473 if (TREE_CODE (t) == TEMPLATE_DECL)
9474 --processing_template_decl;
9475 set_current_access_from_decl (r);
9476 finish_member_declaration (r);
9477 /* Instantiate members marked with attribute used. */
9478 if (r != error_mark_node && DECL_PRESERVE_P (r))
9480 if (TREE_CODE (r) == FUNCTION_DECL
9481 && DECL_OMP_DECLARE_REDUCTION_P (r))
9482 cp_check_omp_declare_reduction (r);
9484 else if (DECL_CLASS_TEMPLATE_P (t)
9485 && LAMBDA_TYPE_P (TREE_TYPE (t)))
9486 /* A closure type for a lambda in a default argument for a
9487 member template. Ignore it; it will be instantiated with
9488 the default argument. */;
9491 /* Build new TYPE_FIELDS. */
9492 if (TREE_CODE (t) == STATIC_ASSERT)
9496 ++c_inhibit_evaluation_warnings;
9498 tsubst_expr (STATIC_ASSERT_CONDITION (t), args,
9499 tf_warning_or_error, NULL_TREE,
9500 /*integral_constant_expression_p=*/true);
9501 --c_inhibit_evaluation_warnings;
9503 finish_static_assert (condition,
9504 STATIC_ASSERT_MESSAGE (t),
9505 STATIC_ASSERT_SOURCE_LOCATION (t),
9508 else if (TREE_CODE (t) != CONST_DECL)
9511 tree vec = NULL_TREE;
9514 /* The file and line for this declaration, to
9515 assist in error message reporting. Since we
9516 called push_tinst_level above, we don't need to
9518 input_location = DECL_SOURCE_LOCATION (t);
9520 if (TREE_CODE (t) == TEMPLATE_DECL)
9521 ++processing_template_decl;
9522 r = tsubst (t, args, tf_warning_or_error, NULL_TREE);
9523 if (TREE_CODE (t) == TEMPLATE_DECL)
9524 --processing_template_decl;
9526 if (TREE_CODE (r) == TREE_VEC)
9528 /* A capture pack became multiple fields. */
9530 len = TREE_VEC_LENGTH (vec);
9533 for (int i = 0; i < len; ++i)
9536 r = TREE_VEC_ELT (vec, i);
9541 [t]he initialization (and any associated
9542 side-effects) of a static data member does
9543 not occur unless the static data member is
9544 itself used in a way that requires the
9545 definition of the static data member to
9548 Therefore, we do not substitute into the
9549 initialized for the static data member here. */
9550 finish_static_data_member_decl
9553 /*init_const_expr_p=*/false,
9554 /*asmspec_tree=*/NULL_TREE,
9556 /* Instantiate members marked with attribute used. */
9557 if (r != error_mark_node && DECL_PRESERVE_P (r))
9560 else if (TREE_CODE (r) == FIELD_DECL)
9562 /* Determine whether R has a valid type and can be
9563 completed later. If R is invalid, then its type
9564 is replaced by error_mark_node. */
9565 tree rtype = TREE_TYPE (r);
9566 if (can_complete_type_without_circularity (rtype))
9567 complete_type (rtype);
9569 if (!COMPLETE_TYPE_P (rtype))
9571 cxx_incomplete_type_error (r, rtype);
9572 TREE_TYPE (r) = error_mark_node;
9576 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
9577 such a thing will already have been added to the field
9578 list by tsubst_enum in finish_member_declaration in the
9579 CLASSTYPE_NESTED_UTDS case above. */
9580 if (!(TREE_CODE (r) == TYPE_DECL
9581 && TREE_CODE (TREE_TYPE (r)) == ENUMERAL_TYPE
9582 && DECL_ARTIFICIAL (r)))
9584 set_current_access_from_decl (r);
9585 finish_member_declaration (r);
9593 if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P (t)
9594 || DECL_TEMPLATE_TEMPLATE_PARM_P (t))
9596 /* Build new CLASSTYPE_FRIEND_CLASSES. */
9598 tree friend_type = t;
9599 bool adjust_processing_template_decl = false;
9601 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
9603 /* template <class T> friend class C; */
9604 friend_type = tsubst_friend_class (friend_type, args);
9605 adjust_processing_template_decl = true;
9607 else if (TREE_CODE (friend_type) == UNBOUND_CLASS_TEMPLATE)
9609 /* template <class T> friend class C::D; */
9610 friend_type = tsubst (friend_type, args,
9611 tf_warning_or_error, NULL_TREE);
9612 if (TREE_CODE (friend_type) == TEMPLATE_DECL)
9613 friend_type = TREE_TYPE (friend_type);
9614 adjust_processing_template_decl = true;
9616 else if (TREE_CODE (friend_type) == TYPENAME_TYPE
9617 || TREE_CODE (friend_type) == TEMPLATE_TYPE_PARM)
9619 /* This could be either
9623 when dependent_type_p is false or
9625 template <class U> friend class T::C;
9628 /* Bump processing_template_decl in case this is something like
9629 template <class T> friend struct A<T>::B. */
9630 ++processing_template_decl;
9631 friend_type = tsubst (friend_type, args,
9632 tf_warning_or_error, NULL_TREE);
9633 if (dependent_type_p (friend_type))
9634 adjust_processing_template_decl = true;
9635 --processing_template_decl;
9637 else if (!CLASSTYPE_USE_TEMPLATE (friend_type)
9638 && hidden_name_p (TYPE_NAME (friend_type)))
9642 where C hasn't been declared yet. Let's lookup name
9643 from namespace scope directly, bypassing any name that
9644 come from dependent base class. */
9645 tree ns = decl_namespace_context (TYPE_MAIN_DECL (friend_type));
9647 /* The call to xref_tag_from_type does injection for friend
9649 push_nested_namespace (ns);
9651 xref_tag_from_type (friend_type, NULL_TREE,
9652 /*tag_scope=*/ts_current);
9653 pop_nested_namespace (ns);
9655 else if (uses_template_parms (friend_type))
9656 /* friend class C<T>; */
9657 friend_type = tsubst (friend_type, args,
9658 tf_warning_or_error, NULL_TREE);
9663 where C is already declared or
9665 friend class C<int>;
9667 We don't have to do anything in these cases. */
9669 if (adjust_processing_template_decl)
9670 /* Trick make_friend_class into realizing that the friend
9671 we're adding is a template, not an ordinary class. It's
9672 important that we use make_friend_class since it will
9673 perform some error-checking and output cross-reference
9675 ++processing_template_decl;
9677 if (friend_type != error_mark_node)
9678 make_friend_class (type, friend_type, /*complain=*/false);
9680 if (adjust_processing_template_decl)
9681 --processing_template_decl;
9685 /* Build new DECL_FRIENDLIST. */
9688 /* The file and line for this declaration, to
9689 assist in error message reporting. Since we
9690 called push_tinst_level above, we don't need to
9692 input_location = DECL_SOURCE_LOCATION (t);
9694 if (TREE_CODE (t) == TEMPLATE_DECL)
9696 ++processing_template_decl;
9697 push_deferring_access_checks (dk_no_check);
9700 r = tsubst_friend_function (t, args);
9701 add_friend (type, r, /*complain=*/false);
9702 if (TREE_CODE (t) == TEMPLATE_DECL)
9704 pop_deferring_access_checks ();
9705 --processing_template_decl;
9713 /* Restore these before substituting into the lambda capture
9715 cp_unevaluated_operand = saved_unevaluated_operand;
9716 c_inhibit_evaluation_warnings = saved_inhibit_evaluation_warnings;
9719 if (tree expr = CLASSTYPE_LAMBDA_EXPR (type))
9721 tree decl = lambda_function (type);
9724 if (!DECL_TEMPLATE_INFO (decl)
9725 || DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (decl)) != decl)
9726 instantiate_decl (decl, false, false);
9728 /* We need to instantiate the capture list from the template
9729 after we've instantiated the closure members, but before we
9730 consider adding the conversion op. Also keep any captures
9731 that may have been added during instantiation of the op(). */
9732 tree tmpl_expr = CLASSTYPE_LAMBDA_EXPR (pattern);
9734 = tsubst_copy_and_build (LAMBDA_EXPR_CAPTURE_LIST (tmpl_expr),
9735 args, tf_warning_or_error, NULL_TREE,
9738 LAMBDA_EXPR_CAPTURE_LIST (expr)
9739 = chainon (tmpl_cap, nreverse (LAMBDA_EXPR_CAPTURE_LIST (expr)));
9741 maybe_add_lambda_conv_op (type);
9744 gcc_assert (errorcount);
9747 /* Set the file and line number information to whatever is given for
9748 the class itself. This puts error messages involving generated
9749 implicit functions at a predictable point, and the same point
9750 that would be used for non-template classes. */
9751 input_location = DECL_SOURCE_LOCATION (typedecl);
9753 unreverse_member_declarations (type);
9754 finish_struct_1 (type);
9755 TYPE_BEING_DEFINED (type) = 0;
9757 /* We don't instantiate default arguments for member functions. 14.7.1:
9759 The implicit instantiation of a class template specialization causes
9760 the implicit instantiation of the declarations, but not of the
9761 definitions or default arguments, of the class member functions,
9762 member classes, static data members and member templates.... */
9764 /* Some typedefs referenced from within the template code need to be access
9765 checked at template instantiation time, i.e now. These types were
9766 added to the template at parsing time. Let's get those and perform
9767 the access checks then. */
9768 perform_typedefs_access_check (pattern, args);
9769 perform_deferred_access_checks (tf_warning_or_error);
9770 pop_nested_class ();
9771 maximum_field_alignment = saved_maximum_field_alignment;
9773 pop_from_top_level ();
9774 pop_deferring_access_checks ();
9777 /* The vtable for a template class can be emitted in any translation
9778 unit in which the class is instantiated. When there is no key
9779 method, however, finish_struct_1 will already have added TYPE to
9780 the keyed_classes list. */
9781 if (TYPE_CONTAINS_VPTR_P (type) && CLASSTYPE_KEY_METHOD (type))
9782 keyed_classes = tree_cons (NULL_TREE, type, keyed_classes);
9787 /* Wrapper for instantiate_class_template_1. */
9790 instantiate_class_template (tree type)
9793 timevar_push (TV_TEMPLATE_INST);
9794 ret = instantiate_class_template_1 (type);
9795 timevar_pop (TV_TEMPLATE_INST);
9800 tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl)
9806 else if (TYPE_P (t))
9807 r = tsubst (t, args, complain, in_decl);
9810 if (!(complain & tf_warning))
9811 ++c_inhibit_evaluation_warnings;
9812 r = tsubst_expr (t, args, complain, in_decl,
9813 /*integral_constant_expression_p=*/true);
9814 if (!(complain & tf_warning))
9815 --c_inhibit_evaluation_warnings;
9820 /* Given a function parameter pack TMPL_PARM and some function parameters
9821 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
9822 and set *SPEC_P to point at the next point in the list. */
9825 extract_fnparm_pack (tree tmpl_parm, tree *spec_p)
9827 /* Collect all of the extra "packed" parameters into an
9831 tree argpack = make_node (NONTYPE_ARGUMENT_PACK);
9832 tree argtypepack = cxx_make_type (TYPE_ARGUMENT_PACK);
9833 tree spec_parm = *spec_p;
9836 for (len = 0; spec_parm; ++len, spec_parm = TREE_CHAIN (spec_parm))
9838 && !function_parameter_expanded_from_pack_p (spec_parm, tmpl_parm))
9841 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
9842 parmvec = make_tree_vec (len);
9843 parmtypevec = make_tree_vec (len);
9844 spec_parm = *spec_p;
9845 for (i = 0; i < len; i++, spec_parm = DECL_CHAIN (spec_parm))
9847 TREE_VEC_ELT (parmvec, i) = spec_parm;
9848 TREE_VEC_ELT (parmtypevec, i) = TREE_TYPE (spec_parm);
9851 /* Build the argument packs. */
9852 SET_ARGUMENT_PACK_ARGS (argpack, parmvec);
9853 SET_ARGUMENT_PACK_ARGS (argtypepack, parmtypevec);
9854 TREE_TYPE (argpack) = argtypepack;
9855 *spec_p = spec_parm;
9860 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
9861 NONTYPE_ARGUMENT_PACK. */
9864 make_fnparm_pack (tree spec_parm)
9866 return extract_fnparm_pack (NULL_TREE, &spec_parm);
9869 /* Return 1 if the Ith element of the argument pack ARG_PACK is a
9870 pack expansion with no extra args, 2 if it has extra args, or 0
9871 if it is not a pack expansion. */
9874 argument_pack_element_is_expansion_p (tree arg_pack, int i)
9876 tree vec = ARGUMENT_PACK_ARGS (arg_pack);
9877 if (i >= TREE_VEC_LENGTH (vec))
9879 tree elt = TREE_VEC_ELT (vec, i);
9880 if (!PACK_EXPANSION_P (elt))
9882 if (PACK_EXPANSION_EXTRA_ARGS (elt))
9888 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
9891 make_argument_pack_select (tree arg_pack, unsigned index)
9893 tree aps = make_node (ARGUMENT_PACK_SELECT);
9895 ARGUMENT_PACK_SELECT_FROM_PACK (aps) = arg_pack;
9896 ARGUMENT_PACK_SELECT_INDEX (aps) = index;
9901 /* This is a subroutine of tsubst_pack_expansion.
9903 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
9904 mechanism to store the (non complete list of) arguments of the
9905 substitution and return a non substituted pack expansion, in order
9906 to wait for when we have enough arguments to really perform the
9910 use_pack_expansion_extra_args_p (tree parm_packs,
9914 /* If one pack has an expansion and another pack has a normal
9915 argument or if one pack has an empty argument and an another
9916 one hasn't then tsubst_pack_expansion cannot perform the
9917 substitution and need to fall back on the
9918 PACK_EXPANSION_EXTRA mechanism. */
9919 if (parm_packs == NULL_TREE)
9921 else if (has_empty_arg)
9924 bool has_expansion_arg = false;
9925 for (int i = 0 ; i < arg_pack_len; ++i)
9927 bool has_non_expansion_arg = false;
9928 for (tree parm_pack = parm_packs;
9930 parm_pack = TREE_CHAIN (parm_pack))
9932 tree arg = TREE_VALUE (parm_pack);
9934 int exp = argument_pack_element_is_expansion_p (arg, i);
9936 /* We can't substitute a pack expansion with extra args into
9940 has_expansion_arg = true;
9942 has_non_expansion_arg = true;
9945 if (has_expansion_arg && has_non_expansion_arg)
9951 /* [temp.variadic]/6 says that:
9953 The instantiation of a pack expansion [...]
9954 produces a list E1,E2, ..., En, where N is the number of elements
9955 in the pack expansion parameters.
9957 This subroutine of tsubst_pack_expansion produces one of these Ei.
9959 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
9960 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
9961 PATTERN, and each TREE_VALUE is its corresponding argument pack.
9962 INDEX is the index 'i' of the element Ei to produce. ARGS,
9963 COMPLAIN, and IN_DECL are the same parameters as for the
9964 tsubst_pack_expansion function.
9966 The function returns the resulting Ei upon successful completion,
9969 Note that this function possibly modifies the ARGS parameter, so
9970 it's the responsibility of the caller to restore it. */
9973 gen_elem_of_pack_expansion_instantiation (tree pattern,
9976 tree args /* This parm gets
9978 tsubst_flags_t complain,
9982 bool ith_elem_is_expansion = false;
9984 /* For each parameter pack, change the substitution of the parameter
9985 pack to the ith argument in its argument pack, then expand the
9987 for (tree pack = parm_packs; pack; pack = TREE_CHAIN (pack))
9989 tree parm = TREE_PURPOSE (pack);
9990 tree arg_pack = TREE_VALUE (pack);
9991 tree aps; /* instance of ARGUMENT_PACK_SELECT. */
9993 ith_elem_is_expansion |=
9994 argument_pack_element_is_expansion_p (arg_pack, index);
9996 /* Select the Ith argument from the pack. */
9997 if (TREE_CODE (parm) == PARM_DECL
9998 || TREE_CODE (parm) == FIELD_DECL)
10002 aps = make_argument_pack_select (arg_pack, index);
10003 if (!mark_used (parm, complain) && !(complain & tf_error))
10004 return error_mark_node;
10005 register_local_specialization (aps, parm);
10008 aps = retrieve_local_specialization (parm);
10013 template_parm_level_and_index (parm, &level, &idx);
10017 aps = make_argument_pack_select (arg_pack, index);
10018 /* Update the corresponding argument. */
10019 TMPL_ARG (args, level, idx) = aps;
10022 /* Re-use the ARGUMENT_PACK_SELECT. */
10023 aps = TMPL_ARG (args, level, idx);
10025 ARGUMENT_PACK_SELECT_INDEX (aps) = index;
10028 /* Substitute into the PATTERN with the (possibly altered)
10030 if (pattern == in_decl)
10031 /* Expanding a fixed parameter pack from
10032 coerce_template_parameter_pack. */
10033 t = tsubst_decl (pattern, args, complain);
10034 else if (!TYPE_P (pattern))
10035 t = tsubst_expr (pattern, args, complain, in_decl,
10036 /*integral_constant_expression_p=*/false);
10038 t = tsubst (pattern, args, complain, in_decl);
10040 /* If the Ith argument pack element is a pack expansion, then
10041 the Ith element resulting from the substituting is going to
10042 be a pack expansion as well. */
10043 if (ith_elem_is_expansion)
10044 t = make_pack_expansion (t);
10049 /* Substitute ARGS into T, which is an pack expansion
10050 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
10051 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
10052 (if only a partial substitution could be performed) or
10053 ERROR_MARK_NODE if there was an error. */
10055 tsubst_pack_expansion (tree t, tree args, tsubst_flags_t complain,
10059 tree pack, packs = NULL_TREE;
10060 bool unsubstituted_packs = false;
10063 hash_map<tree, tree> *saved_local_specializations = NULL;
10064 bool need_local_specializations = false;
10067 gcc_assert (PACK_EXPANSION_P (t));
10068 pattern = PACK_EXPANSION_PATTERN (t);
10070 /* Add in any args remembered from an earlier partial instantiation. */
10071 args = add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (t), args);
10073 levels = TMPL_ARGS_DEPTH (args);
10075 /* Determine the argument packs that will instantiate the parameter
10076 packs used in the expansion expression. While we're at it,
10077 compute the number of arguments to be expanded and make sure it
10079 for (pack = PACK_EXPANSION_PARAMETER_PACKS (t); pack;
10080 pack = TREE_CHAIN (pack))
10082 tree parm_pack = TREE_VALUE (pack);
10083 tree arg_pack = NULL_TREE;
10084 tree orig_arg = NULL_TREE;
10087 if (TREE_CODE (parm_pack) == BASES)
10089 if (BASES_DIRECT (parm_pack))
10090 return calculate_direct_bases (tsubst_expr (BASES_TYPE (parm_pack),
10091 args, complain, in_decl, false));
10093 return calculate_bases (tsubst_expr (BASES_TYPE (parm_pack),
10094 args, complain, in_decl, false));
10096 if (TREE_CODE (parm_pack) == PARM_DECL)
10098 if (PACK_EXPANSION_LOCAL_P (t))
10099 arg_pack = retrieve_local_specialization (parm_pack);
10101 /* We can't rely on local_specializations for a parameter
10102 name used later in a function declaration (such as in a
10103 late-specified return type). Even if it exists, it might
10104 have the wrong value for a recursive call. */
10105 need_local_specializations = true;
10109 /* This parameter pack was used in an unevaluated context. Just
10110 make a dummy decl, since it's only used for its type. */
10111 arg_pack = tsubst_decl (parm_pack, args, complain);
10112 if (arg_pack && DECL_PACK_P (arg_pack))
10113 /* Partial instantiation of the parm_pack, we can't build
10114 up an argument pack yet. */
10115 arg_pack = NULL_TREE;
10117 arg_pack = make_fnparm_pack (arg_pack);
10120 else if (TREE_CODE (parm_pack) == FIELD_DECL)
10121 arg_pack = tsubst_copy (parm_pack, args, complain, in_decl);
10125 template_parm_level_and_index (parm_pack, &level, &idx);
10127 if (level <= levels)
10128 arg_pack = TMPL_ARG (args, level, idx);
10131 orig_arg = arg_pack;
10132 if (arg_pack && TREE_CODE (arg_pack) == ARGUMENT_PACK_SELECT)
10133 arg_pack = ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack);
10135 if (arg_pack && !ARGUMENT_PACK_P (arg_pack))
10136 /* This can only happen if we forget to expand an argument
10137 pack somewhere else. Just return an error, silently. */
10139 result = make_tree_vec (1);
10140 TREE_VEC_ELT (result, 0) = error_mark_node;
10147 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack));
10149 /* Don't bother trying to do a partial substitution with
10150 incomplete packs; we'll try again after deduction. */
10151 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack))
10156 else if (len != my_len)
10158 if (!(complain & tf_error))
10159 /* Fail quietly. */;
10160 else if (TREE_CODE (t) == TYPE_PACK_EXPANSION)
10161 error ("mismatched argument pack lengths while expanding "
10165 error ("mismatched argument pack lengths while expanding "
10168 return error_mark_node;
10171 /* Keep track of the parameter packs and their corresponding
10173 packs = tree_cons (parm_pack, arg_pack, packs);
10174 TREE_TYPE (packs) = orig_arg;
10178 /* We can't substitute for this parameter pack. We use a flag as
10179 well as the missing_level counter because function parameter
10180 packs don't have a level. */
10181 unsubstituted_packs = true;
10185 /* If the expansion is just T..., return the matching argument pack, unless
10186 we need to call convert_from_reference on all the elements. This is an
10187 important optimization; see c++/68422. */
10188 if (!unsubstituted_packs
10189 && TREE_PURPOSE (packs) == pattern)
10191 tree args = ARGUMENT_PACK_ARGS (TREE_VALUE (packs));
10192 /* Types need no adjustment, nor does sizeof..., and if we still have
10193 some pack expansion args we won't do anything yet. */
10194 if (TREE_CODE (t) == TYPE_PACK_EXPANSION
10195 || PACK_EXPANSION_SIZEOF_P (t)
10196 || pack_expansion_args_count (args))
10198 /* Otherwise use the normal path so we get convert_from_reference. */
10201 /* We cannot expand this expansion expression, because we don't have
10202 all of the argument packs we need. */
10203 if (use_pack_expansion_extra_args_p (packs, len, unsubstituted_packs))
10205 /* We got some full packs, but we can't substitute them in until we
10206 have values for all the packs. So remember these until then. */
10208 t = make_pack_expansion (pattern);
10209 PACK_EXPANSION_EXTRA_ARGS (t) = args;
10212 else if (unsubstituted_packs)
10214 /* There were no real arguments, we're just replacing a parameter
10215 pack with another version of itself. Substitute into the
10216 pattern and return a PACK_EXPANSION_*. The caller will need to
10218 if (TREE_CODE (t) == EXPR_PACK_EXPANSION)
10219 t = tsubst_expr (pattern, args, complain, in_decl,
10220 /*integral_constant_expression_p=*/false);
10222 t = tsubst (pattern, args, complain, in_decl);
10223 t = make_pack_expansion (t);
10227 gcc_assert (len >= 0);
10229 if (need_local_specializations)
10231 /* We're in a late-specified return type, so create our own local
10232 specializations map; the current map is either NULL or (in the
10233 case of recursive unification) might have bindings that we don't
10234 want to use or alter. */
10235 saved_local_specializations = local_specializations;
10236 local_specializations = new hash_map<tree, tree>;
10239 /* For each argument in each argument pack, substitute into the
10241 result = make_tree_vec (len);
10242 tree elem_args = copy_template_args (args);
10243 for (i = 0; i < len; ++i)
10245 t = gen_elem_of_pack_expansion_instantiation (pattern, packs,
10247 elem_args, complain,
10249 TREE_VEC_ELT (result, i) = t;
10250 if (t == error_mark_node)
10252 result = error_mark_node;
10257 /* Update ARGS to restore the substitution from parameter packs to
10258 their argument packs. */
10259 for (pack = packs; pack; pack = TREE_CHAIN (pack))
10261 tree parm = TREE_PURPOSE (pack);
10263 if (TREE_CODE (parm) == PARM_DECL
10264 || TREE_CODE (parm) == FIELD_DECL)
10265 register_local_specialization (TREE_TYPE (pack), parm);
10270 if (TREE_VALUE (pack) == NULL_TREE)
10273 template_parm_level_and_index (parm, &level, &idx);
10275 /* Update the corresponding argument. */
10276 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
10277 TREE_VEC_ELT (TREE_VEC_ELT (args, level -1 ), idx) =
10280 TREE_VEC_ELT (args, idx) = TREE_TYPE (pack);
10284 if (need_local_specializations)
10286 delete local_specializations;
10287 local_specializations = saved_local_specializations;
10293 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
10294 TMPL. We do this using DECL_PARM_INDEX, which should work even with
10295 parameter packs; all parms generated from a function parameter pack will
10296 have the same DECL_PARM_INDEX. */
10299 get_pattern_parm (tree parm, tree tmpl)
10301 tree pattern = DECL_TEMPLATE_RESULT (tmpl);
10304 if (DECL_ARTIFICIAL (parm))
10306 for (patparm = DECL_ARGUMENTS (pattern);
10307 patparm; patparm = DECL_CHAIN (patparm))
10308 if (DECL_ARTIFICIAL (patparm)
10309 && DECL_NAME (parm) == DECL_NAME (patparm))
10314 patparm = FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl));
10315 patparm = chain_index (DECL_PARM_INDEX (parm)-1, patparm);
10316 gcc_assert (DECL_PARM_INDEX (patparm)
10317 == DECL_PARM_INDEX (parm));
10323 /* Return an exact copy of template args T that can be modified
10327 copy_template_args (tree t)
10329 if (t == error_mark_node)
10332 int len = TREE_VEC_LENGTH (t);
10333 tree new_vec = make_tree_vec (len);
10335 for (int i = 0; i < len; ++i)
10337 tree elt = TREE_VEC_ELT (t, i);
10338 if (elt && TREE_CODE (elt) == TREE_VEC)
10339 elt = copy_template_args (elt);
10340 TREE_VEC_ELT (new_vec, i) = elt;
10343 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_vec)
10344 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t);
10349 /* Substitute ARGS into the vector or list of template arguments T. */
10352 tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl)
10355 int len, need_new = 0, i, expanded_len_adjust = 0, out;
10358 if (t == error_mark_node)
10359 return error_mark_node;
10361 len = TREE_VEC_LENGTH (t);
10362 elts = XALLOCAVEC (tree, len);
10364 for (i = 0; i < len; i++)
10366 tree orig_arg = TREE_VEC_ELT (t, i);
10369 if (TREE_CODE (orig_arg) == TREE_VEC)
10370 new_arg = tsubst_template_args (orig_arg, args, complain, in_decl);
10371 else if (PACK_EXPANSION_P (orig_arg))
10373 /* Substitute into an expansion expression. */
10374 new_arg = tsubst_pack_expansion (orig_arg, args, complain, in_decl);
10376 if (TREE_CODE (new_arg) == TREE_VEC)
10377 /* Add to the expanded length adjustment the number of
10378 expanded arguments. We subtract one from this
10379 measurement, because the argument pack expression
10380 itself is already counted as 1 in
10381 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
10382 the argument pack is empty. */
10383 expanded_len_adjust += TREE_VEC_LENGTH (new_arg) - 1;
10385 else if (ARGUMENT_PACK_P (orig_arg))
10387 /* Substitute into each of the arguments. */
10388 new_arg = TYPE_P (orig_arg)
10389 ? cxx_make_type (TREE_CODE (orig_arg))
10390 : make_node (TREE_CODE (orig_arg));
10392 SET_ARGUMENT_PACK_ARGS (
10394 tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg),
10395 args, complain, in_decl));
10397 if (ARGUMENT_PACK_ARGS (new_arg) == error_mark_node)
10398 new_arg = error_mark_node;
10400 if (TREE_CODE (new_arg) == NONTYPE_ARGUMENT_PACK) {
10401 TREE_TYPE (new_arg) = tsubst (TREE_TYPE (orig_arg), args,
10402 complain, in_decl);
10403 TREE_CONSTANT (new_arg) = TREE_CONSTANT (orig_arg);
10405 if (TREE_TYPE (new_arg) == error_mark_node)
10406 new_arg = error_mark_node;
10410 new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl);
10412 if (new_arg == error_mark_node)
10413 return error_mark_node;
10416 if (new_arg != orig_arg)
10423 /* Make space for the expanded arguments coming from template
10425 t = make_tree_vec (len + expanded_len_adjust);
10426 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
10427 arguments for a member template.
10428 In that case each TREE_VEC in ORIG_T represents a level of template
10429 arguments, and ORIG_T won't carry any non defaulted argument count.
10430 It will rather be the nested TREE_VECs that will carry one.
10431 In other words, ORIG_T carries a non defaulted argument count only
10432 if it doesn't contain any nested TREE_VEC. */
10433 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t))
10435 int count = GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t);
10436 count += expanded_len_adjust;
10437 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t, count);
10439 for (i = 0, out = 0; i < len; i++)
10441 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t, i))
10442 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t, i)))
10443 && TREE_CODE (elts[i]) == TREE_VEC)
10447 /* Now expand the template argument pack "in place". */
10448 for (idx = 0; idx < TREE_VEC_LENGTH (elts[i]); idx++, out++)
10449 TREE_VEC_ELT (t, out) = TREE_VEC_ELT (elts[i], idx);
10453 TREE_VEC_ELT (t, out) = elts[i];
10461 /* Return the result of substituting ARGS into the template parameters
10462 given by PARMS. If there are m levels of ARGS and m + n levels of
10463 PARMS, then the result will contain n levels of PARMS. For
10464 example, if PARMS is `template <class T> template <class U>
10465 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
10466 result will be `template <int*, double, class V>'. */
10469 tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain)
10471 tree r = NULL_TREE;
10474 /* When substituting into a template, we must set
10475 PROCESSING_TEMPLATE_DECL as the template parameters may be
10476 dependent if they are based on one-another, and the dependency
10477 predicates are short-circuit outside of templates. */
10478 ++processing_template_decl;
10480 for (new_parms = &r;
10481 parms && TMPL_PARMS_DEPTH (parms) > TMPL_ARGS_DEPTH (args);
10482 new_parms = &(TREE_CHAIN (*new_parms)),
10483 parms = TREE_CHAIN (parms))
10486 make_tree_vec (TREE_VEC_LENGTH (TREE_VALUE (parms)));
10489 for (i = 0; i < TREE_VEC_LENGTH (new_vec); ++i)
10493 if (parms == error_mark_node)
10496 tuple = TREE_VEC_ELT (TREE_VALUE (parms), i);
10498 if (tuple == error_mark_node)
10501 TREE_VEC_ELT (new_vec, i) =
10502 tsubst_template_parm (tuple, args, complain);
10506 tree_cons (size_int (TMPL_PARMS_DEPTH (parms)
10507 - TMPL_ARGS_DEPTH (args)),
10508 new_vec, NULL_TREE);
10511 --processing_template_decl;
10516 /* Return the result of substituting ARGS into one template parameter
10517 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
10518 parameter and which TREE_PURPOSE is the default argument of the
10519 template parameter. */
10522 tsubst_template_parm (tree t, tree args, tsubst_flags_t complain)
10524 tree default_value, parm_decl;
10526 if (args == NULL_TREE
10528 || t == error_mark_node)
10531 gcc_assert (TREE_CODE (t) == TREE_LIST);
10533 default_value = TREE_PURPOSE (t);
10534 parm_decl = TREE_VALUE (t);
10536 parm_decl = tsubst (parm_decl, args, complain, NULL_TREE);
10537 if (TREE_CODE (parm_decl) == PARM_DECL
10538 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl), complain))
10539 parm_decl = error_mark_node;
10540 default_value = tsubst_template_arg (default_value, args,
10541 complain, NULL_TREE);
10543 return build_tree_list (default_value, parm_decl);
10546 /* Substitute the ARGS into the indicated aggregate (or enumeration)
10547 type T. If T is not an aggregate or enumeration type, it is
10548 handled as if by tsubst. IN_DECL is as for tsubst. If
10549 ENTERING_SCOPE is nonzero, T is the context for a template which
10550 we are presently tsubst'ing. Return the substituted value. */
10553 tsubst_aggr_type (tree t,
10555 tsubst_flags_t complain,
10557 int entering_scope)
10559 if (t == NULL_TREE)
10562 switch (TREE_CODE (t))
10565 if (TYPE_PTRMEMFUNC_P (t))
10566 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl);
10568 /* Else fall through. */
10569 case ENUMERAL_TYPE:
10571 if (TYPE_TEMPLATE_INFO (t) && uses_template_parms (t))
10576 int saved_unevaluated_operand;
10577 int saved_inhibit_evaluation_warnings;
10579 /* In "sizeof(X<I>)" we need to evaluate "I". */
10580 saved_unevaluated_operand = cp_unevaluated_operand;
10581 cp_unevaluated_operand = 0;
10582 saved_inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
10583 c_inhibit_evaluation_warnings = 0;
10585 /* First, determine the context for the type we are looking
10587 context = TYPE_CONTEXT (t);
10588 if (context && TYPE_P (context))
10590 context = tsubst_aggr_type (context, args, complain,
10591 in_decl, /*entering_scope=*/1);
10592 /* If context is a nested class inside a class template,
10593 it may still need to be instantiated (c++/33959). */
10594 context = complete_type (context);
10597 /* Then, figure out what arguments are appropriate for the
10598 type we are trying to find. For example, given:
10600 template <class T> struct S;
10601 template <class T, class U> void f(T, U) { S<U> su; }
10603 and supposing that we are instantiating f<int, double>,
10604 then our ARGS will be {int, double}, but, when looking up
10605 S we only want {double}. */
10606 argvec = tsubst_template_args (TYPE_TI_ARGS (t), args,
10607 complain, in_decl);
10608 if (argvec == error_mark_node)
10609 r = error_mark_node;
10612 r = lookup_template_class (t, argvec, in_decl, context,
10613 entering_scope, complain);
10614 r = cp_build_qualified_type_real (r, cp_type_quals (t), complain);
10617 cp_unevaluated_operand = saved_unevaluated_operand;
10618 c_inhibit_evaluation_warnings = saved_inhibit_evaluation_warnings;
10623 /* This is not a template type, so there's nothing to do. */
10627 return tsubst (t, args, complain, in_decl);
10631 /* Substitute into the default argument ARG (a default argument for
10632 FN), which has the indicated TYPE. */
10635 tsubst_default_argument (tree fn, tree type, tree arg, tsubst_flags_t complain)
10637 tree saved_class_ptr = NULL_TREE;
10638 tree saved_class_ref = NULL_TREE;
10639 int errs = errorcount + sorrycount;
10641 /* This can happen in invalid code. */
10642 if (TREE_CODE (arg) == DEFAULT_ARG)
10645 /* This default argument came from a template. Instantiate the
10646 default argument here, not in tsubst. In the case of
10655 we must be careful to do name lookup in the scope of S<T>,
10656 rather than in the current class. */
10657 push_access_scope (fn);
10658 /* The "this" pointer is not valid in a default argument. */
10661 saved_class_ptr = current_class_ptr;
10662 cp_function_chain->x_current_class_ptr = NULL_TREE;
10663 saved_class_ref = current_class_ref;
10664 cp_function_chain->x_current_class_ref = NULL_TREE;
10667 push_deferring_access_checks(dk_no_deferred);
10668 /* The default argument expression may cause implicitly defined
10669 member functions to be synthesized, which will result in garbage
10670 collection. We must treat this situation as if we were within
10671 the body of function so as to avoid collecting live data on the
10674 arg = tsubst_expr (arg, DECL_TI_ARGS (fn),
10675 complain, NULL_TREE,
10676 /*integral_constant_expression_p=*/false);
10678 pop_deferring_access_checks();
10680 /* Restore the "this" pointer. */
10683 cp_function_chain->x_current_class_ptr = saved_class_ptr;
10684 cp_function_chain->x_current_class_ref = saved_class_ref;
10687 if (errorcount+sorrycount > errs
10688 && (complain & tf_warning_or_error))
10689 inform (input_location,
10690 " when instantiating default argument for call to %D", fn);
10692 /* Make sure the default argument is reasonable. */
10693 arg = check_default_argument (type, arg, complain);
10695 pop_access_scope (fn);
10700 /* Substitute into all the default arguments for FN. */
10703 tsubst_default_arguments (tree fn, tsubst_flags_t complain)
10708 tmpl_args = DECL_TI_ARGS (fn);
10710 /* If this function is not yet instantiated, we certainly don't need
10711 its default arguments. */
10712 if (uses_template_parms (tmpl_args))
10714 /* Don't do this again for clones. */
10715 if (DECL_CLONED_FUNCTION_P (fn))
10718 for (arg = TYPE_ARG_TYPES (TREE_TYPE (fn));
10720 arg = TREE_CHAIN (arg))
10721 if (TREE_PURPOSE (arg))
10722 TREE_PURPOSE (arg) = tsubst_default_argument (fn,
10724 TREE_PURPOSE (arg),
10728 /* Substitute the ARGS into the T, which is a _DECL. Return the
10729 result of the substitution. Issue error and warning messages under
10730 control of COMPLAIN. */
10733 tsubst_decl (tree t, tree args, tsubst_flags_t complain)
10735 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
10736 location_t saved_loc;
10737 tree r = NULL_TREE;
10739 hashval_t hash = 0;
10741 /* Set the filename and linenumber to improve error-reporting. */
10742 saved_loc = input_location;
10743 input_location = DECL_SOURCE_LOCATION (t);
10745 switch (TREE_CODE (t))
10747 case TEMPLATE_DECL:
10749 /* We can get here when processing a member function template,
10750 member class template, or template template parameter. */
10751 tree decl = DECL_TEMPLATE_RESULT (t);
10756 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
10758 /* Template template parameter is treated here. */
10759 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10760 if (new_type == error_mark_node)
10761 RETURN (error_mark_node);
10762 /* If we get a real template back, return it. This can happen in
10763 the context of most_specialized_partial_spec. */
10764 if (TREE_CODE (new_type) == TEMPLATE_DECL)
10768 DECL_CHAIN (r) = NULL_TREE;
10769 TREE_TYPE (r) = new_type;
10770 DECL_TEMPLATE_RESULT (r)
10771 = build_decl (DECL_SOURCE_LOCATION (decl),
10772 TYPE_DECL, DECL_NAME (decl), new_type);
10773 DECL_TEMPLATE_PARMS (r)
10774 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
10776 TYPE_NAME (new_type) = r;
10780 /* We might already have an instance of this template.
10781 The ARGS are for the surrounding class type, so the
10782 full args contain the tsubst'd args for the context,
10783 plus the innermost args from the template decl. */
10784 tmpl_args = DECL_CLASS_TEMPLATE_P (t)
10785 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t))
10786 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t));
10787 /* Because this is a template, the arguments will still be
10788 dependent, even after substitution. If
10789 PROCESSING_TEMPLATE_DECL is not set, the dependency
10790 predicates will short-circuit. */
10791 ++processing_template_decl;
10792 full_args = tsubst_template_args (tmpl_args, args,
10793 complain, in_decl);
10794 --processing_template_decl;
10795 if (full_args == error_mark_node)
10796 RETURN (error_mark_node);
10798 /* If this is a default template template argument,
10799 tsubst might not have changed anything. */
10800 if (full_args == tmpl_args)
10803 hash = hash_tmpl_and_args (t, full_args);
10804 spec = retrieve_specialization (t, full_args, hash);
10805 if (spec != NULL_TREE)
10811 /* Make a new template decl. It will be similar to the
10812 original, but will record the current template arguments.
10813 We also create a new function declaration, which is just
10814 like the old one, but points to this new template, rather
10815 than the old one. */
10817 gcc_assert (DECL_LANG_SPECIFIC (r) != 0);
10818 DECL_CHAIN (r) = NULL_TREE;
10820 DECL_TEMPLATE_INFO (r) = build_template_info (t, args);
10822 if (TREE_CODE (decl) == TYPE_DECL
10823 && !TYPE_DECL_ALIAS_P (decl))
10826 ++processing_template_decl;
10827 new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10828 --processing_template_decl;
10829 if (new_type == error_mark_node)
10830 RETURN (error_mark_node);
10832 TREE_TYPE (r) = new_type;
10833 /* For a partial specialization, we need to keep pointing to
10834 the primary template. */
10835 if (!DECL_TEMPLATE_SPECIALIZATION (t))
10836 CLASSTYPE_TI_TEMPLATE (new_type) = r;
10837 DECL_TEMPLATE_RESULT (r) = TYPE_MAIN_DECL (new_type);
10838 DECL_TI_ARGS (r) = CLASSTYPE_TI_ARGS (new_type);
10839 DECL_CONTEXT (r) = TYPE_CONTEXT (new_type);
10844 ++processing_template_decl;
10845 new_decl = tsubst (decl, args, complain, in_decl);
10846 --processing_template_decl;
10847 if (new_decl == error_mark_node)
10848 RETURN (error_mark_node);
10850 DECL_TEMPLATE_RESULT (r) = new_decl;
10851 DECL_TI_TEMPLATE (new_decl) = r;
10852 TREE_TYPE (r) = TREE_TYPE (new_decl);
10853 DECL_TI_ARGS (r) = DECL_TI_ARGS (new_decl);
10854 DECL_CONTEXT (r) = DECL_CONTEXT (new_decl);
10857 SET_DECL_IMPLICIT_INSTANTIATION (r);
10858 DECL_TEMPLATE_INSTANTIATIONS (r) = NULL_TREE;
10859 DECL_TEMPLATE_SPECIALIZATIONS (r) = NULL_TREE;
10861 /* The template parameters for this new template are all the
10862 template parameters for the old template, except the
10863 outermost level of parameters. */
10864 DECL_TEMPLATE_PARMS (r)
10865 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
10868 if (PRIMARY_TEMPLATE_P (t))
10869 DECL_PRIMARY_TEMPLATE (r) = r;
10871 if (TREE_CODE (decl) != TYPE_DECL && TREE_CODE (decl) != VAR_DECL)
10872 /* Record this non-type partial instantiation. */
10873 register_specialization (r, t,
10874 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r)),
10879 case FUNCTION_DECL:
10882 tree argvec = NULL_TREE;
10890 /* Nobody should be tsubst'ing into non-template functions. */
10891 gcc_assert (DECL_TEMPLATE_INFO (t) != NULL_TREE);
10893 if (TREE_CODE (DECL_TI_TEMPLATE (t)) == TEMPLATE_DECL)
10898 /* If T is not dependent, just return it. We have to
10899 increment PROCESSING_TEMPLATE_DECL because
10900 value_dependent_expression_p assumes that nothing is
10901 dependent when PROCESSING_TEMPLATE_DECL is zero. */
10902 ++processing_template_decl;
10903 dependent_p = value_dependent_expression_p (t);
10904 --processing_template_decl;
10908 /* Calculate the most general template of which R is a
10909 specialization, and the complete set of arguments used to
10911 gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
10912 argvec = tsubst_template_args (DECL_TI_ARGS
10913 (DECL_TEMPLATE_RESULT
10914 (DECL_TI_TEMPLATE (t))),
10915 args, complain, in_decl);
10916 if (argvec == error_mark_node)
10917 RETURN (error_mark_node);
10919 /* Check to see if we already have this specialization. */
10920 hash = hash_tmpl_and_args (gen_tmpl, argvec);
10921 spec = retrieve_specialization (gen_tmpl, argvec, hash);
10929 /* We can see more levels of arguments than parameters if
10930 there was a specialization of a member template, like
10933 template <class T> struct S { template <class U> void f(); }
10934 template <> template <class U> void S<int>::f(U);
10936 Here, we'll be substituting into the specialization,
10937 because that's where we can find the code we actually
10938 want to generate, but we'll have enough arguments for
10939 the most general template.
10941 We also deal with the peculiar case:
10943 template <class T> struct S {
10944 template <class U> friend void f();
10946 template <class U> void f() {}
10948 template void f<double>();
10950 Here, the ARGS for the instantiation of will be {int,
10951 double}. But, we only need as many ARGS as there are
10952 levels of template parameters in CODE_PATTERN. We are
10953 careful not to get fooled into reducing the ARGS in
10956 template <class T> struct S { template <class U> void f(U); }
10957 template <class T> template <> void S<T>::f(int) {}
10959 which we can spot because the pattern will be a
10960 specialization in this case. */
10961 args_depth = TMPL_ARGS_DEPTH (args);
10963 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t)));
10964 if (args_depth > parms_depth
10965 && !DECL_TEMPLATE_SPECIALIZATION (t))
10966 args = get_innermost_template_args (args, parms_depth);
10970 /* This special case arises when we have something like this:
10972 template <class T> struct S {
10973 friend void f<int>(int, double);
10976 Here, the DECL_TI_TEMPLATE for the friend declaration
10977 will be an IDENTIFIER_NODE. We are being called from
10978 tsubst_friend_function, and we want only to create a
10979 new decl (R) with appropriate types so that we can call
10980 determine_specialization. */
10981 gen_tmpl = NULL_TREE;
10984 if (DECL_CLASS_SCOPE_P (t))
10986 if (DECL_NAME (t) == constructor_name (DECL_CONTEXT (t)))
10990 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args,
10991 complain, t, /*entering_scope=*/1);
10996 ctx = DECL_CONTEXT (t);
10998 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
10999 if (type == error_mark_node)
11000 RETURN (error_mark_node);
11002 /* If we hit excessive deduction depth, the type is bogus even if
11003 it isn't error_mark_node, so don't build a decl. */
11004 if (excessive_deduction_depth)
11005 RETURN (error_mark_node);
11007 /* We do NOT check for matching decls pushed separately at this
11008 point, as they may not represent instantiations of this
11009 template, and in any case are considered separate under the
11012 DECL_USE_TEMPLATE (r) = 0;
11013 TREE_TYPE (r) = type;
11014 /* Clear out the mangled name and RTL for the instantiation. */
11015 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
11016 SET_DECL_RTL (r, NULL);
11017 /* Leave DECL_INITIAL set on deleted instantiations. */
11018 if (!DECL_DELETED_FN (r))
11019 DECL_INITIAL (r) = NULL_TREE;
11020 DECL_CONTEXT (r) = ctx;
11022 /* OpenMP UDRs have the only argument a reference to the declared
11023 type. We want to diagnose if the declared type is a reference,
11024 which is invalid, but as references to references are usually
11025 quietly merged, diagnose it here. */
11026 if (DECL_OMP_DECLARE_REDUCTION_P (t))
11029 = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (t))));
11030 argtype = tsubst (argtype, args, complain, in_decl);
11031 if (TREE_CODE (argtype) == REFERENCE_TYPE)
11032 error_at (DECL_SOURCE_LOCATION (t),
11033 "reference type %qT in "
11034 "%<#pragma omp declare reduction%>", argtype);
11035 if (strchr (IDENTIFIER_POINTER (DECL_NAME (t)), '~') == NULL)
11036 DECL_NAME (r) = omp_reduction_id (ERROR_MARK, DECL_NAME (t),
11040 if (member && DECL_CONV_FN_P (r))
11041 /* Type-conversion operator. Reconstruct the name, in
11042 case it's the name of one of the template's parameters. */
11043 DECL_NAME (r) = mangle_conv_op_name_for_type (TREE_TYPE (type));
11045 DECL_ARGUMENTS (r) = tsubst (DECL_ARGUMENTS (t), args,
11047 DECL_RESULT (r) = NULL_TREE;
11049 TREE_STATIC (r) = 0;
11050 TREE_PUBLIC (r) = TREE_PUBLIC (t);
11051 DECL_EXTERNAL (r) = 1;
11052 /* If this is an instantiation of a function with internal
11053 linkage, we already know what object file linkage will be
11054 assigned to the instantiation. */
11055 DECL_INTERFACE_KNOWN (r) = !TREE_PUBLIC (r);
11056 DECL_DEFER_OUTPUT (r) = 0;
11057 DECL_CHAIN (r) = NULL_TREE;
11058 DECL_PENDING_INLINE_INFO (r) = 0;
11059 DECL_PENDING_INLINE_P (r) = 0;
11060 DECL_SAVED_TREE (r) = NULL_TREE;
11061 DECL_STRUCT_FUNCTION (r) = NULL;
11063 /* We'll re-clone as appropriate in instantiate_template. */
11064 DECL_CLONED_FUNCTION (r) = NULL_TREE;
11066 /* If we aren't complaining now, return on error before we register
11067 the specialization so that we'll complain eventually. */
11068 if ((complain & tf_error) == 0
11069 && IDENTIFIER_OPNAME_P (DECL_NAME (r))
11070 && !grok_op_properties (r, /*complain=*/false))
11071 RETURN (error_mark_node);
11073 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
11074 this in the special friend case mentioned above where
11075 GEN_TMPL is NULL. */
11078 DECL_TEMPLATE_INFO (r)
11079 = build_template_info (gen_tmpl, argvec);
11080 SET_DECL_IMPLICIT_INSTANTIATION (r);
11083 = register_specialization (r, gen_tmpl, argvec, false, hash);
11085 /* We instantiated this while substituting into
11086 the type earlier (template/friend54.C). */
11089 /* We're not supposed to instantiate default arguments
11090 until they are called, for a template. But, for a
11093 template <class T> void f ()
11094 { extern void g(int i = T()); }
11096 we should do the substitution when the template is
11097 instantiated. We handle the member function case in
11098 instantiate_class_template since the default arguments
11099 might refer to other members of the class. */
11101 && !PRIMARY_TEMPLATE_P (gen_tmpl)
11102 && !uses_template_parms (argvec))
11103 tsubst_default_arguments (r, complain);
11106 DECL_TEMPLATE_INFO (r) = NULL_TREE;
11108 /* Copy the list of befriending classes. */
11109 for (friends = &DECL_BEFRIENDING_CLASSES (r);
11111 friends = &TREE_CHAIN (*friends))
11113 *friends = copy_node (*friends);
11114 TREE_VALUE (*friends) = tsubst (TREE_VALUE (*friends),
11119 if (DECL_CONSTRUCTOR_P (r) || DECL_DESTRUCTOR_P (r))
11121 maybe_retrofit_in_chrg (r);
11122 if (DECL_CONSTRUCTOR_P (r))
11123 grok_ctor_properties (ctx, r);
11124 if (DECL_INHERITED_CTOR_BASE (r))
11125 deduce_inheriting_ctor (r);
11126 /* If this is an instantiation of a member template, clone it.
11127 If it isn't, that'll be handled by
11128 clone_constructors_and_destructors. */
11129 if (PRIMARY_TEMPLATE_P (gen_tmpl))
11130 clone_function_decl (r, /*update_method_vec_p=*/0);
11132 else if ((complain & tf_error) != 0
11133 && IDENTIFIER_OPNAME_P (DECL_NAME (r))
11134 && !grok_op_properties (r, /*complain=*/true))
11135 RETURN (error_mark_node);
11137 if (DECL_FRIEND_P (t) && DECL_FRIEND_CONTEXT (t))
11138 SET_DECL_FRIEND_CONTEXT (r,
11139 tsubst (DECL_FRIEND_CONTEXT (t),
11140 args, complain, in_decl));
11142 /* Possibly limit visibility based on template args. */
11143 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
11144 if (DECL_VISIBILITY_SPECIFIED (t))
11146 DECL_VISIBILITY_SPECIFIED (r) = 0;
11147 DECL_ATTRIBUTES (r)
11148 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
11150 determine_visibility (r);
11151 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r)
11152 && !processing_template_decl)
11153 defaulted_late_check (r);
11155 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
11156 args, complain, in_decl);
11162 tree type = NULL_TREE;
11164 tree expanded_types = NULL_TREE;
11165 tree prev_r = NULL_TREE;
11166 tree first_r = NULL_TREE;
11168 if (DECL_PACK_P (t))
11170 /* If there is a local specialization that isn't a
11171 parameter pack, it means that we're doing a "simple"
11172 substitution from inside tsubst_pack_expansion. Just
11173 return the local specialization (which will be a single
11175 tree spec = retrieve_local_specialization (t);
11177 && TREE_CODE (spec) == PARM_DECL
11178 && TREE_CODE (TREE_TYPE (spec)) != TYPE_PACK_EXPANSION)
11181 /* Expand the TYPE_PACK_EXPANSION that provides the types for
11182 the parameters in this function parameter pack. */
11183 expanded_types = tsubst_pack_expansion (TREE_TYPE (t), args,
11184 complain, in_decl);
11185 if (TREE_CODE (expanded_types) == TREE_VEC)
11187 len = TREE_VEC_LENGTH (expanded_types);
11189 /* Zero-length parameter packs are boring. Just substitute
11192 RETURN (tsubst (TREE_CHAIN (t), args, complain,
11197 /* All we did was update the type. Make a note of that. */
11198 type = expanded_types;
11199 expanded_types = NULL_TREE;
11203 /* Loop through all of the parameters we'll build. When T is
11204 a function parameter pack, LEN is the number of expanded
11205 types in EXPANDED_TYPES; otherwise, LEN is 1. */
11207 for (i = 0; i < len; ++i)
11211 if (DECL_TEMPLATE_PARM_P (t))
11212 SET_DECL_TEMPLATE_PARM_P (r);
11214 if (expanded_types)
11215 /* We're on the Ith parameter of the function parameter
11218 /* Get the Ith type. */
11219 type = TREE_VEC_ELT (expanded_types, i);
11221 /* Rename the parameter to include the index. */
11223 = make_ith_pack_parameter_name (DECL_NAME (r), i);
11226 /* We're dealing with a normal parameter. */
11227 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
11229 type = type_decays_to (type);
11230 TREE_TYPE (r) = type;
11231 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
11233 if (DECL_INITIAL (r))
11235 if (TREE_CODE (DECL_INITIAL (r)) != TEMPLATE_PARM_INDEX)
11236 DECL_INITIAL (r) = TREE_TYPE (r);
11238 DECL_INITIAL (r) = tsubst (DECL_INITIAL (r), args,
11239 complain, in_decl);
11242 DECL_CONTEXT (r) = NULL_TREE;
11244 if (!DECL_TEMPLATE_PARM_P (r))
11245 DECL_ARG_TYPE (r) = type_passed_as (type);
11247 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
11248 args, complain, in_decl);
11250 /* Keep track of the first new parameter we
11251 generate. That's what will be returned to the
11256 /* Build a proper chain of parameters when substituting
11257 into a function parameter pack. */
11259 DECL_CHAIN (prev_r) = r;
11262 /* If cp_unevaluated_operand is set, we're just looking for a
11263 single dummy parameter, so don't keep going. */
11264 if (DECL_CHAIN (t) && !cp_unevaluated_operand)
11265 DECL_CHAIN (r) = tsubst (DECL_CHAIN (t), args,
11266 complain, DECL_CHAIN (t));
11268 /* FIRST_R contains the start of the chain we've built. */
11275 tree type = NULL_TREE;
11276 tree vec = NULL_TREE;
11277 tree expanded_types = NULL_TREE;
11280 if (PACK_EXPANSION_P (TREE_TYPE (t)))
11282 /* This field is a lambda capture pack. Return a TREE_VEC of
11283 the expanded fields to instantiate_class_template_1 and
11284 store them in the specializations hash table as a
11285 NONTYPE_ARGUMENT_PACK so that tsubst_copy can find them. */
11286 expanded_types = tsubst_pack_expansion (TREE_TYPE (t), args,
11287 complain, in_decl);
11288 if (TREE_CODE (expanded_types) == TREE_VEC)
11290 len = TREE_VEC_LENGTH (expanded_types);
11291 vec = make_tree_vec (len);
11295 /* All we did was update the type. Make a note of that. */
11296 type = expanded_types;
11297 expanded_types = NULL_TREE;
11301 for (int i = 0; i < len; ++i)
11304 if (expanded_types)
11306 type = TREE_VEC_ELT (expanded_types, i);
11308 = make_ith_pack_parameter_name (DECL_NAME (r), i);
11311 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
11313 if (type == error_mark_node)
11314 RETURN (error_mark_node);
11315 TREE_TYPE (r) = type;
11316 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
11318 if (DECL_C_BIT_FIELD (r))
11319 /* For bit-fields, DECL_INITIAL gives the number of bits. For
11320 non-bit-fields DECL_INITIAL is a non-static data member
11321 initializer, which gets deferred instantiation. */
11323 = tsubst_expr (DECL_INITIAL (t), args,
11325 /*integral_constant_expression_p=*/true);
11326 else if (DECL_INITIAL (t))
11328 /* Set up DECL_TEMPLATE_INFO so that we can get at the
11329 NSDMI in perform_member_init. Still set DECL_INITIAL
11330 so that we know there is one. */
11331 DECL_INITIAL (r) = void_node;
11332 gcc_assert (DECL_LANG_SPECIFIC (r) == NULL);
11333 retrofit_lang_decl (r);
11334 DECL_TEMPLATE_INFO (r) = build_template_info (t, args);
11336 /* We don't have to set DECL_CONTEXT here; it is set by
11337 finish_member_declaration. */
11338 DECL_CHAIN (r) = NULL_TREE;
11340 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r), 0,
11341 args, complain, in_decl);
11344 TREE_VEC_ELT (vec, i) = r;
11350 tree pack = make_node (NONTYPE_ARGUMENT_PACK);
11351 tree tpack = cxx_make_type (TYPE_ARGUMENT_PACK);
11352 SET_ARGUMENT_PACK_ARGS (pack, vec);
11353 SET_ARGUMENT_PACK_ARGS (tpack, expanded_types);
11354 TREE_TYPE (pack) = tpack;
11355 register_specialization (pack, t, args, false, 0);
11361 /* We reach here only for member using decls. We also need to check
11362 uses_template_parms because DECL_DEPENDENT_P is not set for a
11363 using-declaration that designates a member of the current
11364 instantiation (c++/53549). */
11365 if (DECL_DEPENDENT_P (t)
11366 || uses_template_parms (USING_DECL_SCOPE (t)))
11368 tree inst_scope = tsubst_copy (USING_DECL_SCOPE (t), args,
11369 complain, in_decl);
11370 tree name = tsubst_copy (DECL_NAME (t), args, complain, in_decl);
11371 r = do_class_using_decl (inst_scope, name);
11373 r = error_mark_node;
11376 TREE_PROTECTED (r) = TREE_PROTECTED (t);
11377 TREE_PRIVATE (r) = TREE_PRIVATE (t);
11383 DECL_CHAIN (r) = NULL_TREE;
11390 tree argvec = NULL_TREE;
11391 tree gen_tmpl = NULL_TREE;
11393 tree tmpl = NULL_TREE;
11395 tree type = NULL_TREE;
11398 if (TREE_TYPE (t) == error_mark_node)
11399 RETURN (error_mark_node);
11401 if (TREE_CODE (t) == TYPE_DECL
11402 && t == TYPE_MAIN_DECL (TREE_TYPE (t)))
11404 /* If this is the canonical decl, we don't have to
11405 mess with instantiations, and often we can't (for
11406 typename, template type parms and such). Note that
11407 TYPE_NAME is not correct for the above test if
11408 we've copied the type for a typedef. */
11409 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
11410 if (type == error_mark_node)
11411 RETURN (error_mark_node);
11412 r = TYPE_NAME (type);
11416 /* Check to see if we already have the specialization we
11419 if (DECL_CLASS_SCOPE_P (t) || DECL_NAMESPACE_SCOPE_P (t))
11421 /* T is a static data member or namespace-scope entity.
11422 We have to substitute into namespace-scope variables
11423 (not just variable templates) because of cases like:
11425 template <class T> void f() { extern T t; }
11427 where the entity referenced is not known until
11428 instantiation time. */
11430 ctx = DECL_CONTEXT (t);
11431 if (DECL_CLASS_SCOPE_P (t))
11433 ctx = tsubst_aggr_type (ctx, args,
11435 in_decl, /*entering_scope=*/1);
11436 /* If CTX is unchanged, then T is in fact the
11437 specialization we want. That situation occurs when
11438 referencing a static data member within in its own
11439 class. We can use pointer equality, rather than
11440 same_type_p, because DECL_CONTEXT is always
11442 if (ctx == DECL_CONTEXT (t)
11443 /* ... unless T is a member template; in which
11444 case our caller can be willing to create a
11445 specialization of that template represented
11447 && !(DECL_TI_TEMPLATE (t)
11448 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
11454 tmpl = DECL_TI_TEMPLATE (t);
11455 gen_tmpl = most_general_template (tmpl);
11456 argvec = tsubst (DECL_TI_ARGS (t), args, complain, in_decl);
11457 if (argvec != error_mark_node)
11458 argvec = (coerce_innermost_template_parms
11459 (DECL_TEMPLATE_PARMS (gen_tmpl),
11460 argvec, t, complain,
11461 /*all*/true, /*defarg*/true));
11462 if (argvec == error_mark_node)
11463 RETURN (error_mark_node);
11464 hash = hash_tmpl_and_args (gen_tmpl, argvec);
11465 spec = retrieve_specialization (gen_tmpl, argvec, hash);
11470 /* A local variable. */
11472 /* Subsequent calls to pushdecl will fill this in. */
11474 spec = retrieve_local_specialization (t);
11476 /* If we already have the specialization we need, there is
11477 nothing more to do. */
11484 /* Create a new node for the specialization we need. */
11486 if (type == NULL_TREE)
11488 if (is_typedef_decl (t))
11489 type = DECL_ORIGINAL_TYPE (t);
11491 type = TREE_TYPE (t);
11493 && VAR_HAD_UNKNOWN_BOUND (t)
11494 && type != error_mark_node)
11495 type = strip_array_domain (type);
11496 type = tsubst (type, args, complain, in_decl);
11500 /* Even if the original location is out of scope, the
11501 newly substituted one is not. */
11502 DECL_DEAD_FOR_LOCAL (r) = 0;
11503 DECL_INITIALIZED_P (r) = 0;
11504 DECL_TEMPLATE_INSTANTIATED (r) = 0;
11505 if (type == error_mark_node)
11506 RETURN (error_mark_node);
11507 if (TREE_CODE (type) == FUNCTION_TYPE)
11509 /* It may seem that this case cannot occur, since:
11514 declares a function, not a variable. However:
11517 template <typename T> void g() { T t; }
11518 template void g<f>();
11520 is an attempt to declare a variable with function
11522 error ("variable %qD has function type",
11523 /* R is not yet sufficiently initialized, so we
11524 just use its name. */
11526 RETURN (error_mark_node);
11528 type = complete_type (type);
11529 /* Wait until cp_finish_decl to set this again, to handle
11530 circular dependency (template/instantiate6.C). */
11531 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r) = 0;
11532 type = check_var_type (DECL_NAME (r), type);
11534 if (DECL_HAS_VALUE_EXPR_P (t))
11536 tree ve = DECL_VALUE_EXPR (t);
11537 ve = tsubst_expr (ve, args, complain, in_decl,
11538 /*constant_expression_p=*/false);
11539 if (REFERENCE_REF_P (ve))
11541 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
11542 ve = TREE_OPERAND (ve, 0);
11544 SET_DECL_VALUE_EXPR (r, ve);
11546 if (TREE_STATIC (r) || DECL_EXTERNAL (r))
11547 set_decl_tls_model (r, decl_tls_model (t));
11549 else if (DECL_SELF_REFERENCE_P (t))
11550 SET_DECL_SELF_REFERENCE_P (r);
11551 TREE_TYPE (r) = type;
11552 cp_apply_type_quals_to_decl (cp_type_quals (type), r);
11553 DECL_CONTEXT (r) = ctx;
11554 /* Clear out the mangled name and RTL for the instantiation. */
11555 SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
11556 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
11557 SET_DECL_RTL (r, NULL);
11558 /* The initializer must not be expanded until it is required;
11559 see [temp.inst]. */
11560 DECL_INITIAL (r) = NULL_TREE;
11562 DECL_MODE (r) = VOIDmode;
11563 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL))
11564 SET_DECL_RTL (r, NULL);
11565 DECL_SIZE (r) = DECL_SIZE_UNIT (r) = 0;
11568 /* Possibly limit visibility based on template args. */
11569 DECL_VISIBILITY (r) = VISIBILITY_DEFAULT;
11570 if (DECL_VISIBILITY_SPECIFIED (t))
11572 DECL_VISIBILITY_SPECIFIED (r) = 0;
11573 DECL_ATTRIBUTES (r)
11574 = remove_attribute ("visibility", DECL_ATTRIBUTES (r));
11576 determine_visibility (r);
11581 /* A static data member declaration is always marked
11582 external when it is declared in-class, even if an
11583 initializer is present. We mimic the non-template
11584 processing here. */
11585 DECL_EXTERNAL (r) = 1;
11586 if (DECL_NAMESPACE_SCOPE_P (t))
11587 DECL_NOT_REALLY_EXTERN (r) = 1;
11589 DECL_TEMPLATE_INFO (r) = build_template_info (tmpl, argvec);
11590 SET_DECL_IMPLICIT_INSTANTIATION (r);
11591 register_specialization (r, gen_tmpl, argvec, false, hash);
11593 else if (!cp_unevaluated_operand)
11594 register_local_specialization (r, t);
11596 DECL_CHAIN (r) = NULL_TREE;
11598 apply_late_template_attributes (&r, DECL_ATTRIBUTES (r),
11600 args, complain, in_decl);
11602 /* Preserve a typedef that names a type. */
11603 if (is_typedef_decl (r))
11605 DECL_ORIGINAL_TYPE (r) = NULL_TREE;
11606 set_underlying_type (r);
11607 if (TYPE_DECL_ALIAS_P (r) && type != error_mark_node)
11608 /* An alias template specialization can be dependent
11609 even if its underlying type is not. */
11610 TYPE_DEPENDENT_P_VALID (TREE_TYPE (r)) = false;
11613 layout_decl (r, 0);
11618 gcc_unreachable ();
11623 /* Restore the file and line information. */
11624 input_location = saved_loc;
11629 /* Substitute into the ARG_TYPES of a function type.
11630 If END is a TREE_CHAIN, leave it and any following types
11634 tsubst_arg_types (tree arg_types,
11637 tsubst_flags_t complain,
11640 tree remaining_arg_types;
11641 tree type = NULL_TREE;
11643 tree expanded_args = NULL_TREE;
11646 if (!arg_types || arg_types == void_list_node || arg_types == end)
11649 remaining_arg_types = tsubst_arg_types (TREE_CHAIN (arg_types),
11650 args, end, complain, in_decl);
11651 if (remaining_arg_types == error_mark_node)
11652 return error_mark_node;
11654 if (PACK_EXPANSION_P (TREE_VALUE (arg_types)))
11656 /* For a pack expansion, perform substitution on the
11657 entire expression. Later on, we'll handle the arguments
11659 expanded_args = tsubst_pack_expansion (TREE_VALUE (arg_types),
11660 args, complain, in_decl);
11662 if (TREE_CODE (expanded_args) == TREE_VEC)
11663 /* So that we'll spin through the parameters, one by one. */
11664 i = TREE_VEC_LENGTH (expanded_args);
11667 /* We only partially substituted into the parameter
11668 pack. Our type is TYPE_PACK_EXPANSION. */
11669 type = expanded_args;
11670 expanded_args = NULL_TREE;
11678 type = TREE_VEC_ELT (expanded_args, i);
11680 type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
11682 if (type == error_mark_node)
11683 return error_mark_node;
11684 if (VOID_TYPE_P (type))
11686 if (complain & tf_error)
11688 error ("invalid parameter type %qT", type);
11690 error ("in declaration %q+D", in_decl);
11692 return error_mark_node;
11695 if (abstract_virtuals_error_sfinae (ACU_PARM, type, complain))
11696 return error_mark_node;
11698 /* Do array-to-pointer, function-to-pointer conversion, and ignore
11699 top-level qualifiers as required. */
11700 type = cv_unqualified (type_decays_to (type));
11702 /* We do not substitute into default arguments here. The standard
11703 mandates that they be instantiated only when needed, which is
11704 done in build_over_call. */
11705 default_arg = TREE_PURPOSE (arg_types);
11707 if (default_arg && TREE_CODE (default_arg) == DEFAULT_ARG)
11709 /* We've instantiated a template before its default arguments
11710 have been parsed. This can happen for a nested template
11711 class, and is not an error unless we require the default
11712 argument in a call of this function. */
11713 remaining_arg_types =
11714 tree_cons (default_arg, type, remaining_arg_types);
11715 vec_safe_push (DEFARG_INSTANTIATIONS(default_arg), remaining_arg_types);
11718 remaining_arg_types =
11719 hash_tree_cons (default_arg, type, remaining_arg_types);
11722 return remaining_arg_types;
11725 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
11726 *not* handle the exception-specification for FNTYPE, because the
11727 initial substitution of explicitly provided template parameters
11728 during argument deduction forbids substitution into the
11729 exception-specification:
11733 All references in the function type of the function template to the
11734 corresponding template parameters are replaced by the specified tem-
11735 plate argument values. If a substitution in a template parameter or
11736 in the function type of the function template results in an invalid
11737 type, type deduction fails. [Note: The equivalent substitution in
11738 exception specifications is done only when the function is instanti-
11739 ated, at which point a program is ill-formed if the substitution
11740 results in an invalid type.] */
11743 tsubst_function_type (tree t,
11745 tsubst_flags_t complain,
11749 tree arg_types = NULL_TREE;
11752 /* The TYPE_CONTEXT is not used for function/method types. */
11753 gcc_assert (TYPE_CONTEXT (t) == NULL_TREE);
11755 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
11757 bool late_return_type_p = TYPE_HAS_LATE_RETURN_TYPE (t);
11759 if (late_return_type_p)
11761 /* Substitute the argument types. */
11762 arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args, NULL_TREE,
11763 complain, in_decl);
11764 if (arg_types == error_mark_node)
11765 return error_mark_node;
11767 tree save_ccp = current_class_ptr;
11768 tree save_ccr = current_class_ref;
11769 tree this_type = (TREE_CODE (t) == METHOD_TYPE
11770 ? TREE_TYPE (TREE_VALUE (arg_types)) : NULL_TREE);
11771 bool do_inject = this_type && CLASS_TYPE_P (this_type);
11774 /* DR 1207: 'this' is in scope in the trailing return type. */
11775 inject_this_parameter (this_type, cp_type_quals (this_type));
11778 /* Substitute the return type. */
11779 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
11783 current_class_ptr = save_ccp;
11784 current_class_ref = save_ccr;
11788 /* Substitute the return type. */
11789 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
11791 if (return_type == error_mark_node)
11792 return error_mark_node;
11793 /* DR 486 clarifies that creation of a function type with an
11794 invalid return type is a deduction failure. */
11795 if (TREE_CODE (return_type) == ARRAY_TYPE
11796 || TREE_CODE (return_type) == FUNCTION_TYPE)
11798 if (complain & tf_error)
11800 if (TREE_CODE (return_type) == ARRAY_TYPE)
11801 error ("function returning an array");
11803 error ("function returning a function");
11805 return error_mark_node;
11808 if (abstract_virtuals_error_sfinae (ACU_RETURN, return_type, complain))
11809 return error_mark_node;
11811 if (!late_return_type_p)
11813 /* Substitute the argument types. */
11814 arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args, NULL_TREE,
11815 complain, in_decl);
11816 if (arg_types == error_mark_node)
11817 return error_mark_node;
11820 /* Construct a new type node and return it. */
11821 if (TREE_CODE (t) == FUNCTION_TYPE)
11823 fntype = build_function_type (return_type, arg_types);
11824 fntype = apply_memfn_quals (fntype,
11825 type_memfn_quals (t),
11826 type_memfn_rqual (t));
11830 tree r = TREE_TYPE (TREE_VALUE (arg_types));
11831 /* Don't pick up extra function qualifiers from the basetype. */
11832 r = cp_build_qualified_type_real (r, type_memfn_quals (t), complain);
11833 if (! MAYBE_CLASS_TYPE_P (r))
11837 Type deduction may fail for any of the following
11840 -- Attempting to create "pointer to member of T" when T
11841 is not a class type. */
11842 if (complain & tf_error)
11843 error ("creating pointer to member function of non-class type %qT",
11845 return error_mark_node;
11848 fntype = build_method_type_directly (r, return_type,
11849 TREE_CHAIN (arg_types));
11850 fntype = build_ref_qualified_type (fntype, type_memfn_rqual (t));
11852 fntype = cp_build_type_attribute_variant (fntype, TYPE_ATTRIBUTES (t));
11854 if (late_return_type_p)
11855 TYPE_HAS_LATE_RETURN_TYPE (fntype) = 1;
11860 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
11861 ARGS into that specification, and return the substituted
11862 specification. If there is no specification, return NULL_TREE. */
11865 tsubst_exception_specification (tree fntype,
11867 tsubst_flags_t complain,
11874 specs = TYPE_RAISES_EXCEPTIONS (fntype);
11875 new_specs = NULL_TREE;
11876 if (specs && TREE_PURPOSE (specs))
11878 /* A noexcept-specifier. */
11879 tree expr = TREE_PURPOSE (specs);
11880 if (TREE_CODE (expr) == INTEGER_CST)
11884 /* Defer instantiation of noexcept-specifiers to avoid
11885 excessive instantiations (c++/49107). */
11886 new_specs = make_node (DEFERRED_NOEXCEPT);
11887 if (DEFERRED_NOEXCEPT_SPEC_P (specs))
11889 /* We already partially instantiated this member template,
11890 so combine the new args with the old. */
11891 DEFERRED_NOEXCEPT_PATTERN (new_specs)
11892 = DEFERRED_NOEXCEPT_PATTERN (expr);
11893 DEFERRED_NOEXCEPT_ARGS (new_specs)
11894 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr), args);
11898 DEFERRED_NOEXCEPT_PATTERN (new_specs) = expr;
11899 DEFERRED_NOEXCEPT_ARGS (new_specs) = args;
11903 new_specs = tsubst_copy_and_build
11904 (expr, args, complain, in_decl, /*function_p=*/false,
11905 /*integral_constant_expression_p=*/true);
11906 new_specs = build_noexcept_spec (new_specs, complain);
11910 if (! TREE_VALUE (specs))
11917 tree expanded_specs = NULL_TREE;
11919 if (PACK_EXPANSION_P (TREE_VALUE (specs)))
11921 /* Expand the pack expansion type. */
11922 expanded_specs = tsubst_pack_expansion (TREE_VALUE (specs),
11926 if (expanded_specs == error_mark_node)
11927 return error_mark_node;
11928 else if (TREE_CODE (expanded_specs) == TREE_VEC)
11929 len = TREE_VEC_LENGTH (expanded_specs);
11932 /* We're substituting into a member template, so
11933 we got a TYPE_PACK_EXPANSION back. Add that
11934 expansion and move on. */
11935 gcc_assert (TREE_CODE (expanded_specs)
11936 == TYPE_PACK_EXPANSION);
11937 new_specs = add_exception_specifier (new_specs,
11940 specs = TREE_CHAIN (specs);
11945 for (i = 0; i < len; ++i)
11947 if (expanded_specs)
11948 spec = TREE_VEC_ELT (expanded_specs, i);
11950 spec = tsubst (TREE_VALUE (specs), args, complain, in_decl);
11951 if (spec == error_mark_node)
11953 new_specs = add_exception_specifier (new_specs, spec,
11957 specs = TREE_CHAIN (specs);
11963 /* Take the tree structure T and replace template parameters used
11964 therein with the argument vector ARGS. IN_DECL is an associated
11965 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
11966 Issue error and warning messages under control of COMPLAIN. Note
11967 that we must be relatively non-tolerant of extensions here, in
11968 order to preserve conformance; if we allow substitutions that
11969 should not be allowed, we may allow argument deductions that should
11970 not succeed, and therefore report ambiguous overload situations
11971 where there are none. In theory, we could allow the substitution,
11972 but indicate that it should have failed, and allow our caller to
11973 make sure that the right thing happens, but we don't try to do this
11976 This function is used for dealing with types, decls and the like;
11977 for expressions, use tsubst_expr or tsubst_copy. */
11980 tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
11982 enum tree_code code;
11983 tree type, r = NULL_TREE;
11985 if (t == NULL_TREE || t == error_mark_node
11986 || t == integer_type_node
11987 || t == void_type_node
11988 || t == char_type_node
11989 || t == unknown_type_node
11990 || TREE_CODE (t) == NAMESPACE_DECL
11991 || TREE_CODE (t) == TRANSLATION_UNIT_DECL)
11995 return tsubst_decl (t, args, complain);
11997 if (args == NULL_TREE)
12000 code = TREE_CODE (t);
12002 if (code == IDENTIFIER_NODE)
12003 type = IDENTIFIER_TYPE_VALUE (t);
12005 type = TREE_TYPE (t);
12007 gcc_assert (type != unknown_type_node);
12009 /* Reuse typedefs. We need to do this to handle dependent attributes,
12010 such as attribute aligned. */
12012 && typedef_variant_p (t))
12014 tree decl = TYPE_NAME (t);
12016 if (alias_template_specialization_p (t))
12018 /* DECL represents an alias template and we want to
12020 tree tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
12021 tree gen_args = tsubst (DECL_TI_ARGS (decl), args, complain, in_decl);
12022 r = instantiate_alias_template (tmpl, gen_args, complain);
12024 else if (DECL_CLASS_SCOPE_P (decl)
12025 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl))
12026 && uses_template_parms (DECL_CONTEXT (decl)))
12028 tree tmpl = most_general_template (DECL_TI_TEMPLATE (decl));
12029 tree gen_args = tsubst (DECL_TI_ARGS (decl), args, complain, in_decl);
12030 r = retrieve_specialization (tmpl, gen_args, 0);
12032 else if (DECL_FUNCTION_SCOPE_P (decl)
12033 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl))
12034 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl))))
12035 r = retrieve_local_specialization (decl);
12037 /* The typedef is from a non-template context. */
12043 r = cp_build_qualified_type_real
12044 (r, cp_type_quals (t) | cp_type_quals (r),
12045 complain | tf_ignore_bad_quals);
12050 /* We don't have an instantiation yet, so drop the typedef. */
12051 int quals = cp_type_quals (t);
12052 t = DECL_ORIGINAL_TYPE (decl);
12053 t = cp_build_qualified_type_real (t, quals,
12054 complain | tf_ignore_bad_quals);
12059 && code != TYPENAME_TYPE
12060 && code != TEMPLATE_TYPE_PARM
12061 && code != IDENTIFIER_NODE
12062 && code != FUNCTION_TYPE
12063 && code != METHOD_TYPE)
12064 type = tsubst (type, args, complain, in_decl);
12065 if (type == error_mark_node)
12066 return error_mark_node;
12072 case ENUMERAL_TYPE:
12073 return tsubst_aggr_type (t, args, complain, in_decl,
12074 /*entering_scope=*/0);
12077 case IDENTIFIER_NODE:
12088 if (t == integer_type_node)
12091 if (TREE_CODE (TYPE_MIN_VALUE (t)) == INTEGER_CST
12092 && TREE_CODE (TYPE_MAX_VALUE (t)) == INTEGER_CST)
12096 tree max, omax = TREE_OPERAND (TYPE_MAX_VALUE (t), 0);
12098 max = tsubst_expr (omax, args, complain, in_decl,
12099 /*integral_constant_expression_p=*/false);
12101 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
12103 if (TREE_CODE (max) == NOP_EXPR
12104 && TREE_SIDE_EFFECTS (omax)
12105 && !TREE_TYPE (max))
12106 TREE_TYPE (max) = TREE_TYPE (TREE_OPERAND (max, 0));
12108 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
12109 with TREE_SIDE_EFFECTS that indicates this is not an integral
12110 constant expression. */
12111 if (processing_template_decl
12112 && TREE_SIDE_EFFECTS (omax) && TREE_CODE (omax) == NOP_EXPR)
12114 gcc_assert (TREE_CODE (max) == NOP_EXPR);
12115 TREE_SIDE_EFFECTS (max) = 1;
12118 return compute_array_index_type (NULL_TREE, max, complain);
12121 case TEMPLATE_TYPE_PARM:
12122 case TEMPLATE_TEMPLATE_PARM:
12123 case BOUND_TEMPLATE_TEMPLATE_PARM:
12124 case TEMPLATE_PARM_INDEX:
12129 tree arg = NULL_TREE;
12133 gcc_assert (TREE_VEC_LENGTH (args) > 0);
12134 template_parm_level_and_index (t, &level, &idx);
12136 levels = TMPL_ARGS_DEPTH (args);
12137 if (level <= levels)
12139 arg = TMPL_ARG (args, level, idx);
12141 if (arg && TREE_CODE (arg) == ARGUMENT_PACK_SELECT)
12143 /* See through ARGUMENT_PACK_SELECT arguments. */
12144 arg = ARGUMENT_PACK_SELECT_ARG (arg);
12145 /* If the selected argument is an expansion E, that most
12146 likely means we were called from
12147 gen_elem_of_pack_expansion_instantiation during the
12148 substituting of pack an argument pack (which Ith
12149 element is a pack expansion, where I is
12150 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
12151 In this case, the Ith element resulting from this
12152 substituting is going to be a pack expansion, which
12153 pattern is the pattern of E. Let's return the
12155 gen_elem_of_pack_expansion_instantiation will
12156 build the resulting pack expansion from it. */
12157 if (PACK_EXPANSION_P (arg))
12159 /* Make sure we aren't throwing away arg info. */
12160 gcc_assert (!PACK_EXPANSION_EXTRA_ARGS (arg));
12161 arg = PACK_EXPANSION_PATTERN (arg);
12166 if (arg == error_mark_node)
12167 return error_mark_node;
12168 else if (arg != NULL_TREE)
12170 if (ARGUMENT_PACK_P (arg))
12171 /* If ARG is an argument pack, we don't actually want to
12172 perform a substitution here, because substitutions
12173 for argument packs are only done
12174 element-by-element. We can get to this point when
12175 substituting the type of a non-type template
12176 parameter pack, when that type actually contains
12177 template parameter packs from an outer template, e.g.,
12179 template<typename... Types> struct A {
12180 template<Types... Values> struct B { };
12184 if (code == TEMPLATE_TYPE_PARM)
12187 gcc_assert (TYPE_P (arg));
12189 quals = cp_type_quals (arg) | cp_type_quals (t);
12191 return cp_build_qualified_type_real
12192 (arg, quals, complain | tf_ignore_bad_quals);
12194 else if (code == BOUND_TEMPLATE_TEMPLATE_PARM)
12196 /* We are processing a type constructed from a
12197 template template parameter. */
12198 tree argvec = tsubst (TYPE_TI_ARGS (t),
12199 args, complain, in_decl);
12200 if (argvec == error_mark_node)
12201 return error_mark_node;
12203 gcc_assert (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
12204 || TREE_CODE (arg) == TEMPLATE_DECL
12205 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE);
12207 if (TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
12208 /* Consider this code:
12210 template <template <class> class Template>
12212 template <class Arg> using Bind = Template<Arg>;
12215 template <template <class> class Template, class Arg>
12216 using Instantiate = Template<Arg>; //#0
12218 template <template <class> class Template,
12221 Instantiate<Internal<Template>::template Bind,
12224 When #1 is parsed, the
12225 BOUND_TEMPLATE_TEMPLATE_PARM representing the
12226 parameter `Template' in #0 matches the
12227 UNBOUND_CLASS_TEMPLATE representing the argument
12228 `Internal<Template>::template Bind'; We then want
12229 to assemble the type `Bind<Argument>' that can't
12230 be fully created right now, because
12231 `Internal<Template>' not being complete, the Bind
12232 template cannot be looked up in that context. So
12233 we need to "store" `Bind<Argument>' for later
12234 when the context of Bind becomes complete. Let's
12235 store that in a TYPENAME_TYPE. */
12236 return make_typename_type (TYPE_CONTEXT (arg),
12237 build_nt (TEMPLATE_ID_EXPR,
12238 TYPE_IDENTIFIER (arg),
12243 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
12244 are resolving nested-types in the signature of a
12245 member function templates. Otherwise ARG is a
12246 TEMPLATE_DECL and is the real template to be
12248 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
12249 arg = TYPE_NAME (arg);
12251 r = lookup_template_class (arg,
12253 DECL_CONTEXT (arg),
12254 /*entering_scope=*/0,
12256 return cp_build_qualified_type_real
12257 (r, cp_type_quals (t) | cp_type_quals (r), complain);
12260 /* TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX. */
12261 return convert_from_reference (unshare_expr (arg));
12265 /* This can happen during the attempted tsubst'ing in
12266 unify. This means that we don't yet have any information
12267 about the template parameter in question. */
12270 /* Early in template argument deduction substitution, we don't
12271 want to reduce the level of 'auto', or it will be confused
12272 with a normal template parm in subsequent deduction. */
12273 if (is_auto (t) && (complain & tf_partial))
12276 /* If we get here, we must have been looking at a parm for a
12277 more deeply nested template. Make a new version of this
12278 template parameter, but with a lower level. */
12281 case TEMPLATE_TYPE_PARM:
12282 case TEMPLATE_TEMPLATE_PARM:
12283 case BOUND_TEMPLATE_TEMPLATE_PARM:
12284 if (cp_type_quals (t))
12286 r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
12287 r = cp_build_qualified_type_real
12288 (r, cp_type_quals (t),
12289 complain | (code == TEMPLATE_TYPE_PARM
12290 ? tf_ignore_bad_quals : 0));
12295 TEMPLATE_TYPE_PARM_INDEX (r)
12296 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t),
12297 r, levels, args, complain);
12298 TYPE_STUB_DECL (r) = TYPE_NAME (r) = TEMPLATE_TYPE_DECL (r);
12299 TYPE_MAIN_VARIANT (r) = r;
12300 TYPE_POINTER_TO (r) = NULL_TREE;
12301 TYPE_REFERENCE_TO (r) = NULL_TREE;
12303 if (TREE_CODE (r) == TEMPLATE_TEMPLATE_PARM)
12304 /* We have reduced the level of the template
12305 template parameter, but not the levels of its
12306 template parameters, so canonical_type_parameter
12307 will not be able to find the canonical template
12308 template parameter for this level. Thus, we
12309 require structural equality checking to compare
12310 TEMPLATE_TEMPLATE_PARMs. */
12311 SET_TYPE_STRUCTURAL_EQUALITY (r);
12312 else if (TYPE_STRUCTURAL_EQUALITY_P (t))
12313 SET_TYPE_STRUCTURAL_EQUALITY (r);
12315 TYPE_CANONICAL (r) = canonical_type_parameter (r);
12317 if (code == BOUND_TEMPLATE_TEMPLATE_PARM)
12319 tree argvec = tsubst (TYPE_TI_ARGS (t), args,
12320 complain, in_decl);
12321 if (argvec == error_mark_node)
12322 return error_mark_node;
12324 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r)
12325 = build_template_info (TYPE_TI_TEMPLATE (t), argvec);
12330 case TEMPLATE_PARM_INDEX:
12331 r = reduce_template_parm_level (t, type, levels, args, complain);
12335 gcc_unreachable ();
12343 tree purpose, value, chain;
12345 if (t == void_list_node)
12348 purpose = TREE_PURPOSE (t);
12351 purpose = tsubst (purpose, args, complain, in_decl);
12352 if (purpose == error_mark_node)
12353 return error_mark_node;
12355 value = TREE_VALUE (t);
12358 value = tsubst (value, args, complain, in_decl);
12359 if (value == error_mark_node)
12360 return error_mark_node;
12362 chain = TREE_CHAIN (t);
12363 if (chain && chain != void_type_node)
12365 chain = tsubst (chain, args, complain, in_decl);
12366 if (chain == error_mark_node)
12367 return error_mark_node;
12369 if (purpose == TREE_PURPOSE (t)
12370 && value == TREE_VALUE (t)
12371 && chain == TREE_CHAIN (t))
12373 return hash_tree_cons (purpose, value, chain);
12377 /* We should never be tsubsting a binfo. */
12378 gcc_unreachable ();
12381 /* A vector of template arguments. */
12382 gcc_assert (!type);
12383 return tsubst_template_args (t, args, complain, in_decl);
12386 case REFERENCE_TYPE:
12388 if (type == TREE_TYPE (t) && TREE_CODE (type) != METHOD_TYPE)
12393 Type deduction may fail for any of the following
12396 -- Attempting to create a pointer to reference type.
12397 -- Attempting to create a reference to a reference type or
12398 a reference to void.
12400 Core issue 106 says that creating a reference to a reference
12401 during instantiation is no longer a cause for failure. We
12402 only enforce this check in strict C++98 mode. */
12403 if ((TREE_CODE (type) == REFERENCE_TYPE
12404 && (((cxx_dialect == cxx98) && flag_iso) || code != REFERENCE_TYPE))
12405 || (code == REFERENCE_TYPE && VOID_TYPE_P (type)))
12407 static location_t last_loc;
12409 /* We keep track of the last time we issued this error
12410 message to avoid spewing a ton of messages during a
12411 single bad template instantiation. */
12412 if (complain & tf_error
12413 && last_loc != input_location)
12415 if (VOID_TYPE_P (type))
12416 error ("forming reference to void");
12417 else if (code == POINTER_TYPE)
12418 error ("forming pointer to reference type %qT", type);
12420 error ("forming reference to reference type %qT", type);
12421 last_loc = input_location;
12424 return error_mark_node;
12426 else if (TREE_CODE (type) == FUNCTION_TYPE
12427 && (type_memfn_quals (type) != TYPE_UNQUALIFIED
12428 || type_memfn_rqual (type) != REF_QUAL_NONE))
12430 if (complain & tf_error)
12432 if (code == POINTER_TYPE)
12433 error ("forming pointer to qualified function type %qT",
12436 error ("forming reference to qualified function type %qT",
12439 return error_mark_node;
12441 else if (code == POINTER_TYPE)
12443 r = build_pointer_type (type);
12444 if (TREE_CODE (type) == METHOD_TYPE)
12445 r = build_ptrmemfunc_type (r);
12447 else if (TREE_CODE (type) == REFERENCE_TYPE)
12448 /* In C++0x, during template argument substitution, when there is an
12449 attempt to create a reference to a reference type, reference
12450 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
12452 "If a template-argument for a template-parameter T names a type
12453 that is a reference to a type A, an attempt to create the type
12454 'lvalue reference to cv T' creates the type 'lvalue reference to
12455 A,' while an attempt to create the type type rvalue reference to
12456 cv T' creates the type T"
12458 r = cp_build_reference_type
12460 TYPE_REF_IS_RVALUE (t) && TYPE_REF_IS_RVALUE (type));
12462 r = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
12463 r = cp_build_qualified_type_real (r, cp_type_quals (t), complain);
12465 if (r != error_mark_node)
12466 /* Will this ever be needed for TYPE_..._TO values? */
12473 r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
12474 if (r == error_mark_node || !MAYBE_CLASS_TYPE_P (r))
12478 Type deduction may fail for any of the following
12481 -- Attempting to create "pointer to member of T" when T
12482 is not a class type. */
12483 if (complain & tf_error)
12484 error ("creating pointer to member of non-class type %qT", r);
12485 return error_mark_node;
12487 if (TREE_CODE (type) == REFERENCE_TYPE)
12489 if (complain & tf_error)
12490 error ("creating pointer to member reference type %qT", type);
12491 return error_mark_node;
12493 if (VOID_TYPE_P (type))
12495 if (complain & tf_error)
12496 error ("creating pointer to member of type void");
12497 return error_mark_node;
12499 gcc_assert (TREE_CODE (type) != METHOD_TYPE);
12500 if (TREE_CODE (type) == FUNCTION_TYPE)
12502 /* The type of the implicit object parameter gets its
12503 cv-qualifiers from the FUNCTION_TYPE. */
12506 = build_memfn_type (type, r, type_memfn_quals (type),
12507 type_memfn_rqual (type));
12508 memptr = build_ptrmemfunc_type (build_pointer_type (method_type));
12509 return cp_build_qualified_type_real (memptr, cp_type_quals (t),
12513 return cp_build_qualified_type_real (build_ptrmem_type (r, type),
12517 case FUNCTION_TYPE:
12522 fntype = tsubst_function_type (t, args, complain, in_decl);
12523 if (fntype == error_mark_node)
12524 return error_mark_node;
12526 /* Substitute the exception specification. */
12527 specs = tsubst_exception_specification (t, args, complain,
12528 in_decl, /*defer_ok*/true);
12529 if (specs == error_mark_node)
12530 return error_mark_node;
12532 fntype = build_exception_variant (fntype, specs);
12537 tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
12538 if (domain == error_mark_node)
12539 return error_mark_node;
12541 /* As an optimization, we avoid regenerating the array type if
12542 it will obviously be the same as T. */
12543 if (type == TREE_TYPE (t) && domain == TYPE_DOMAIN (t))
12546 /* These checks should match the ones in create_array_type_for_decl.
12550 The deduction may fail for any of the following reasons:
12552 -- Attempting to create an array with an element type that
12553 is void, a function type, or a reference type, or [DR337]
12554 an abstract class type. */
12555 if (VOID_TYPE_P (type)
12556 || TREE_CODE (type) == FUNCTION_TYPE
12557 || (TREE_CODE (type) == ARRAY_TYPE
12558 && TYPE_DOMAIN (type) == NULL_TREE)
12559 || TREE_CODE (type) == REFERENCE_TYPE)
12561 if (complain & tf_error)
12562 error ("creating array of %qT", type);
12563 return error_mark_node;
12566 if (abstract_virtuals_error_sfinae (ACU_ARRAY, type, complain))
12567 return error_mark_node;
12569 r = build_cplus_array_type (type, domain);
12571 if (TYPE_USER_ALIGN (t))
12573 TYPE_ALIGN (r) = TYPE_ALIGN (t);
12574 TYPE_USER_ALIGN (r) = 1;
12580 case TYPENAME_TYPE:
12582 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
12583 in_decl, /*entering_scope=*/1);
12584 tree f = tsubst_copy (TYPENAME_TYPE_FULLNAME (t), args,
12585 complain, in_decl);
12587 if (ctx == error_mark_node || f == error_mark_node)
12588 return error_mark_node;
12590 if (!MAYBE_CLASS_TYPE_P (ctx))
12592 if (complain & tf_error)
12593 error ("%qT is not a class, struct, or union type", ctx);
12594 return error_mark_node;
12596 else if (!uses_template_parms (ctx) && !TYPE_BEING_DEFINED (ctx))
12598 /* Normally, make_typename_type does not require that the CTX
12599 have complete type in order to allow things like:
12601 template <class T> struct S { typename S<T>::X Y; };
12603 But, such constructs have already been resolved by this
12604 point, so here CTX really should have complete type, unless
12605 it's a partial instantiation. */
12606 ctx = complete_type (ctx);
12607 if (!COMPLETE_TYPE_P (ctx))
12609 if (complain & tf_error)
12610 cxx_incomplete_type_error (NULL_TREE, ctx);
12611 return error_mark_node;
12615 f = make_typename_type (ctx, f, typename_type,
12616 complain | tf_keep_type_decl);
12617 if (f == error_mark_node)
12619 if (TREE_CODE (f) == TYPE_DECL)
12621 complain |= tf_ignore_bad_quals;
12625 if (TREE_CODE (f) != TYPENAME_TYPE)
12627 if (TYPENAME_IS_ENUM_P (t) && TREE_CODE (f) != ENUMERAL_TYPE)
12629 if (complain & tf_error)
12630 error ("%qT resolves to %qT, which is not an enumeration type",
12633 return error_mark_node;
12635 else if (TYPENAME_IS_CLASS_P (t) && !CLASS_TYPE_P (f))
12637 if (complain & tf_error)
12638 error ("%qT resolves to %qT, which is is not a class type",
12641 return error_mark_node;
12645 return cp_build_qualified_type_real
12646 (f, cp_type_quals (f) | cp_type_quals (t), complain);
12649 case UNBOUND_CLASS_TEMPLATE:
12651 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
12652 in_decl, /*entering_scope=*/1);
12653 tree name = TYPE_IDENTIFIER (t);
12654 tree parm_list = DECL_TEMPLATE_PARMS (TYPE_NAME (t));
12656 if (ctx == error_mark_node || name == error_mark_node)
12657 return error_mark_node;
12660 parm_list = tsubst_template_parms (parm_list, args, complain);
12661 return make_unbound_class_template (ctx, name, parm_list, complain);
12668 ++cp_unevaluated_operand;
12669 ++c_inhibit_evaluation_warnings;
12671 type = tsubst_expr (TYPEOF_TYPE_EXPR (t), args,
12673 /*integral_constant_expression_p=*/false);
12675 --cp_unevaluated_operand;
12676 --c_inhibit_evaluation_warnings;
12678 type = finish_typeof (type);
12679 return cp_build_qualified_type_real (type,
12681 | cp_type_quals (type),
12685 case DECLTYPE_TYPE:
12689 ++cp_unevaluated_operand;
12690 ++c_inhibit_evaluation_warnings;
12692 type = tsubst_copy_and_build (DECLTYPE_TYPE_EXPR (t), args,
12693 complain|tf_decltype, in_decl,
12694 /*function_p*/false,
12695 /*integral_constant_expression*/false);
12697 --cp_unevaluated_operand;
12698 --c_inhibit_evaluation_warnings;
12700 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t))
12701 type = lambda_capture_field_type (type,
12702 DECLTYPE_FOR_INIT_CAPTURE (t));
12703 else if (DECLTYPE_FOR_LAMBDA_PROXY (t))
12704 type = lambda_proxy_type (type);
12707 bool id = DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t);
12708 if (id && TREE_CODE (DECLTYPE_TYPE_EXPR (t)) == BIT_NOT_EXPR
12710 /* In a template ~id could be either a complement expression
12711 or an unqualified-id naming a destructor; if instantiating
12712 it produces an expression, it's not an id-expression or
12715 type = finish_decltype_type (type, id, complain);
12717 return cp_build_qualified_type_real (type,
12719 | cp_type_quals (type),
12720 complain | tf_ignore_bad_quals);
12723 case UNDERLYING_TYPE:
12725 tree type = tsubst (UNDERLYING_TYPE_TYPE (t), args,
12726 complain, in_decl);
12727 return finish_underlying_type (type);
12730 case TYPE_ARGUMENT_PACK:
12731 case NONTYPE_ARGUMENT_PACK:
12733 tree r = TYPE_P (t) ? cxx_make_type (code) : make_node (code);
12735 tsubst_template_args (ARGUMENT_PACK_ARGS (t),
12739 SET_ARGUMENT_PACK_ARGS (r, packed_out);
12741 /* For template nontype argument packs, also substitute into
12743 if (code == NONTYPE_ARGUMENT_PACK)
12744 TREE_TYPE (r) = tsubst (TREE_TYPE (t), args, complain, in_decl);
12763 /* We should use one of the expression tsubsts for these codes. */
12764 gcc_unreachable ();
12767 sorry ("use of %qs in template", get_tree_code_name (code));
12768 return error_mark_node;
12772 /* Like tsubst_expr for a BASELINK. OBJECT_TYPE, if non-NULL, is the
12773 type of the expression on the left-hand side of the "." or "->"
12777 tsubst_baselink (tree baselink, tree object_type,
12778 tree args, tsubst_flags_t complain, tree in_decl)
12781 tree qualifying_scope;
12784 tree template_args = 0;
12785 bool template_id_p = false;
12786 bool qualified = BASELINK_QUALIFIED_P (baselink);
12788 /* A baselink indicates a function from a base class. Both the
12789 BASELINK_ACCESS_BINFO and the base class referenced may
12790 indicate bases of the template class, rather than the
12791 instantiated class. In addition, lookups that were not
12792 ambiguous before may be ambiguous now. Therefore, we perform
12793 the lookup again. */
12794 qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink));
12795 qualifying_scope = tsubst (qualifying_scope, args,
12796 complain, in_decl);
12797 fns = BASELINK_FUNCTIONS (baselink);
12798 optype = tsubst (BASELINK_OPTYPE (baselink), args, complain, in_decl);
12799 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
12801 template_id_p = true;
12802 template_args = TREE_OPERAND (fns, 1);
12803 fns = TREE_OPERAND (fns, 0);
12805 template_args = tsubst_template_args (template_args, args,
12806 complain, in_decl);
12808 name = DECL_NAME (get_first_fn (fns));
12809 if (IDENTIFIER_TYPENAME_P (name))
12810 name = mangle_conv_op_name_for_type (optype);
12811 baselink = lookup_fnfields (qualifying_scope, name, /*protect=*/1);
12813 return error_mark_node;
12815 /* If lookup found a single function, mark it as used at this
12816 point. (If it lookup found multiple functions the one selected
12817 later by overload resolution will be marked as used at that
12819 if (BASELINK_P (baselink))
12820 fns = BASELINK_FUNCTIONS (baselink);
12821 if (!template_id_p && !really_overloaded_fn (fns)
12822 && !mark_used (OVL_CURRENT (fns), complain) && !(complain & tf_error))
12823 return error_mark_node;
12825 /* Add back the template arguments, if present. */
12826 if (BASELINK_P (baselink) && template_id_p)
12827 BASELINK_FUNCTIONS (baselink)
12828 = build2 (TEMPLATE_ID_EXPR,
12830 BASELINK_FUNCTIONS (baselink),
12832 /* Update the conversion operator type. */
12833 BASELINK_OPTYPE (baselink) = optype;
12836 object_type = current_class_type;
12839 baselink = adjust_result_of_qualified_name_lookup (baselink,
12845 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
12846 true if the qualified-id will be a postfix-expression in-and-of
12847 itself; false if more of the postfix-expression follows the
12848 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
12852 tsubst_qualified_id (tree qualified_id, tree args,
12853 tsubst_flags_t complain, tree in_decl,
12854 bool done, bool address_p)
12860 tree template_args;
12861 location_t loc = UNKNOWN_LOCATION;
12863 gcc_assert (TREE_CODE (qualified_id) == SCOPE_REF);
12865 /* Figure out what name to look up. */
12866 name = TREE_OPERAND (qualified_id, 1);
12867 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
12869 is_template = true;
12870 loc = EXPR_LOCATION (name);
12871 template_args = TREE_OPERAND (name, 1);
12873 template_args = tsubst_template_args (template_args, args,
12874 complain, in_decl);
12875 name = TREE_OPERAND (name, 0);
12879 is_template = false;
12880 template_args = NULL_TREE;
12883 /* Substitute into the qualifying scope. When there are no ARGS, we
12884 are just trying to simplify a non-dependent expression. In that
12885 case the qualifying scope may be dependent, and, in any case,
12886 substituting will not help. */
12887 scope = TREE_OPERAND (qualified_id, 0);
12890 scope = tsubst (scope, args, complain, in_decl);
12891 expr = tsubst_copy (name, args, complain, in_decl);
12896 if (dependent_scope_p (scope))
12899 expr = build_min_nt_loc (loc, TEMPLATE_ID_EXPR, expr, template_args);
12900 return build_qualified_name (NULL_TREE, scope, expr,
12901 QUALIFIED_NAME_IS_TEMPLATE (qualified_id));
12904 if (!BASELINK_P (name) && !DECL_P (expr))
12906 if (TREE_CODE (expr) == BIT_NOT_EXPR)
12908 /* A BIT_NOT_EXPR is used to represent a destructor. */
12909 if (!check_dtor_name (scope, TREE_OPERAND (expr, 0)))
12911 error ("qualifying type %qT does not match destructor name ~%qT",
12912 scope, TREE_OPERAND (expr, 0));
12913 expr = error_mark_node;
12916 expr = lookup_qualified_name (scope, complete_dtor_identifier,
12917 /*is_type_p=*/0, false);
12920 expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0, false);
12921 if (TREE_CODE (TREE_CODE (expr) == TEMPLATE_DECL
12922 ? DECL_TEMPLATE_RESULT (expr) : expr) == TYPE_DECL)
12924 if (complain & tf_error)
12926 error ("dependent-name %qE is parsed as a non-type, but "
12927 "instantiation yields a type", qualified_id);
12928 inform (input_location, "say %<typename %E%> if a type is meant", qualified_id);
12930 return error_mark_node;
12936 check_accessibility_of_qualified_id (expr, /*object_type=*/NULL_TREE,
12938 /* Remember that there was a reference to this entity. */
12939 if (!mark_used (expr, complain) && !(complain & tf_error))
12940 return error_mark_node;
12943 if (expr == error_mark_node || TREE_CODE (expr) == TREE_LIST)
12945 if (complain & tf_error)
12946 qualified_name_lookup_error (scope,
12947 TREE_OPERAND (qualified_id, 1),
12948 expr, input_location);
12949 return error_mark_node;
12953 expr = lookup_template_function (expr, template_args);
12955 if (expr == error_mark_node && complain & tf_error)
12956 qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1),
12957 expr, input_location);
12958 else if (TYPE_P (scope))
12960 expr = (adjust_result_of_qualified_name_lookup
12961 (expr, scope, current_nonlambda_class_type ()));
12962 expr = (finish_qualified_id_expr
12963 (scope, expr, done, address_p && PTRMEM_OK_P (qualified_id),
12964 QUALIFIED_NAME_IS_TEMPLATE (qualified_id),
12965 /*template_arg_p=*/false, complain));
12968 /* Expressions do not generally have reference type. */
12969 if (TREE_CODE (expr) != SCOPE_REF
12970 /* However, if we're about to form a pointer-to-member, we just
12971 want the referenced member referenced. */
12972 && TREE_CODE (expr) != OFFSET_REF)
12973 expr = convert_from_reference (expr);
12978 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
12979 initializer, DECL is the substituted VAR_DECL. Other arguments are as
12983 tsubst_init (tree init, tree decl, tree args,
12984 tsubst_flags_t complain, tree in_decl)
12989 init = tsubst_expr (init, args, complain, in_decl, false);
12993 /* If we had an initializer but it
12994 instantiated to nothing,
12995 value-initialize the object. This will
12996 only occur when the initializer was a
12997 pack expansion where the parameter packs
12998 used in that expansion were of length
13000 init = build_value_init (TREE_TYPE (decl),
13002 if (TREE_CODE (init) == AGGR_INIT_EXPR)
13003 init = get_target_expr_sfinae (init, complain);
13009 /* Like tsubst, but deals with expressions. This function just replaces
13010 template parms; to finish processing the resultant expression, use
13011 tsubst_copy_and_build or tsubst_expr. */
13014 tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
13016 enum tree_code code;
13019 if (t == NULL_TREE || t == error_mark_node || args == NULL_TREE)
13022 code = TREE_CODE (t);
13027 r = retrieve_local_specialization (t);
13029 if (r == NULL_TREE)
13031 /* We get here for a use of 'this' in an NSDMI. */
13032 if (DECL_NAME (t) == this_identifier
13033 && current_function_decl
13034 && DECL_CONSTRUCTOR_P (current_function_decl))
13035 return current_class_ptr;
13037 /* This can happen for a parameter name used later in a function
13038 declaration (such as in a late-specified return type). Just
13039 make a dummy decl, since it's only used for its type. */
13040 gcc_assert (cp_unevaluated_operand != 0);
13041 r = tsubst_decl (t, args, complain);
13042 /* Give it the template pattern as its context; its true context
13043 hasn't been instantiated yet and this is good enough for
13045 DECL_CONTEXT (r) = DECL_CONTEXT (t);
13048 if (TREE_CODE (r) == ARGUMENT_PACK_SELECT)
13049 r = ARGUMENT_PACK_SELECT_ARG (r);
13050 if (!mark_used (r, complain) && !(complain & tf_error))
13051 return error_mark_node;
13059 if (DECL_TEMPLATE_PARM_P (t))
13060 return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
13061 /* There is no need to substitute into namespace-scope
13063 if (DECL_NAMESPACE_SCOPE_P (t))
13065 /* If ARGS is NULL, then T is known to be non-dependent. */
13066 if (args == NULL_TREE)
13067 return scalar_constant_value (t);
13069 /* Unfortunately, we cannot just call lookup_name here.
13072 template <int I> int f() {
13074 struct S { void g() { E e = a; } };
13077 When we instantiate f<7>::S::g(), say, lookup_name is not
13078 clever enough to find f<7>::a. */
13080 = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
13081 /*entering_scope=*/0);
13083 for (v = TYPE_VALUES (enum_type);
13085 v = TREE_CHAIN (v))
13086 if (TREE_PURPOSE (v) == DECL_NAME (t))
13087 return TREE_VALUE (v);
13089 /* We didn't find the name. That should never happen; if
13090 name-lookup found it during preliminary parsing, we
13091 should find it again here during instantiation. */
13092 gcc_unreachable ();
13097 if (PACK_EXPANSION_P (TREE_TYPE (t)))
13099 /* Check for a local specialization set up by
13100 tsubst_pack_expansion. */
13101 if (tree r = retrieve_local_specialization (t))
13103 if (TREE_CODE (r) == ARGUMENT_PACK_SELECT)
13104 r = ARGUMENT_PACK_SELECT_ARG (r);
13108 /* When retrieving a capture pack from a generic lambda, remove the
13109 lambda call op's own template argument list from ARGS. Only the
13110 template arguments active for the closure type should be used to
13111 retrieve the pack specialization. */
13112 if (LAMBDA_FUNCTION_P (current_function_decl)
13113 && (template_class_depth (DECL_CONTEXT (t))
13114 != TMPL_ARGS_DEPTH (args)))
13115 args = strip_innermost_template_args (args, 1);
13117 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
13118 tsubst_decl put in the hash table. */
13119 return retrieve_specialization (t, args, 0);
13122 if (DECL_CONTEXT (t))
13126 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
13127 /*entering_scope=*/1);
13128 if (ctx != DECL_CONTEXT (t))
13130 tree r = lookup_field (ctx, DECL_NAME (t), 0, false);
13133 if (complain & tf_error)
13134 error ("using invalid field %qD", t);
13135 return error_mark_node;
13144 case FUNCTION_DECL:
13145 if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
13146 r = tsubst (t, args, complain, in_decl);
13147 else if (local_variable_p (t))
13149 r = retrieve_local_specialization (t);
13150 if (r == NULL_TREE)
13152 /* First try name lookup to find the instantiation. */
13153 r = lookup_name (DECL_NAME (t));
13156 /* Make sure that the one we found is the one we want. */
13157 tree ctx = DECL_CONTEXT (t);
13158 if (DECL_LANG_SPECIFIC (ctx) && DECL_TEMPLATE_INFO (ctx))
13159 ctx = tsubst (ctx, args, complain, in_decl);
13160 if (ctx != DECL_CONTEXT (r))
13168 /* This can happen for a variable used in a
13169 late-specified return type of a local lambda, or for a
13170 local static or constant. Building a new VAR_DECL
13171 should be OK in all those cases. */
13172 r = tsubst_decl (t, args, complain);
13173 if (decl_maybe_constant_var_p (r))
13175 /* We can't call cp_finish_decl, so handle the
13176 initializer by hand. */
13177 tree init = tsubst_init (DECL_INITIAL (t), r, args,
13178 complain, in_decl);
13179 if (!processing_template_decl)
13180 init = maybe_constant_init (init);
13181 if (processing_template_decl
13182 ? potential_constant_expression (init)
13183 : reduced_constant_expression_p (init))
13184 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r)
13185 = TREE_CONSTANT (r) = true;
13186 DECL_INITIAL (r) = init;
13188 gcc_assert (cp_unevaluated_operand || TREE_STATIC (r)
13189 || decl_constant_var_p (r)
13190 || errorcount || sorrycount);
13191 if (!processing_template_decl)
13193 if (TREE_STATIC (r))
13194 rest_of_decl_compilation (r, toplevel_bindings_p (),
13197 r = process_outer_var_ref (r, complain);
13200 /* Remember this for subsequent uses. */
13201 if (local_specializations)
13202 register_local_specialization (r, t);
13207 if (!mark_used (r, complain) && !(complain & tf_error))
13208 return error_mark_node;
13211 case NAMESPACE_DECL:
13215 /* An OVERLOAD will always be a non-dependent overload set; an
13216 overload set from function scope will just be represented with an
13217 IDENTIFIER_NODE, and from class scope with a BASELINK. */
13218 gcc_assert (!uses_template_parms (t));
13222 return tsubst_baselink (t, current_nonlambda_class_type (),
13223 args, complain, in_decl);
13225 case TEMPLATE_DECL:
13226 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
13227 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
13228 args, complain, in_decl);
13229 else if (DECL_FUNCTION_TEMPLATE_P (t) && DECL_MEMBER_TEMPLATE_P (t))
13230 return tsubst (t, args, complain, in_decl);
13231 else if (DECL_CLASS_SCOPE_P (t)
13232 && uses_template_parms (DECL_CONTEXT (t)))
13234 /* Template template argument like the following example need
13237 template <template <class> class TT> struct C {};
13238 template <class T> struct D {
13239 template <class U> struct E {};
13244 We are processing the template argument `E' in #1 for
13245 the template instantiation #2. Originally, `E' is a
13246 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
13247 have to substitute this with one having context `D<int>'. */
13249 tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
13250 return lookup_field (context, DECL_NAME(t), 0, false);
13253 /* Ordinary template template argument. */
13257 case REINTERPRET_CAST_EXPR:
13258 case CONST_CAST_EXPR:
13259 case STATIC_CAST_EXPR:
13260 case DYNAMIC_CAST_EXPR:
13261 case IMPLICIT_CONV_EXPR:
13265 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
13266 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
13267 return build1 (code, type, op0);
13271 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
13273 tree expanded, op = TREE_OPERAND (t, 0);
13276 if (SIZEOF_EXPR_TYPE_P (t))
13277 op = TREE_TYPE (op);
13279 ++cp_unevaluated_operand;
13280 ++c_inhibit_evaluation_warnings;
13281 /* We only want to compute the number of arguments. */
13282 expanded = tsubst_pack_expansion (op, args, complain, in_decl);
13283 --cp_unevaluated_operand;
13284 --c_inhibit_evaluation_warnings;
13286 if (TREE_CODE (expanded) == TREE_VEC)
13288 len = TREE_VEC_LENGTH (expanded);
13289 /* Set TREE_USED for the benefit of -Wunused. */
13290 for (int i = 0; i < len; i++)
13291 if (DECL_P (TREE_VEC_ELT (expanded, i)))
13292 TREE_USED (TREE_VEC_ELT (expanded, i)) = true;
13295 if (expanded == error_mark_node)
13296 return error_mark_node;
13297 else if (PACK_EXPANSION_P (expanded)
13298 || (TREE_CODE (expanded) == TREE_VEC
13300 && PACK_EXPANSION_P (TREE_VEC_ELT (expanded, len-1))))
13302 if (TREE_CODE (expanded) == TREE_VEC)
13303 expanded = TREE_VEC_ELT (expanded, len - 1);
13305 PACK_EXPANSION_SIZEOF_P (expanded) = true;
13307 if (TYPE_P (expanded))
13308 return cxx_sizeof_or_alignof_type (expanded, SIZEOF_EXPR,
13309 complain & tf_error);
13311 return cxx_sizeof_or_alignof_expr (expanded, SIZEOF_EXPR,
13312 complain & tf_error);
13315 return build_int_cst (size_type_node, len);
13317 if (SIZEOF_EXPR_TYPE_P (t))
13319 r = tsubst (TREE_TYPE (TREE_OPERAND (t, 0)),
13320 args, complain, in_decl);
13321 r = build1 (NOP_EXPR, r, error_mark_node);
13322 r = build1 (SIZEOF_EXPR,
13323 tsubst (TREE_TYPE (t), args, complain, in_decl), r);
13324 SIZEOF_EXPR_TYPE_P (r) = 1;
13331 case TRUTH_NOT_EXPR:
13334 case UNARY_PLUS_EXPR: /* Unary + */
13336 case AT_ENCODE_EXPR:
13340 case REALPART_EXPR:
13341 case IMAGPART_EXPR:
13344 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
13345 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
13346 return build1 (code, type, op0);
13349 case COMPONENT_REF:
13354 object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
13355 name = TREE_OPERAND (t, 1);
13356 if (TREE_CODE (name) == BIT_NOT_EXPR)
13358 name = tsubst_copy (TREE_OPERAND (name, 0), args,
13359 complain, in_decl);
13360 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
13362 else if (TREE_CODE (name) == SCOPE_REF
13363 && TREE_CODE (TREE_OPERAND (name, 1)) == BIT_NOT_EXPR)
13365 tree base = tsubst_copy (TREE_OPERAND (name, 0), args,
13366 complain, in_decl);
13367 name = TREE_OPERAND (name, 1);
13368 name = tsubst_copy (TREE_OPERAND (name, 0), args,
13369 complain, in_decl);
13370 name = build1 (BIT_NOT_EXPR, NULL_TREE, name);
13371 name = build_qualified_name (/*type=*/NULL_TREE,
13373 /*template_p=*/false);
13375 else if (BASELINK_P (name))
13376 name = tsubst_baselink (name,
13377 non_reference (TREE_TYPE (object)),
13381 name = tsubst_copy (name, args, complain, in_decl);
13382 return build_nt (COMPONENT_REF, object, name, NULL_TREE);
13388 case TRUNC_DIV_EXPR:
13389 case CEIL_DIV_EXPR:
13390 case FLOOR_DIV_EXPR:
13391 case ROUND_DIV_EXPR:
13392 case EXACT_DIV_EXPR:
13396 case TRUNC_MOD_EXPR:
13397 case FLOOR_MOD_EXPR:
13398 case TRUTH_ANDIF_EXPR:
13399 case TRUTH_ORIF_EXPR:
13400 case TRUTH_AND_EXPR:
13401 case TRUTH_OR_EXPR:
13414 case COMPOUND_EXPR:
13417 case PREDECREMENT_EXPR:
13418 case PREINCREMENT_EXPR:
13419 case POSTDECREMENT_EXPR:
13420 case POSTINCREMENT_EXPR:
13422 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
13423 tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
13424 return build_nt (code, op0, op1);
13429 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
13430 tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
13431 return build_qualified_name (/*type=*/NULL_TREE, op0, op1,
13432 QUALIFIED_NAME_IS_TEMPLATE (t));
13437 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
13438 tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
13439 return build_nt (ARRAY_REF, op0, op1, NULL_TREE, NULL_TREE);
13444 int n = VL_EXP_OPERAND_LENGTH (t);
13445 tree result = build_vl_exp (CALL_EXPR, n);
13447 for (i = 0; i < n; i++)
13448 TREE_OPERAND (t, i) = tsubst_copy (TREE_OPERAND (t, i), args,
13449 complain, in_decl);
13455 case PSEUDO_DTOR_EXPR:
13456 case VEC_PERM_EXPR:
13458 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
13459 tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
13460 tree op2 = tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl);
13461 r = build_nt (code, op0, op1, op2);
13462 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
13468 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
13469 tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
13470 tree op2 = tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl);
13471 r = build_nt (code, op0, op1, op2);
13472 NEW_EXPR_USE_GLOBAL (r) = NEW_EXPR_USE_GLOBAL (t);
13478 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
13479 tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
13480 r = build_nt (code, op0, op1);
13481 DELETE_EXPR_USE_GLOBAL (r) = DELETE_EXPR_USE_GLOBAL (t);
13482 DELETE_EXPR_USE_VEC (r) = DELETE_EXPR_USE_VEC (t);
13486 case TEMPLATE_ID_EXPR:
13488 /* Substituted template arguments */
13489 tree fn = TREE_OPERAND (t, 0);
13490 tree targs = TREE_OPERAND (t, 1);
13492 fn = tsubst_copy (fn, args, complain, in_decl);
13494 targs = tsubst_template_args (targs, args, complain, in_decl);
13496 return lookup_template_function (fn, targs);
13501 tree purpose, value, chain;
13503 if (t == void_list_node)
13506 purpose = TREE_PURPOSE (t);
13508 purpose = tsubst_copy (purpose, args, complain, in_decl);
13509 value = TREE_VALUE (t);
13511 value = tsubst_copy (value, args, complain, in_decl);
13512 chain = TREE_CHAIN (t);
13513 if (chain && chain != void_type_node)
13514 chain = tsubst_copy (chain, args, complain, in_decl);
13515 if (purpose == TREE_PURPOSE (t)
13516 && value == TREE_VALUE (t)
13517 && chain == TREE_CHAIN (t))
13519 return tree_cons (purpose, value, chain);
13524 case ENUMERAL_TYPE:
13526 case TEMPLATE_TYPE_PARM:
13527 case TEMPLATE_TEMPLATE_PARM:
13528 case BOUND_TEMPLATE_TEMPLATE_PARM:
13529 case TEMPLATE_PARM_INDEX:
13531 case REFERENCE_TYPE:
13533 case FUNCTION_TYPE:
13536 case TYPENAME_TYPE:
13537 case UNBOUND_CLASS_TEMPLATE:
13539 case DECLTYPE_TYPE:
13541 return tsubst (t, args, complain, in_decl);
13545 /* Fall through. */
13546 case IDENTIFIER_NODE:
13547 if (IDENTIFIER_TYPENAME_P (t))
13549 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
13550 return mangle_conv_op_name_for_type (new_type);
13556 /* This is handled by tsubst_copy_and_build. */
13557 gcc_unreachable ();
13561 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
13562 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
13563 return build_x_va_arg (EXPR_LOCATION (t), op0, type);
13566 case CLEANUP_POINT_EXPR:
13567 /* We shouldn't have built any of these during initial template
13568 generation. Instead, they should be built during instantiation
13569 in response to the saved STMT_IS_FULL_EXPR_P setting. */
13570 gcc_unreachable ();
13574 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
13575 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
13576 tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
13577 r = build2 (code, type, op0, op1);
13578 PTRMEM_OK_P (r) = PTRMEM_OK_P (t);
13579 if (!mark_used (TREE_OPERAND (r, 1), complain)
13580 && !(complain & tf_error))
13581 return error_mark_node;
13585 case EXPR_PACK_EXPANSION:
13586 error ("invalid use of pack expansion expression");
13587 return error_mark_node;
13589 case NONTYPE_ARGUMENT_PACK:
13590 error ("use %<...%> to expand argument pack");
13591 return error_mark_node;
13594 gcc_checking_assert (t == void_node && VOID_TYPE_P (TREE_TYPE (t)));
13602 /* Instantiate any typedefs in the type. */
13603 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
13604 r = fold_convert (type, t);
13605 gcc_assert (TREE_CODE (r) == code);
13610 /* These can sometimes show up in a partial instantiation, but never
13611 involve template parms. */
13612 gcc_assert (!uses_template_parms (t));
13616 /* We shouldn't get here, but keep going if !ENABLE_CHECKING. */
13617 gcc_checking_assert (false);
13622 /* Helper function for tsubst_omp_clauses, used for instantiation of
13623 OMP_CLAUSE_DECL of clauses that handles also OpenMP array sections
13624 represented with TREE_LIST. */
13627 tsubst_omp_clause_decl (tree decl, tree args, tsubst_flags_t complain,
13630 if (TREE_CODE (decl) == TREE_LIST)
13633 = tsubst_expr (TREE_PURPOSE (decl), args, complain, in_decl,
13634 /*integral_constant_expression_p=*/false);
13635 tree length = tsubst_expr (TREE_VALUE (decl), args, complain, in_decl,
13636 /*integral_constant_expression_p=*/false);
13637 tree chain = tsubst_omp_clause_decl (TREE_CHAIN (decl), args, complain,
13639 if (TREE_PURPOSE (decl) == low_bound
13640 && TREE_VALUE (decl) == length
13641 && TREE_CHAIN (decl) == chain)
13643 return tree_cons (low_bound, length, chain);
13645 return tsubst_copy (decl, args, complain, in_decl);
13648 /* Like tsubst_copy, but specifically for OpenMP clauses. */
13651 tsubst_omp_clauses (tree clauses, bool declare_simd,
13652 tree args, tsubst_flags_t complain, tree in_decl)
13654 tree new_clauses = NULL, nc, oc;
13656 for (oc = clauses; oc ; oc = OMP_CLAUSE_CHAIN (oc))
13658 nc = copy_node (oc);
13659 OMP_CLAUSE_CHAIN (nc) = new_clauses;
13662 switch (OMP_CLAUSE_CODE (nc))
13664 case OMP_CLAUSE_LASTPRIVATE:
13665 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc))
13667 OMP_CLAUSE_LASTPRIVATE_STMT (nc) = push_stmt_list ();
13668 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc), args, complain,
13669 in_decl, /*integral_constant_expression_p=*/false);
13670 OMP_CLAUSE_LASTPRIVATE_STMT (nc)
13671 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc));
13674 case OMP_CLAUSE_PRIVATE:
13675 case OMP_CLAUSE_SHARED:
13676 case OMP_CLAUSE_FIRSTPRIVATE:
13677 case OMP_CLAUSE_COPYIN:
13678 case OMP_CLAUSE_COPYPRIVATE:
13679 case OMP_CLAUSE_UNIFORM:
13680 OMP_CLAUSE_DECL (nc) = tsubst_copy (OMP_CLAUSE_DECL (oc), args,
13681 complain, in_decl);
13683 case OMP_CLAUSE_DEPEND:
13684 case OMP_CLAUSE_FROM:
13685 case OMP_CLAUSE_TO:
13686 case OMP_CLAUSE_MAP:
13687 OMP_CLAUSE_DECL (nc)
13688 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc), args, complain,
13691 case OMP_CLAUSE_IF:
13692 case OMP_CLAUSE_NUM_THREADS:
13693 case OMP_CLAUSE_SCHEDULE:
13694 case OMP_CLAUSE_COLLAPSE:
13695 case OMP_CLAUSE_FINAL:
13696 case OMP_CLAUSE_DEVICE:
13697 case OMP_CLAUSE_DIST_SCHEDULE:
13698 case OMP_CLAUSE_NUM_TEAMS:
13699 case OMP_CLAUSE_THREAD_LIMIT:
13700 case OMP_CLAUSE_SAFELEN:
13701 case OMP_CLAUSE_SIMDLEN:
13702 OMP_CLAUSE_OPERAND (nc, 0)
13703 = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 0), args, complain,
13704 in_decl, /*integral_constant_expression_p=*/false);
13706 case OMP_CLAUSE_REDUCTION:
13707 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc))
13709 tree placeholder = OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc);
13710 if (TREE_CODE (placeholder) == SCOPE_REF)
13712 tree scope = tsubst (TREE_OPERAND (placeholder, 0), args,
13713 complain, in_decl);
13714 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc)
13715 = build_qualified_name (NULL_TREE, scope,
13716 TREE_OPERAND (placeholder, 1),
13720 gcc_assert (identifier_p (placeholder));
13722 OMP_CLAUSE_DECL (nc) = tsubst_copy (OMP_CLAUSE_DECL (oc), args,
13723 complain, in_decl);
13725 case OMP_CLAUSE_LINEAR:
13726 case OMP_CLAUSE_ALIGNED:
13727 OMP_CLAUSE_DECL (nc) = tsubst_copy (OMP_CLAUSE_DECL (oc), args,
13728 complain, in_decl);
13729 OMP_CLAUSE_OPERAND (nc, 1)
13730 = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 1), args, complain,
13731 in_decl, /*integral_constant_expression_p=*/false);
13733 case OMP_CLAUSE_NOWAIT:
13734 case OMP_CLAUSE_ORDERED:
13735 case OMP_CLAUSE_DEFAULT:
13736 case OMP_CLAUSE_UNTIED:
13737 case OMP_CLAUSE_MERGEABLE:
13738 case OMP_CLAUSE_INBRANCH:
13739 case OMP_CLAUSE_NOTINBRANCH:
13740 case OMP_CLAUSE_PROC_BIND:
13741 case OMP_CLAUSE_FOR:
13742 case OMP_CLAUSE_PARALLEL:
13743 case OMP_CLAUSE_SECTIONS:
13744 case OMP_CLAUSE_TASKGROUP:
13747 gcc_unreachable ();
13751 new_clauses = nreverse (new_clauses);
13753 new_clauses = finish_omp_clauses (new_clauses);
13754 return new_clauses;
13757 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
13760 tsubst_copy_asm_operands (tree t, tree args, tsubst_flags_t complain,
13763 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
13765 tree purpose, value, chain;
13770 if (TREE_CODE (t) != TREE_LIST)
13771 return tsubst_copy_and_build (t, args, complain, in_decl,
13772 /*function_p=*/false,
13773 /*integral_constant_expression_p=*/false);
13775 if (t == void_list_node)
13778 purpose = TREE_PURPOSE (t);
13780 purpose = RECUR (purpose);
13781 value = TREE_VALUE (t);
13784 if (TREE_CODE (value) != LABEL_DECL)
13785 value = RECUR (value);
13788 value = lookup_label (DECL_NAME (value));
13789 gcc_assert (TREE_CODE (value) == LABEL_DECL);
13790 TREE_USED (value) = 1;
13793 chain = TREE_CHAIN (t);
13794 if (chain && chain != void_type_node)
13795 chain = RECUR (chain);
13796 return tree_cons (purpose, value, chain);
13800 /* Substitute one OMP_FOR iterator. */
13803 tsubst_omp_for_iterator (tree t, int i, tree declv, tree initv,
13804 tree condv, tree incrv, tree *clauses,
13805 tree args, tsubst_flags_t complain, tree in_decl,
13806 bool integral_constant_expression_p)
13808 #define RECUR(NODE) \
13809 tsubst_expr ((NODE), args, complain, in_decl, \
13810 integral_constant_expression_p)
13811 tree decl, init, cond, incr;
13813 init = TREE_VEC_ELT (OMP_FOR_INIT (t), i);
13814 gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
13815 decl = TREE_OPERAND (init, 0);
13816 init = TREE_OPERAND (init, 1);
13817 tree decl_expr = NULL_TREE;
13818 if (init && TREE_CODE (init) == DECL_EXPR)
13820 /* We need to jump through some hoops to handle declarations in the
13821 for-init-statement, since we might need to handle auto deduction,
13822 but we need to keep control of initialization. */
13824 init = DECL_INITIAL (DECL_EXPR_DECL (init));
13825 decl = tsubst_decl (decl, args, complain);
13828 decl = RECUR (decl);
13829 init = RECUR (init);
13831 tree auto_node = type_uses_auto (TREE_TYPE (decl));
13832 if (auto_node && init)
13834 = do_auto_deduction (TREE_TYPE (decl), init, auto_node);
13836 gcc_assert (!type_dependent_expression_p (decl));
13838 if (!CLASS_TYPE_P (TREE_TYPE (decl)))
13842 /* Declare the variable, but don't let that initialize it. */
13843 tree init_sav = DECL_INITIAL (DECL_EXPR_DECL (decl_expr));
13844 DECL_INITIAL (DECL_EXPR_DECL (decl_expr)) = NULL_TREE;
13846 DECL_INITIAL (DECL_EXPR_DECL (decl_expr)) = init_sav;
13849 cond = RECUR (TREE_VEC_ELT (OMP_FOR_COND (t), i));
13850 incr = TREE_VEC_ELT (OMP_FOR_INCR (t), i);
13851 if (TREE_CODE (incr) == MODIFY_EXPR)
13853 tree lhs = RECUR (TREE_OPERAND (incr, 0));
13854 tree rhs = RECUR (TREE_OPERAND (incr, 1));
13855 incr = build_x_modify_expr (EXPR_LOCATION (incr), lhs,
13856 NOP_EXPR, rhs, complain);
13859 incr = RECUR (incr);
13860 TREE_VEC_ELT (declv, i) = decl;
13861 TREE_VEC_ELT (initv, i) = init;
13862 TREE_VEC_ELT (condv, i) = cond;
13863 TREE_VEC_ELT (incrv, i) = incr;
13869 /* Declare and initialize the variable. */
13876 for (c = *clauses; c ; c = OMP_CLAUSE_CHAIN (c))
13878 if ((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_PRIVATE
13879 || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE)
13880 && OMP_CLAUSE_DECL (c) == decl)
13882 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
13883 && OMP_CLAUSE_DECL (c) == decl)
13884 error ("iteration variable %qD should not be firstprivate", decl);
13885 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
13886 && OMP_CLAUSE_DECL (c) == decl)
13887 error ("iteration variable %qD should not be reduction", decl);
13891 c = build_omp_clause (input_location, OMP_CLAUSE_PRIVATE);
13892 OMP_CLAUSE_DECL (c) = decl;
13893 c = finish_omp_clauses (c);
13896 OMP_CLAUSE_CHAIN (c) = *clauses;
13901 cond = TREE_VEC_ELT (OMP_FOR_COND (t), i);
13902 if (COMPARISON_CLASS_P (cond))
13904 tree op0 = RECUR (TREE_OPERAND (cond, 0));
13905 tree op1 = RECUR (TREE_OPERAND (cond, 1));
13906 cond = build2 (TREE_CODE (cond), boolean_type_node, op0, op1);
13909 cond = RECUR (cond);
13910 incr = TREE_VEC_ELT (OMP_FOR_INCR (t), i);
13911 switch (TREE_CODE (incr))
13913 case PREINCREMENT_EXPR:
13914 case PREDECREMENT_EXPR:
13915 case POSTINCREMENT_EXPR:
13916 case POSTDECREMENT_EXPR:
13917 incr = build2 (TREE_CODE (incr), TREE_TYPE (decl),
13918 RECUR (TREE_OPERAND (incr, 0)), NULL_TREE);
13921 if (TREE_CODE (TREE_OPERAND (incr, 1)) == PLUS_EXPR
13922 || TREE_CODE (TREE_OPERAND (incr, 1)) == MINUS_EXPR)
13924 tree rhs = TREE_OPERAND (incr, 1);
13925 tree lhs = RECUR (TREE_OPERAND (incr, 0));
13926 tree rhs0 = RECUR (TREE_OPERAND (rhs, 0));
13927 tree rhs1 = RECUR (TREE_OPERAND (rhs, 1));
13928 incr = build2 (MODIFY_EXPR, TREE_TYPE (decl), lhs,
13929 build2 (TREE_CODE (rhs), TREE_TYPE (decl),
13933 incr = RECUR (incr);
13936 if (TREE_CODE (TREE_OPERAND (incr, 1)) == PLUS_EXPR
13937 || TREE_CODE (TREE_OPERAND (incr, 1)) == MINUS_EXPR)
13939 tree lhs = RECUR (TREE_OPERAND (incr, 0));
13940 incr = build2 (MODIFY_EXPR, TREE_TYPE (decl), lhs,
13941 build2 (TREE_CODE (TREE_OPERAND (incr, 1)),
13942 TREE_TYPE (decl), lhs,
13943 RECUR (TREE_OPERAND (incr, 2))));
13945 else if (TREE_CODE (TREE_OPERAND (incr, 1)) == NOP_EXPR
13946 && (TREE_CODE (TREE_OPERAND (incr, 2)) == PLUS_EXPR
13947 || (TREE_CODE (TREE_OPERAND (incr, 2)) == MINUS_EXPR)))
13949 tree rhs = TREE_OPERAND (incr, 2);
13950 tree lhs = RECUR (TREE_OPERAND (incr, 0));
13951 tree rhs0 = RECUR (TREE_OPERAND (rhs, 0));
13952 tree rhs1 = RECUR (TREE_OPERAND (rhs, 1));
13953 incr = build2 (MODIFY_EXPR, TREE_TYPE (decl), lhs,
13954 build2 (TREE_CODE (rhs), TREE_TYPE (decl),
13958 incr = RECUR (incr);
13961 incr = RECUR (incr);
13965 TREE_VEC_ELT (declv, i) = decl;
13966 TREE_VEC_ELT (initv, i) = init;
13967 TREE_VEC_ELT (condv, i) = cond;
13968 TREE_VEC_ELT (incrv, i) = incr;
13972 /* Like tsubst_copy for expressions, etc. but also does semantic
13976 tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl,
13977 bool integral_constant_expression_p)
13979 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
13980 #define RECUR(NODE) \
13981 tsubst_expr ((NODE), args, complain, in_decl, \
13982 integral_constant_expression_p)
13988 if (t == NULL_TREE || t == error_mark_node)
13991 loc = input_location;
13992 if (EXPR_HAS_LOCATION (t))
13993 input_location = EXPR_LOCATION (t);
13994 if (STATEMENT_CODE_P (TREE_CODE (t)))
13995 current_stmt_tree ()->stmts_are_full_exprs_p = STMT_IS_FULL_EXPR_P (t);
13997 switch (TREE_CODE (t))
13999 case STATEMENT_LIST:
14001 tree_stmt_iterator i;
14002 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
14003 RECUR (tsi_stmt (i));
14007 case CTOR_INITIALIZER:
14008 finish_mem_initializers (tsubst_initializer_list
14009 (TREE_OPERAND (t, 0), args));
14013 finish_return_stmt (RECUR (TREE_OPERAND (t, 0)));
14017 tmp = RECUR (EXPR_STMT_EXPR (t));
14018 if (EXPR_STMT_STMT_EXPR_RESULT (t))
14019 finish_stmt_expr_expr (tmp, cur_stmt_expr);
14021 finish_expr_stmt (tmp);
14025 do_using_directive (USING_STMT_NAMESPACE (t));
14030 tree decl, pattern_decl;
14033 pattern_decl = decl = DECL_EXPR_DECL (t);
14034 if (TREE_CODE (decl) == LABEL_DECL)
14035 finish_label_decl (DECL_NAME (decl));
14036 else if (TREE_CODE (decl) == USING_DECL)
14038 tree scope = USING_DECL_SCOPE (decl);
14039 tree name = DECL_NAME (decl);
14042 scope = tsubst (scope, args, complain, in_decl);
14043 decl = lookup_qualified_name (scope, name,
14044 /*is_type_p=*/false,
14045 /*complain=*/false);
14046 if (decl == error_mark_node || TREE_CODE (decl) == TREE_LIST)
14047 qualified_name_lookup_error (scope, name, decl, input_location);
14049 do_local_using_decl (decl, scope, name);
14051 else if (DECL_PACK_P (decl))
14053 /* Don't build up decls for a variadic capture proxy, we'll
14054 instantiate the elements directly as needed. */
14059 init = DECL_INITIAL (decl);
14060 decl = tsubst (decl, args, complain, in_decl);
14061 if (decl != error_mark_node)
14063 /* By marking the declaration as instantiated, we avoid
14064 trying to instantiate it. Since instantiate_decl can't
14065 handle local variables, and since we've already done
14066 all that needs to be done, that's the right thing to
14069 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
14071 && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
14072 /* Anonymous aggregates are a special case. */
14073 finish_anon_union (decl);
14074 else if (is_capture_proxy (DECL_EXPR_DECL (t)))
14076 DECL_CONTEXT (decl) = current_function_decl;
14077 if (DECL_NAME (decl) == this_identifier)
14079 tree lam = DECL_CONTEXT (current_function_decl);
14080 lam = CLASSTYPE_LAMBDA_EXPR (lam);
14081 LAMBDA_EXPR_THIS_CAPTURE (lam) = decl;
14083 insert_capture_proxy (decl);
14085 else if (DECL_IMPLICIT_TYPEDEF_P (t))
14086 /* We already did a pushtag. */;
14087 else if (TREE_CODE (decl) == FUNCTION_DECL
14088 && DECL_OMP_DECLARE_REDUCTION_P (decl)
14089 && DECL_FUNCTION_SCOPE_P (pattern_decl))
14091 DECL_CONTEXT (decl) = NULL_TREE;
14093 DECL_CONTEXT (decl) = current_function_decl;
14094 cp_check_omp_declare_reduction (decl);
14098 int const_init = false;
14099 maybe_push_decl (decl);
14101 && DECL_PRETTY_FUNCTION_P (decl))
14103 /* For __PRETTY_FUNCTION__ we have to adjust the
14105 const char *const name
14106 = cxx_printable_name (current_function_decl, 2);
14107 init = cp_fname_init (name, &TREE_TYPE (decl));
14110 init = tsubst_init (init, decl, args, complain, in_decl);
14113 const_init = (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
14115 cp_finish_decl (decl, init, const_init, NULL_TREE, 0);
14124 stmt = begin_for_stmt (NULL_TREE, NULL_TREE);
14125 RECUR (FOR_INIT_STMT (t));
14126 finish_for_init_stmt (stmt);
14127 tmp = RECUR (FOR_COND (t));
14128 finish_for_cond (tmp, stmt, false);
14129 tmp = RECUR (FOR_EXPR (t));
14130 finish_for_expr (tmp, stmt);
14131 RECUR (FOR_BODY (t));
14132 finish_for_stmt (stmt);
14135 case RANGE_FOR_STMT:
14138 stmt = begin_for_stmt (NULL_TREE, NULL_TREE);
14139 decl = RANGE_FOR_DECL (t);
14140 decl = tsubst (decl, args, complain, in_decl);
14141 maybe_push_decl (decl);
14142 expr = RECUR (RANGE_FOR_EXPR (t));
14143 stmt = cp_convert_range_for (stmt, decl, expr, RANGE_FOR_IVDEP (t));
14144 RECUR (RANGE_FOR_BODY (t));
14145 finish_for_stmt (stmt);
14150 stmt = begin_while_stmt ();
14151 tmp = RECUR (WHILE_COND (t));
14152 finish_while_stmt_cond (tmp, stmt, false);
14153 RECUR (WHILE_BODY (t));
14154 finish_while_stmt (stmt);
14158 stmt = begin_do_stmt ();
14159 RECUR (DO_BODY (t));
14160 finish_do_body (stmt);
14161 tmp = RECUR (DO_COND (t));
14162 finish_do_stmt (tmp, stmt, false);
14166 stmt = begin_if_stmt ();
14167 tmp = RECUR (IF_COND (t));
14168 finish_if_stmt_cond (tmp, stmt);
14169 RECUR (THEN_CLAUSE (t));
14170 finish_then_clause (stmt);
14172 if (ELSE_CLAUSE (t))
14174 begin_else_clause (stmt);
14175 RECUR (ELSE_CLAUSE (t));
14176 finish_else_clause (stmt);
14179 finish_if_stmt (stmt);
14183 if (BIND_EXPR_BODY_BLOCK (t))
14184 stmt = begin_function_body ();
14186 stmt = begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t)
14187 ? BCS_TRY_BLOCK : 0);
14189 RECUR (BIND_EXPR_BODY (t));
14191 if (BIND_EXPR_BODY_BLOCK (t))
14192 finish_function_body (stmt);
14194 finish_compound_stmt (stmt);
14198 finish_break_stmt ();
14201 case CONTINUE_STMT:
14202 finish_continue_stmt ();
14206 stmt = begin_switch_stmt ();
14207 tmp = RECUR (SWITCH_STMT_COND (t));
14208 finish_switch_cond (tmp, stmt);
14209 RECUR (SWITCH_STMT_BODY (t));
14210 finish_switch_stmt (stmt);
14213 case CASE_LABEL_EXPR:
14215 tree low = RECUR (CASE_LOW (t));
14216 tree high = RECUR (CASE_HIGH (t));
14217 finish_case_label (EXPR_LOCATION (t), low, high);
14223 tree decl = LABEL_EXPR_LABEL (t);
14226 label = finish_label_stmt (DECL_NAME (decl));
14227 if (DECL_ATTRIBUTES (decl) != NULL_TREE)
14228 cplus_decl_attributes (&label, DECL_ATTRIBUTES (decl), 0);
14233 tmp = GOTO_DESTINATION (t);
14234 if (TREE_CODE (tmp) != LABEL_DECL)
14235 /* Computed goto's must be tsubst'd into. On the other hand,
14236 non-computed gotos must not be; the identifier in question
14237 will have no binding. */
14240 tmp = DECL_NAME (tmp);
14241 finish_goto_stmt (tmp);
14246 tree string = RECUR (ASM_STRING (t));
14247 tree outputs = tsubst_copy_asm_operands (ASM_OUTPUTS (t), args,
14248 complain, in_decl);
14249 tree inputs = tsubst_copy_asm_operands (ASM_INPUTS (t), args,
14250 complain, in_decl);
14251 tree clobbers = tsubst_copy_asm_operands (ASM_CLOBBERS (t), args,
14252 complain, in_decl);
14253 tree labels = tsubst_copy_asm_operands (ASM_LABELS (t), args,
14254 complain, in_decl);
14255 tmp = finish_asm_stmt (ASM_VOLATILE_P (t), string, outputs, inputs,
14257 tree asm_expr = tmp;
14258 if (TREE_CODE (asm_expr) == CLEANUP_POINT_EXPR)
14259 asm_expr = TREE_OPERAND (asm_expr, 0);
14260 ASM_INPUT_P (asm_expr) = ASM_INPUT_P (t);
14267 stmt = begin_try_block ();
14268 RECUR (TRY_STMTS (t));
14269 finish_cleanup_try_block (stmt);
14270 finish_cleanup (RECUR (TRY_HANDLERS (t)), stmt);
14274 tree compound_stmt = NULL_TREE;
14276 if (FN_TRY_BLOCK_P (t))
14277 stmt = begin_function_try_block (&compound_stmt);
14279 stmt = begin_try_block ();
14281 RECUR (TRY_STMTS (t));
14283 if (FN_TRY_BLOCK_P (t))
14284 finish_function_try_block (stmt);
14286 finish_try_block (stmt);
14288 RECUR (TRY_HANDLERS (t));
14289 if (FN_TRY_BLOCK_P (t))
14290 finish_function_handler_sequence (stmt, compound_stmt);
14292 finish_handler_sequence (stmt);
14298 tree decl = HANDLER_PARMS (t);
14302 decl = tsubst (decl, args, complain, in_decl);
14303 /* Prevent instantiate_decl from trying to instantiate
14304 this variable. We've already done all that needs to be
14306 if (decl != error_mark_node)
14307 DECL_TEMPLATE_INSTANTIATED (decl) = 1;
14309 stmt = begin_handler ();
14310 finish_handler_parms (decl, stmt);
14311 RECUR (HANDLER_BODY (t));
14312 finish_handler (stmt);
14317 tmp = tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
14318 if (CLASS_TYPE_P (tmp))
14320 /* Local classes are not independent templates; they are
14321 instantiated along with their containing function. And this
14322 way we don't have to deal with pushing out of one local class
14323 to instantiate a member of another local class. */
14325 /* Closures are handled by the LAMBDA_EXPR. */
14326 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t)));
14327 complete_type (tmp);
14328 for (fn = TYPE_METHODS (tmp); fn; fn = DECL_CHAIN (fn))
14329 if (!DECL_ARTIFICIAL (fn))
14330 instantiate_decl (fn, /*defer_ok*/0, /*expl_inst_class*/false);
14334 case STATIC_ASSERT:
14338 ++c_inhibit_evaluation_warnings;
14340 tsubst_expr (STATIC_ASSERT_CONDITION (t),
14343 /*integral_constant_expression_p=*/true);
14344 --c_inhibit_evaluation_warnings;
14346 finish_static_assert (condition,
14347 STATIC_ASSERT_MESSAGE (t),
14348 STATIC_ASSERT_SOURCE_LOCATION (t),
14349 /*member_p=*/false);
14354 tmp = tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t), false,
14355 args, complain, in_decl);
14356 stmt = begin_omp_parallel ();
14357 RECUR (OMP_PARALLEL_BODY (t));
14358 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp, stmt))
14359 = OMP_PARALLEL_COMBINED (t);
14363 tmp = tsubst_omp_clauses (OMP_TASK_CLAUSES (t), false,
14364 args, complain, in_decl);
14365 stmt = begin_omp_task ();
14366 RECUR (OMP_TASK_BODY (t));
14367 finish_omp_task (tmp, stmt);
14374 case OMP_DISTRIBUTE:
14376 tree clauses, body, pre_body;
14377 tree declv = NULL_TREE, initv = NULL_TREE, condv = NULL_TREE;
14378 tree incrv = NULL_TREE;
14381 clauses = tsubst_omp_clauses (OMP_FOR_CLAUSES (t), false,
14382 args, complain, in_decl);
14383 if (OMP_FOR_INIT (t) != NULL_TREE)
14385 declv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
14386 initv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
14387 condv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
14388 incrv = make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t)));
14391 stmt = begin_omp_structured_block ();
14393 pre_body = push_stmt_list ();
14394 RECUR (OMP_FOR_PRE_BODY (t));
14395 pre_body = pop_stmt_list (pre_body);
14397 if (OMP_FOR_INIT (t) != NULL_TREE)
14398 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (t)); i++)
14399 tsubst_omp_for_iterator (t, i, declv, initv, condv, incrv,
14400 &clauses, args, complain, in_decl,
14401 integral_constant_expression_p);
14403 body = push_stmt_list ();
14404 RECUR (OMP_FOR_BODY (t));
14405 body = pop_stmt_list (body);
14407 if (OMP_FOR_INIT (t) != NULL_TREE)
14408 t = finish_omp_for (EXPR_LOCATION (t), TREE_CODE (t), declv, initv,
14409 condv, incrv, body, pre_body, clauses);
14412 t = make_node (TREE_CODE (t));
14413 TREE_TYPE (t) = void_type_node;
14414 OMP_FOR_BODY (t) = body;
14415 OMP_FOR_PRE_BODY (t) = pre_body;
14416 OMP_FOR_CLAUSES (t) = clauses;
14417 SET_EXPR_LOCATION (t, EXPR_LOCATION (t));
14421 add_stmt (finish_omp_structured_block (stmt));
14428 tmp = tsubst_omp_clauses (OMP_CLAUSES (t), false,
14429 args, complain, in_decl);
14430 stmt = push_stmt_list ();
14431 RECUR (OMP_BODY (t));
14432 stmt = pop_stmt_list (stmt);
14435 OMP_BODY (t) = stmt;
14436 OMP_CLAUSES (t) = tmp;
14440 case OMP_TARGET_DATA:
14442 tmp = tsubst_omp_clauses (OMP_CLAUSES (t), false,
14443 args, complain, in_decl);
14444 keep_next_level (true);
14445 stmt = begin_omp_structured_block ();
14447 RECUR (OMP_BODY (t));
14448 stmt = finish_omp_structured_block (stmt);
14451 OMP_BODY (t) = stmt;
14452 OMP_CLAUSES (t) = tmp;
14456 case OMP_TARGET_UPDATE:
14457 tmp = tsubst_omp_clauses (OMP_TARGET_UPDATE_CLAUSES (t), false,
14458 args, complain, in_decl);
14460 OMP_TARGET_UPDATE_CLAUSES (t) = tmp;
14467 case OMP_TASKGROUP:
14469 stmt = push_stmt_list ();
14470 RECUR (OMP_BODY (t));
14471 stmt = pop_stmt_list (stmt);
14474 OMP_BODY (t) = stmt;
14479 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t));
14480 if (TREE_CODE (TREE_OPERAND (t, 1)) != MODIFY_EXPR)
14482 tree op1 = TREE_OPERAND (t, 1);
14483 tree rhs1 = NULL_TREE;
14485 if (TREE_CODE (op1) == COMPOUND_EXPR)
14487 rhs1 = RECUR (TREE_OPERAND (op1, 0));
14488 op1 = TREE_OPERAND (op1, 1);
14490 lhs = RECUR (TREE_OPERAND (op1, 0));
14491 rhs = RECUR (TREE_OPERAND (op1, 1));
14492 finish_omp_atomic (OMP_ATOMIC, TREE_CODE (op1), lhs, rhs,
14493 NULL_TREE, NULL_TREE, rhs1,
14494 OMP_ATOMIC_SEQ_CST (t));
14498 tree op1 = TREE_OPERAND (t, 1);
14499 tree v = NULL_TREE, lhs, rhs = NULL_TREE, lhs1 = NULL_TREE;
14500 tree rhs1 = NULL_TREE;
14501 enum tree_code code = TREE_CODE (TREE_OPERAND (op1, 1));
14502 enum tree_code opcode = NOP_EXPR;
14503 if (code == OMP_ATOMIC_READ)
14505 v = RECUR (TREE_OPERAND (op1, 0));
14506 lhs = RECUR (TREE_OPERAND (TREE_OPERAND (op1, 1), 0));
14508 else if (code == OMP_ATOMIC_CAPTURE_OLD
14509 || code == OMP_ATOMIC_CAPTURE_NEW)
14511 tree op11 = TREE_OPERAND (TREE_OPERAND (op1, 1), 1);
14512 v = RECUR (TREE_OPERAND (op1, 0));
14513 lhs1 = RECUR (TREE_OPERAND (TREE_OPERAND (op1, 1), 0));
14514 if (TREE_CODE (op11) == COMPOUND_EXPR)
14516 rhs1 = RECUR (TREE_OPERAND (op11, 0));
14517 op11 = TREE_OPERAND (op11, 1);
14519 lhs = RECUR (TREE_OPERAND (op11, 0));
14520 rhs = RECUR (TREE_OPERAND (op11, 1));
14521 opcode = TREE_CODE (op11);
14522 if (opcode == MODIFY_EXPR)
14528 lhs = RECUR (TREE_OPERAND (op1, 0));
14529 rhs = RECUR (TREE_OPERAND (op1, 1));
14531 finish_omp_atomic (code, opcode, lhs, rhs, v, lhs1, rhs1,
14532 OMP_ATOMIC_SEQ_CST (t));
14536 case TRANSACTION_EXPR:
14539 flags |= (TRANSACTION_EXPR_OUTER (t) ? TM_STMT_ATTR_OUTER : 0);
14540 flags |= (TRANSACTION_EXPR_RELAXED (t) ? TM_STMT_ATTR_RELAXED : 0);
14542 if (TRANSACTION_EXPR_IS_STMT (t))
14544 tree body = TRANSACTION_EXPR_BODY (t);
14545 tree noex = NULL_TREE;
14546 if (TREE_CODE (body) == MUST_NOT_THROW_EXPR)
14548 noex = MUST_NOT_THROW_COND (body);
14549 if (noex == NULL_TREE)
14550 noex = boolean_true_node;
14551 body = TREE_OPERAND (body, 0);
14553 stmt = begin_transaction_stmt (input_location, NULL, flags);
14555 finish_transaction_stmt (stmt, NULL, flags, RECUR (noex));
14559 stmt = build_transaction_expr (EXPR_LOCATION (t),
14560 RECUR (TRANSACTION_EXPR_BODY (t)),
14567 case MUST_NOT_THROW_EXPR:
14569 tree op0 = RECUR (TREE_OPERAND (t, 0));
14570 tree cond = RECUR (MUST_NOT_THROW_COND (t));
14571 RETURN (build_must_not_throw_expr (op0, cond));
14574 case EXPR_PACK_EXPANSION:
14575 error ("invalid use of pack expansion expression");
14576 RETURN (error_mark_node);
14578 case NONTYPE_ARGUMENT_PACK:
14579 error ("use %<...%> to expand argument pack");
14580 RETURN (error_mark_node);
14582 case CILK_SPAWN_STMT:
14583 cfun->calls_cilk_spawn = 1;
14584 RETURN (build_cilk_spawn (EXPR_LOCATION (t), RECUR (CILK_SPAWN_FN (t))));
14586 case CILK_SYNC_STMT:
14587 RETURN (build_cilk_sync ());
14589 case COMPOUND_EXPR:
14590 tmp = RECUR (TREE_OPERAND (t, 0));
14591 if (tmp == NULL_TREE)
14592 /* If the first operand was a statement, we're done with it. */
14593 RETURN (RECUR (TREE_OPERAND (t, 1)));
14594 RETURN (build_x_compound_expr (EXPR_LOCATION (t), tmp,
14595 RECUR (TREE_OPERAND (t, 1)),
14598 case ANNOTATE_EXPR:
14599 tmp = RECUR (TREE_OPERAND (t, 0));
14600 RETURN (build2_loc (EXPR_LOCATION (t), ANNOTATE_EXPR,
14601 TREE_TYPE (tmp), tmp, RECUR (TREE_OPERAND (t, 1))));
14604 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t)));
14606 RETURN (tsubst_copy_and_build (t, args, complain, in_decl,
14607 /*function_p=*/false,
14608 integral_constant_expression_p));
14611 RETURN (NULL_TREE);
14613 input_location = loc;
14619 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
14620 function. For description of the body see comment above
14621 cp_parser_omp_declare_reduction_exprs. */
14624 tsubst_omp_udr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
14626 if (t == NULL_TREE || t == error_mark_node)
14629 gcc_assert (TREE_CODE (t) == STATEMENT_LIST);
14631 tree_stmt_iterator tsi;
14634 memset (stmts, 0, sizeof stmts);
14635 for (i = 0, tsi = tsi_start (t);
14636 i < 7 && !tsi_end_p (tsi);
14637 i++, tsi_next (&tsi))
14638 stmts[i] = tsi_stmt (tsi);
14639 gcc_assert (tsi_end_p (tsi));
14643 gcc_assert (TREE_CODE (stmts[0]) == DECL_EXPR
14644 && TREE_CODE (stmts[1]) == DECL_EXPR);
14645 tree omp_out = tsubst (DECL_EXPR_DECL (stmts[0]),
14646 args, complain, in_decl);
14647 tree omp_in = tsubst (DECL_EXPR_DECL (stmts[1]),
14648 args, complain, in_decl);
14649 DECL_CONTEXT (omp_out) = current_function_decl;
14650 DECL_CONTEXT (omp_in) = current_function_decl;
14651 keep_next_level (true);
14652 tree block = begin_omp_structured_block ();
14653 tsubst_expr (stmts[2], args, complain, in_decl, false);
14654 block = finish_omp_structured_block (block);
14655 block = maybe_cleanup_point_expr_void (block);
14656 add_decl_expr (omp_out);
14657 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts[0])))
14658 TREE_NO_WARNING (omp_out) = 1;
14659 add_decl_expr (omp_in);
14660 finish_expr_stmt (block);
14664 gcc_assert (TREE_CODE (stmts[3]) == DECL_EXPR
14665 && TREE_CODE (stmts[4]) == DECL_EXPR);
14666 tree omp_priv = tsubst (DECL_EXPR_DECL (stmts[3]),
14667 args, complain, in_decl);
14668 tree omp_orig = tsubst (DECL_EXPR_DECL (stmts[4]),
14669 args, complain, in_decl);
14670 DECL_CONTEXT (omp_priv) = current_function_decl;
14671 DECL_CONTEXT (omp_orig) = current_function_decl;
14672 keep_next_level (true);
14673 tree block = begin_omp_structured_block ();
14674 tsubst_expr (stmts[5], args, complain, in_decl, false);
14675 block = finish_omp_structured_block (block);
14676 block = maybe_cleanup_point_expr_void (block);
14677 cp_walk_tree (&block, cp_remove_omp_priv_cleanup_stmt, omp_priv, NULL);
14678 add_decl_expr (omp_priv);
14679 add_decl_expr (omp_orig);
14680 finish_expr_stmt (block);
14682 add_decl_expr (omp_orig);
14686 /* T is a postfix-expression that is not being used in a function
14687 call. Return the substituted version of T. */
14690 tsubst_non_call_postfix_expression (tree t, tree args,
14691 tsubst_flags_t complain,
14694 if (TREE_CODE (t) == SCOPE_REF)
14695 t = tsubst_qualified_id (t, args, complain, in_decl,
14696 /*done=*/false, /*address_p=*/false);
14698 t = tsubst_copy_and_build (t, args, complain, in_decl,
14699 /*function_p=*/false,
14700 /*integral_constant_expression_p=*/false);
14705 /* Like tsubst but deals with expressions and performs semantic
14706 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
14709 tsubst_copy_and_build (tree t,
14711 tsubst_flags_t complain,
14714 bool integral_constant_expression_p)
14716 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
14717 #define RECUR(NODE) \
14718 tsubst_copy_and_build (NODE, args, complain, in_decl, \
14719 /*function_p=*/false, \
14720 integral_constant_expression_p)
14725 if (t == NULL_TREE || t == error_mark_node)
14728 loc = input_location;
14729 if (EXPR_HAS_LOCATION (t))
14730 input_location = EXPR_LOCATION (t);
14732 /* N3276 decltype magic only applies to calls at the top level or on the
14733 right side of a comma. */
14734 tsubst_flags_t decltype_flag = (complain & tf_decltype);
14735 complain &= ~tf_decltype;
14737 switch (TREE_CODE (t))
14741 /* Fall through. */
14742 case IDENTIFIER_NODE:
14746 bool non_integral_constant_expression_p;
14747 const char *error_msg;
14749 if (IDENTIFIER_TYPENAME_P (t))
14751 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
14752 t = mangle_conv_op_name_for_type (new_type);
14755 /* Look up the name. */
14756 decl = lookup_name (t);
14758 /* By convention, expressions use ERROR_MARK_NODE to indicate
14759 failure, not NULL_TREE. */
14760 if (decl == NULL_TREE)
14761 decl = error_mark_node;
14763 decl = finish_id_expression (t, decl, NULL_TREE,
14765 integral_constant_expression_p,
14766 /*allow_non_integral_constant_expression_p=*/(cxx_dialect >= cxx11),
14767 &non_integral_constant_expression_p,
14768 /*template_p=*/false,
14770 /*address_p=*/false,
14771 /*template_arg_p=*/false,
14776 if (!function_p && identifier_p (decl))
14778 if (complain & tf_error)
14779 unqualified_name_lookup_error (decl);
14780 decl = error_mark_node;
14785 case TEMPLATE_ID_EXPR:
14788 tree templ = RECUR (TREE_OPERAND (t, 0));
14789 tree targs = TREE_OPERAND (t, 1);
14792 targs = tsubst_template_args (targs, args, complain, in_decl);
14793 if (targs == error_mark_node)
14794 return error_mark_node;
14796 if (variable_template_p (templ))
14798 templ = lookup_template_variable (templ, targs);
14799 if (!any_dependent_template_arguments_p (targs))
14801 templ = finish_template_variable (templ, complain);
14804 RETURN (convert_from_reference (templ));
14807 if (TREE_CODE (templ) == COMPONENT_REF)
14809 object = TREE_OPERAND (templ, 0);
14810 templ = TREE_OPERAND (templ, 1);
14813 object = NULL_TREE;
14814 templ = lookup_template_function (templ, targs);
14817 RETURN (build3 (COMPONENT_REF, TREE_TYPE (templ),
14818 object, templ, NULL_TREE));
14820 RETURN (baselink_for_fns (templ));
14825 tree r = RECUR (TREE_OPERAND (t, 0));
14827 if (REFERENCE_REF_P (t))
14829 /* A type conversion to reference type will be enclosed in
14830 such an indirect ref, but the substitution of the cast
14831 will have also added such an indirect ref. */
14832 if (TREE_CODE (TREE_TYPE (r)) == REFERENCE_TYPE)
14833 r = convert_from_reference (r);
14836 r = build_x_indirect_ref (input_location, r, RO_UNARY_STAR,
14837 complain|decltype_flag);
14843 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
14844 tree op0 = RECUR (TREE_OPERAND (t, 0));
14845 RETURN (build_nop (type, op0));
14848 case IMPLICIT_CONV_EXPR:
14850 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
14851 tree expr = RECUR (TREE_OPERAND (t, 0));
14852 int flags = LOOKUP_IMPLICIT;
14853 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t))
14854 flags = LOOKUP_NORMAL;
14855 RETURN (perform_implicit_conversion_flags (type, expr, complain,
14861 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
14862 tree op0 = RECUR (TREE_OPERAND (t, 0));
14863 RETURN (build1 (CONVERT_EXPR, type, op0));
14867 case REINTERPRET_CAST_EXPR:
14868 case CONST_CAST_EXPR:
14869 case DYNAMIC_CAST_EXPR:
14870 case STATIC_CAST_EXPR:
14873 tree op, r = NULL_TREE;
14875 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
14876 if (integral_constant_expression_p
14877 && !cast_valid_in_integral_constant_expression_p (type))
14879 if (complain & tf_error)
14880 error ("a cast to a type other than an integral or "
14881 "enumeration type cannot appear in a constant-expression");
14882 RETURN (error_mark_node);
14885 op = RECUR (TREE_OPERAND (t, 0));
14887 warning_sentinel s(warn_useless_cast);
14888 switch (TREE_CODE (t))
14891 r = build_functional_cast (type, op, complain);
14893 case REINTERPRET_CAST_EXPR:
14894 r = build_reinterpret_cast (type, op, complain);
14896 case CONST_CAST_EXPR:
14897 r = build_const_cast (type, op, complain);
14899 case DYNAMIC_CAST_EXPR:
14900 r = build_dynamic_cast (type, op, complain);
14902 case STATIC_CAST_EXPR:
14903 r = build_static_cast (type, op, complain);
14906 gcc_unreachable ();
14912 case POSTDECREMENT_EXPR:
14913 case POSTINCREMENT_EXPR:
14914 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
14915 args, complain, in_decl);
14916 RETURN (build_x_unary_op (input_location, TREE_CODE (t), op1,
14917 complain|decltype_flag));
14919 case PREDECREMENT_EXPR:
14920 case PREINCREMENT_EXPR:
14924 case TRUTH_NOT_EXPR:
14925 case UNARY_PLUS_EXPR: /* Unary + */
14926 case REALPART_EXPR:
14927 case IMAGPART_EXPR:
14928 RETURN (build_x_unary_op (input_location, TREE_CODE (t),
14929 RECUR (TREE_OPERAND (t, 0)),
14930 complain|decltype_flag));
14932 case FIX_TRUNC_EXPR:
14933 RETURN (cp_build_unary_op (FIX_TRUNC_EXPR, RECUR (TREE_OPERAND (t, 0)),
14937 op1 = TREE_OPERAND (t, 0);
14938 if (TREE_CODE (op1) == LABEL_DECL)
14939 RETURN (finish_label_address_expr (DECL_NAME (op1),
14940 EXPR_LOCATION (op1)));
14941 if (TREE_CODE (op1) == SCOPE_REF)
14942 op1 = tsubst_qualified_id (op1, args, complain, in_decl,
14943 /*done=*/true, /*address_p=*/true);
14945 op1 = tsubst_non_call_postfix_expression (op1, args, complain,
14947 RETURN (build_x_unary_op (input_location, ADDR_EXPR, op1,
14948 complain|decltype_flag));
14953 case TRUNC_DIV_EXPR:
14954 case CEIL_DIV_EXPR:
14955 case FLOOR_DIV_EXPR:
14956 case ROUND_DIV_EXPR:
14957 case EXACT_DIV_EXPR:
14961 case TRUNC_MOD_EXPR:
14962 case FLOOR_MOD_EXPR:
14963 case TRUTH_ANDIF_EXPR:
14964 case TRUTH_ORIF_EXPR:
14965 case TRUTH_AND_EXPR:
14966 case TRUTH_OR_EXPR:
14982 warning_sentinel s1(warn_type_limits);
14983 warning_sentinel s2(warn_div_by_zero);
14984 tree op0 = RECUR (TREE_OPERAND (t, 0));
14985 tree op1 = RECUR (TREE_OPERAND (t, 1));
14986 tree r = build_x_binary_op
14987 (input_location, TREE_CODE (t),
14989 (TREE_NO_WARNING (TREE_OPERAND (t, 0))
14991 : TREE_CODE (TREE_OPERAND (t, 0))),
14993 (TREE_NO_WARNING (TREE_OPERAND (t, 1))
14995 : TREE_CODE (TREE_OPERAND (t, 1))),
14997 complain|decltype_flag);
14998 if (EXPR_P (r) && TREE_NO_WARNING (t))
14999 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
15004 case POINTER_PLUS_EXPR:
15006 tree op0 = RECUR (TREE_OPERAND (t, 0));
15007 tree op1 = RECUR (TREE_OPERAND (t, 1));
15008 return fold_build_pointer_plus (op0, op1);
15012 RETURN (tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
15013 /*address_p=*/false));
15015 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
15016 args, complain, in_decl);
15017 RETURN (build_x_array_ref (EXPR_LOCATION (t), op1,
15018 RECUR (TREE_OPERAND (t, 1)),
15019 complain|decltype_flag));
15021 case ARRAY_NOTATION_REF:
15023 tree start_index, length, stride;
15024 op1 = tsubst_non_call_postfix_expression (ARRAY_NOTATION_ARRAY (t),
15025 args, complain, in_decl);
15026 start_index = RECUR (ARRAY_NOTATION_START (t));
15027 length = RECUR (ARRAY_NOTATION_LENGTH (t));
15028 stride = RECUR (ARRAY_NOTATION_STRIDE (t));
15029 RETURN (build_array_notation_ref (EXPR_LOCATION (t), op1, start_index,
15030 length, stride, TREE_TYPE (op1)));
15033 if (PACK_EXPANSION_P (TREE_OPERAND (t, 0)))
15034 RETURN (tsubst_copy (t, args, complain, in_decl));
15041 op1 = TREE_OPERAND (t, 0);
15042 if (TREE_CODE (t) == SIZEOF_EXPR && SIZEOF_EXPR_TYPE_P (t))
15043 op1 = TREE_TYPE (op1);
15046 /* When there are no ARGS, we are trying to evaluate a
15047 non-dependent expression from the parser. Trying to do
15048 the substitutions may not work. */
15050 op1 = TREE_TYPE (op1);
15054 ++cp_unevaluated_operand;
15055 ++c_inhibit_evaluation_warnings;
15057 op1 = tsubst (op1, args, complain, in_decl);
15059 op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
15060 /*function_p=*/false,
15061 /*integral_constant_expression_p=*/
15063 --cp_unevaluated_operand;
15064 --c_inhibit_evaluation_warnings;
15067 r = cxx_sizeof_or_alignof_type (op1, TREE_CODE (t),
15068 complain & tf_error);
15070 r = cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t),
15071 complain & tf_error);
15072 if (TREE_CODE (t) == SIZEOF_EXPR && r != error_mark_node)
15074 if (TREE_CODE (r) != SIZEOF_EXPR || TYPE_P (op1))
15076 if (!processing_template_decl && TYPE_P (op1))
15078 r = build_min (SIZEOF_EXPR, size_type_node,
15079 build1 (NOP_EXPR, op1, error_mark_node));
15080 SIZEOF_EXPR_TYPE_P (r) = 1;
15083 r = build_min (SIZEOF_EXPR, size_type_node, op1);
15084 TREE_SIDE_EFFECTS (r) = 0;
15085 TREE_READONLY (r) = 1;
15087 SET_EXPR_LOCATION (r, EXPR_LOCATION (t));
15092 case AT_ENCODE_EXPR:
15094 op1 = TREE_OPERAND (t, 0);
15095 ++cp_unevaluated_operand;
15096 ++c_inhibit_evaluation_warnings;
15097 op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
15098 /*function_p=*/false,
15099 /*integral_constant_expression_p=*/false);
15100 --cp_unevaluated_operand;
15101 --c_inhibit_evaluation_warnings;
15102 RETURN (objc_build_encode_expr (op1));
15105 case NOEXCEPT_EXPR:
15106 op1 = TREE_OPERAND (t, 0);
15107 ++cp_unevaluated_operand;
15108 ++c_inhibit_evaluation_warnings;
15109 ++cp_noexcept_operand;
15110 op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
15111 /*function_p=*/false,
15112 /*integral_constant_expression_p=*/false);
15113 --cp_unevaluated_operand;
15114 --c_inhibit_evaluation_warnings;
15115 --cp_noexcept_operand;
15116 RETURN (finish_noexcept_expr (op1, complain));
15120 warning_sentinel s(warn_div_by_zero);
15121 tree lhs = RECUR (TREE_OPERAND (t, 0));
15122 tree rhs = RECUR (TREE_OPERAND (t, 2));
15123 tree r = build_x_modify_expr
15124 (EXPR_LOCATION (t), lhs, TREE_CODE (TREE_OPERAND (t, 1)), rhs,
15125 complain|decltype_flag);
15126 /* TREE_NO_WARNING must be set if either the expression was
15127 parenthesized or it uses an operator such as >>= rather
15128 than plain assignment. In the former case, it was already
15129 set and must be copied. In the latter case,
15130 build_x_modify_expr sets it and it must not be reset
15132 if (TREE_NO_WARNING (t))
15133 TREE_NO_WARNING (r) = TREE_NO_WARNING (t);
15139 op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
15140 args, complain, in_decl);
15141 /* Remember that there was a reference to this entity. */
15143 && !mark_used (op1, complain) && !(complain & tf_error))
15144 RETURN (error_mark_node);
15145 RETURN (build_x_arrow (input_location, op1, complain));
15149 tree placement = RECUR (TREE_OPERAND (t, 0));
15150 tree init = RECUR (TREE_OPERAND (t, 3));
15151 vec<tree, va_gc> *placement_vec;
15152 vec<tree, va_gc> *init_vec;
15155 if (placement == NULL_TREE)
15156 placement_vec = NULL;
15159 placement_vec = make_tree_vector ();
15160 for (; placement != NULL_TREE; placement = TREE_CHAIN (placement))
15161 vec_safe_push (placement_vec, TREE_VALUE (placement));
15164 /* If there was an initializer in the original tree, but it
15165 instantiated to an empty list, then we should pass a
15166 non-NULL empty vector to tell build_new that it was an
15167 empty initializer() rather than no initializer. This can
15168 only happen when the initializer is a pack expansion whose
15169 parameter packs are of length zero. */
15170 if (init == NULL_TREE && TREE_OPERAND (t, 3) == NULL_TREE)
15174 init_vec = make_tree_vector ();
15175 if (init == void_node)
15176 gcc_assert (init_vec != NULL);
15179 for (; init != NULL_TREE; init = TREE_CHAIN (init))
15180 vec_safe_push (init_vec, TREE_VALUE (init));
15184 tree op1 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
15185 tree op2 = RECUR (TREE_OPERAND (t, 2));
15186 ret = build_new (&placement_vec, op1, op2, &init_vec,
15187 NEW_EXPR_USE_GLOBAL (t),
15190 if (placement_vec != NULL)
15191 release_tree_vector (placement_vec);
15192 if (init_vec != NULL)
15193 release_tree_vector (init_vec);
15200 tree op0 = RECUR (TREE_OPERAND (t, 0));
15201 tree op1 = RECUR (TREE_OPERAND (t, 1));
15202 RETURN (delete_sanity (op0, op1,
15203 DELETE_EXPR_USE_VEC (t),
15204 DELETE_EXPR_USE_GLOBAL (t),
15208 case COMPOUND_EXPR:
15210 tree op0 = tsubst_copy_and_build (TREE_OPERAND (t, 0), args,
15211 complain & ~tf_decltype, in_decl,
15212 /*function_p=*/false,
15213 integral_constant_expression_p);
15214 RETURN (build_x_compound_expr (EXPR_LOCATION (t),
15216 RECUR (TREE_OPERAND (t, 1)),
15217 complain|decltype_flag));
15223 vec<tree, va_gc> *call_args;
15224 unsigned int nargs, i;
15229 function = CALL_EXPR_FN (t);
15230 /* When we parsed the expression, we determined whether or
15231 not Koenig lookup should be performed. */
15232 koenig_p = KOENIG_LOOKUP_P (t);
15233 if (TREE_CODE (function) == SCOPE_REF)
15235 qualified_p = true;
15236 function = tsubst_qualified_id (function, args, complain, in_decl,
15238 /*address_p=*/false);
15240 else if (koenig_p && identifier_p (function))
15242 /* Do nothing; calling tsubst_copy_and_build on an identifier
15243 would incorrectly perform unqualified lookup again.
15245 Note that we can also have an IDENTIFIER_NODE if the earlier
15246 unqualified lookup found a member function; in that case
15247 koenig_p will be false and we do want to do the lookup
15248 again to find the instantiated member function.
15250 FIXME but doing that causes c++/15272, so we need to stop
15251 using IDENTIFIER_NODE in that situation. */
15252 qualified_p = false;
15256 if (TREE_CODE (function) == COMPONENT_REF)
15258 tree op = TREE_OPERAND (function, 1);
15260 qualified_p = (TREE_CODE (op) == SCOPE_REF
15261 || (BASELINK_P (op)
15262 && BASELINK_QUALIFIED_P (op)));
15265 qualified_p = false;
15267 if (TREE_CODE (function) == ADDR_EXPR
15268 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
15269 /* Avoid error about taking the address of a constructor. */
15270 function = TREE_OPERAND (function, 0);
15272 function = tsubst_copy_and_build (function, args, complain,
15275 integral_constant_expression_p);
15277 if (BASELINK_P (function))
15278 qualified_p = true;
15281 nargs = call_expr_nargs (t);
15282 call_args = make_tree_vector ();
15283 for (i = 0; i < nargs; ++i)
15285 tree arg = CALL_EXPR_ARG (t, i);
15287 if (!PACK_EXPANSION_P (arg))
15288 vec_safe_push (call_args, RECUR (CALL_EXPR_ARG (t, i)));
15291 /* Expand the pack expansion and push each entry onto
15293 arg = tsubst_pack_expansion (arg, args, complain, in_decl);
15294 if (TREE_CODE (arg) == TREE_VEC)
15296 unsigned int len, j;
15298 len = TREE_VEC_LENGTH (arg);
15299 for (j = 0; j < len; ++j)
15301 tree value = TREE_VEC_ELT (arg, j);
15302 if (value != NULL_TREE)
15303 value = convert_from_reference (value);
15304 vec_safe_push (call_args, value);
15309 /* A partial substitution. Add one entry. */
15310 vec_safe_push (call_args, arg);
15315 /* We do not perform argument-dependent lookup if normal
15316 lookup finds a non-function, in accordance with the
15317 expected resolution of DR 218. */
15319 && ((is_overloaded_fn (function)
15320 /* If lookup found a member function, the Koenig lookup is
15321 not appropriate, even if an unqualified-name was used
15322 to denote the function. */
15323 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function)))
15324 || identifier_p (function))
15325 /* Only do this when substitution turns a dependent call
15326 into a non-dependent call. */
15327 && type_dependent_expression_p_push (t)
15328 && !any_type_dependent_arguments_p (call_args))
15329 function = perform_koenig_lookup (function, call_args, tf_none);
15331 if (identifier_p (function)
15332 && !any_type_dependent_arguments_p (call_args))
15334 if (koenig_p && (complain & tf_warning_or_error))
15336 /* For backwards compatibility and good diagnostics, try
15337 the unqualified lookup again if we aren't in SFINAE
15339 tree unq = (tsubst_copy_and_build
15340 (function, args, complain, in_decl, true,
15341 integral_constant_expression_p));
15342 if (unq == error_mark_node)
15343 RETURN (error_mark_node);
15345 if (unq != function)
15348 if (INDIRECT_REF_P (fn))
15349 fn = TREE_OPERAND (fn, 0);
15350 if (TREE_CODE (fn) == COMPONENT_REF)
15351 fn = TREE_OPERAND (fn, 1);
15352 if (is_overloaded_fn (fn))
15353 fn = get_first_fn (fn);
15354 if (permerror (EXPR_LOC_OR_LOC (t, input_location),
15355 "%qD was not declared in this scope, "
15356 "and no declarations were found by "
15357 "argument-dependent lookup at the point "
15358 "of instantiation", function))
15361 /* Can't say anything more. */;
15362 else if (DECL_CLASS_SCOPE_P (fn))
15364 location_t loc = EXPR_LOC_OR_LOC (t,
15367 "declarations in dependent base %qT are "
15368 "not found by unqualified lookup",
15369 DECL_CLASS_CONTEXT (fn));
15370 if (current_class_ptr)
15372 "use %<this->%D%> instead", function);
15375 "use %<%T::%D%> instead",
15376 current_class_name, function);
15379 inform (0, "%q+D declared here, later in the "
15380 "translation unit", fn);
15385 if (identifier_p (function))
15387 if (complain & tf_error)
15388 unqualified_name_lookup_error (function);
15389 release_tree_vector (call_args);
15390 RETURN (error_mark_node);
15394 /* Remember that there was a reference to this entity. */
15395 if (DECL_P (function)
15396 && !mark_used (function, complain) && !(complain & tf_error))
15397 RETURN (error_mark_node);
15399 /* Put back tf_decltype for the actual call. */
15400 complain |= decltype_flag;
15402 if (TREE_CODE (function) == OFFSET_REF)
15403 ret = build_offset_ref_call_from_tree (function, &call_args,
15405 else if (TREE_CODE (function) == COMPONENT_REF)
15407 tree instance = TREE_OPERAND (function, 0);
15408 tree fn = TREE_OPERAND (function, 1);
15410 if (processing_template_decl
15411 && (type_dependent_expression_p (instance)
15412 || (!BASELINK_P (fn)
15413 && TREE_CODE (fn) != FIELD_DECL)
15414 || type_dependent_expression_p (fn)
15415 || any_type_dependent_arguments_p (call_args)))
15416 ret = build_nt_call_vec (function, call_args);
15417 else if (!BASELINK_P (fn))
15418 ret = finish_call_expr (function, &call_args,
15419 /*disallow_virtual=*/false,
15420 /*koenig_p=*/false,
15423 ret = (build_new_method_call
15425 &call_args, NULL_TREE,
15426 qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL,
15431 ret = finish_call_expr (function, &call_args,
15432 /*disallow_virtual=*/qualified_p,
15436 release_tree_vector (call_args);
15443 tree cond = RECUR (TREE_OPERAND (t, 0));
15444 tree folded_cond = fold_non_dependent_expr (cond);
15447 if (TREE_CODE (folded_cond) == INTEGER_CST)
15449 if (integer_zerop (folded_cond))
15451 ++c_inhibit_evaluation_warnings;
15452 exp1 = RECUR (TREE_OPERAND (t, 1));
15453 --c_inhibit_evaluation_warnings;
15454 exp2 = RECUR (TREE_OPERAND (t, 2));
15458 exp1 = RECUR (TREE_OPERAND (t, 1));
15459 ++c_inhibit_evaluation_warnings;
15460 exp2 = RECUR (TREE_OPERAND (t, 2));
15461 --c_inhibit_evaluation_warnings;
15463 cond = folded_cond;
15467 exp1 = RECUR (TREE_OPERAND (t, 1));
15468 exp2 = RECUR (TREE_OPERAND (t, 2));
15471 RETURN (build_x_conditional_expr (EXPR_LOCATION (t),
15472 cond, exp1, exp2, complain));
15475 case PSEUDO_DTOR_EXPR:
15477 tree op0 = RECUR (TREE_OPERAND (t, 0));
15478 tree op1 = RECUR (TREE_OPERAND (t, 1));
15479 tree op2 = tsubst (TREE_OPERAND (t, 2), args, complain, in_decl);
15480 RETURN (finish_pseudo_destructor_expr (op0, op1, op2,
15486 tree purpose, value, chain;
15488 if (t == void_list_node)
15491 if ((TREE_PURPOSE (t) && PACK_EXPANSION_P (TREE_PURPOSE (t)))
15492 || (TREE_VALUE (t) && PACK_EXPANSION_P (TREE_VALUE (t))))
15494 /* We have pack expansions, so expand those and
15495 create a new list out of it. */
15496 tree purposevec = NULL_TREE;
15497 tree valuevec = NULL_TREE;
15501 /* Expand the argument expressions. */
15502 if (TREE_PURPOSE (t))
15503 purposevec = tsubst_pack_expansion (TREE_PURPOSE (t), args,
15504 complain, in_decl);
15505 if (TREE_VALUE (t))
15506 valuevec = tsubst_pack_expansion (TREE_VALUE (t), args,
15507 complain, in_decl);
15509 /* Build the rest of the list. */
15510 chain = TREE_CHAIN (t);
15511 if (chain && chain != void_type_node)
15512 chain = RECUR (chain);
15514 /* Determine the number of arguments. */
15515 if (purposevec && TREE_CODE (purposevec) == TREE_VEC)
15517 len = TREE_VEC_LENGTH (purposevec);
15518 gcc_assert (!valuevec || len == TREE_VEC_LENGTH (valuevec));
15520 else if (TREE_CODE (valuevec) == TREE_VEC)
15521 len = TREE_VEC_LENGTH (valuevec);
15524 /* Since we only performed a partial substitution into
15525 the argument pack, we only RETURN (a single list
15527 if (purposevec == TREE_PURPOSE (t)
15528 && valuevec == TREE_VALUE (t)
15529 && chain == TREE_CHAIN (t))
15532 RETURN (tree_cons (purposevec, valuevec, chain));
15535 /* Convert the argument vectors into a TREE_LIST */
15539 /* Grab the Ith values. */
15541 purpose = purposevec ? TREE_VEC_ELT (purposevec, i)
15544 = valuevec ? convert_from_reference (TREE_VEC_ELT (valuevec, i))
15547 /* Build the list (backwards). */
15548 chain = tree_cons (purpose, value, chain);
15554 purpose = TREE_PURPOSE (t);
15556 purpose = RECUR (purpose);
15557 value = TREE_VALUE (t);
15559 value = RECUR (value);
15560 chain = TREE_CHAIN (t);
15561 if (chain && chain != void_type_node)
15562 chain = RECUR (chain);
15563 if (purpose == TREE_PURPOSE (t)
15564 && value == TREE_VALUE (t)
15565 && chain == TREE_CHAIN (t))
15567 RETURN (tree_cons (purpose, value, chain));
15570 case COMPONENT_REF:
15577 object = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0),
15578 args, complain, in_decl);
15579 /* Remember that there was a reference to this entity. */
15580 if (DECL_P (object)
15581 && !mark_used (object, complain) && !(complain & tf_error))
15582 RETURN (error_mark_node);
15583 object_type = TREE_TYPE (object);
15585 member = TREE_OPERAND (t, 1);
15586 if (BASELINK_P (member))
15587 member = tsubst_baselink (member,
15588 non_reference (TREE_TYPE (object)),
15589 args, complain, in_decl);
15591 member = tsubst_copy (member, args, complain, in_decl);
15592 if (member == error_mark_node)
15593 RETURN (error_mark_node);
15595 if (type_dependent_expression_p (object))
15596 /* We can't do much here. */;
15597 else if (!CLASS_TYPE_P (object_type))
15599 if (scalarish_type_p (object_type))
15601 tree s = NULL_TREE;
15602 tree dtor = member;
15604 if (TREE_CODE (dtor) == SCOPE_REF)
15606 s = TREE_OPERAND (dtor, 0);
15607 dtor = TREE_OPERAND (dtor, 1);
15609 if (TREE_CODE (dtor) == BIT_NOT_EXPR)
15611 dtor = TREE_OPERAND (dtor, 0);
15613 RETURN (finish_pseudo_destructor_expr
15614 (object, s, dtor, input_location));
15618 else if (TREE_CODE (member) == SCOPE_REF
15619 && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
15621 /* Lookup the template functions now that we know what the
15623 tree scope = TREE_OPERAND (member, 0);
15624 tree tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
15625 tree args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
15626 member = lookup_qualified_name (scope, tmpl,
15627 /*is_type_p=*/false,
15628 /*complain=*/false);
15629 if (BASELINK_P (member))
15631 BASELINK_FUNCTIONS (member)
15632 = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
15634 member = (adjust_result_of_qualified_name_lookup
15635 (member, BINFO_TYPE (BASELINK_BINFO (member)),
15640 qualified_name_lookup_error (scope, tmpl, member,
15642 RETURN (error_mark_node);
15645 else if (TREE_CODE (member) == SCOPE_REF
15646 && !CLASS_TYPE_P (TREE_OPERAND (member, 0))
15647 && TREE_CODE (TREE_OPERAND (member, 0)) != NAMESPACE_DECL)
15649 if (complain & tf_error)
15651 if (TYPE_P (TREE_OPERAND (member, 0)))
15652 error ("%qT is not a class or namespace",
15653 TREE_OPERAND (member, 0));
15655 error ("%qD is not a class or namespace",
15656 TREE_OPERAND (member, 0));
15658 RETURN (error_mark_node);
15660 else if (TREE_CODE (member) == FIELD_DECL)
15662 r = finish_non_static_data_member (member, object, NULL_TREE);
15663 if (TREE_CODE (r) == COMPONENT_REF)
15664 REF_PARENTHESIZED_P (r) = REF_PARENTHESIZED_P (t);
15668 r = finish_class_member_access_expr (object, member,
15669 /*template_p=*/false,
15671 if (TREE_CODE (r) == COMPONENT_REF)
15672 REF_PARENTHESIZED_P (r) = REF_PARENTHESIZED_P (t);
15677 RETURN (build_throw
15678 (RECUR (TREE_OPERAND (t, 0))));
15682 vec<constructor_elt, va_gc> *n;
15683 constructor_elt *ce;
15684 unsigned HOST_WIDE_INT idx;
15685 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
15686 bool process_index_p;
15688 bool need_copy_p = false;
15691 if (type == error_mark_node)
15692 RETURN (error_mark_node);
15694 /* digest_init will do the wrong thing if we let it. */
15695 if (type && TYPE_PTRMEMFUNC_P (type))
15698 /* We do not want to process the index of aggregate
15699 initializers as they are identifier nodes which will be
15700 looked up by digest_init. */
15701 process_index_p = !(type && MAYBE_CLASS_TYPE_P (type));
15703 n = vec_safe_copy (CONSTRUCTOR_ELTS (t));
15704 newlen = vec_safe_length (n);
15705 FOR_EACH_VEC_SAFE_ELT (n, idx, ce)
15707 if (ce->index && process_index_p
15708 /* An identifier index is looked up in the type
15709 being initialized, not the current scope. */
15710 && TREE_CODE (ce->index) != IDENTIFIER_NODE)
15711 ce->index = RECUR (ce->index);
15713 if (PACK_EXPANSION_P (ce->value))
15715 /* Substitute into the pack expansion. */
15716 ce->value = tsubst_pack_expansion (ce->value, args, complain,
15719 if (ce->value == error_mark_node
15720 || PACK_EXPANSION_P (ce->value))
15722 else if (TREE_VEC_LENGTH (ce->value) == 1)
15723 /* Just move the argument into place. */
15724 ce->value = TREE_VEC_ELT (ce->value, 0);
15727 /* Update the length of the final CONSTRUCTOR
15728 arguments vector, and note that we will need to
15730 newlen = newlen + TREE_VEC_LENGTH (ce->value) - 1;
15731 need_copy_p = true;
15735 ce->value = RECUR (ce->value);
15740 vec<constructor_elt, va_gc> *old_n = n;
15742 vec_alloc (n, newlen);
15743 FOR_EACH_VEC_ELT (*old_n, idx, ce)
15745 if (TREE_CODE (ce->value) == TREE_VEC)
15747 int i, len = TREE_VEC_LENGTH (ce->value);
15748 for (i = 0; i < len; ++i)
15749 CONSTRUCTOR_APPEND_ELT (n, 0,
15750 TREE_VEC_ELT (ce->value, i));
15753 CONSTRUCTOR_APPEND_ELT (n, 0, ce->value);
15757 r = build_constructor (init_list_type_node, n);
15758 CONSTRUCTOR_IS_DIRECT_INIT (r) = CONSTRUCTOR_IS_DIRECT_INIT (t);
15760 if (TREE_HAS_CONSTRUCTOR (t))
15761 RETURN (finish_compound_literal (type, r, complain));
15763 TREE_TYPE (r) = type;
15769 tree operand_0 = TREE_OPERAND (t, 0);
15770 if (TYPE_P (operand_0))
15772 operand_0 = tsubst (operand_0, args, complain, in_decl);
15773 RETURN (get_typeid (operand_0, complain));
15777 operand_0 = RECUR (operand_0);
15778 RETURN (build_typeid (operand_0, complain));
15785 else if (DECL_PACK_P (t))
15787 /* We don't build decls for an instantiation of a
15788 variadic capture proxy, we instantiate the elements
15790 gcc_assert (DECL_HAS_VALUE_EXPR_P (t));
15791 return RECUR (DECL_VALUE_EXPR (t));
15797 tree r = tsubst_copy (t, args, complain, in_decl);
15798 /* ??? We're doing a subset of finish_id_expression here. */
15800 && !processing_template_decl
15801 && !cp_unevaluated_operand
15802 && (TREE_STATIC (r) || DECL_EXTERNAL (r))
15803 && DECL_THREAD_LOCAL_P (r))
15805 if (tree wrap = get_tls_wrapper_fn (r))
15806 /* Replace an evaluated use of the thread_local variable with
15807 a call to its wrapper. */
15808 r = build_cxx_call (wrap, 0, NULL, tf_warning_or_error);
15810 else if (outer_automatic_var_p (r))
15812 r = process_outer_var_ref (r, complain);
15813 if (is_capture_proxy (r))
15814 register_local_specialization (r, t);
15817 if (TREE_CODE (TREE_TYPE (t)) != REFERENCE_TYPE)
15818 /* If the original type was a reference, we'll be wrapped in
15819 the appropriate INDIRECT_REF. */
15820 r = convert_from_reference (r);
15826 tree op0 = RECUR (TREE_OPERAND (t, 0));
15827 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
15828 RETURN (build_x_va_arg (EXPR_LOCATION (t), op0, type));
15831 case OFFSETOF_EXPR:
15832 RETURN (finish_offsetof (RECUR (TREE_OPERAND (t, 0)),
15833 EXPR_LOCATION (t)));
15837 tree type1 = tsubst (TRAIT_EXPR_TYPE1 (t), args,
15838 complain, in_decl);
15840 tree type2 = TRAIT_EXPR_TYPE2 (t);
15841 if (type2 && TREE_CODE (type2) == TREE_LIST)
15842 type2 = RECUR (type2);
15844 type2 = tsubst (type2, args, complain, in_decl);
15846 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t), type1, type2));
15851 tree old_stmt_expr = cur_stmt_expr;
15852 tree stmt_expr = begin_stmt_expr ();
15854 cur_stmt_expr = stmt_expr;
15855 tsubst_expr (STMT_EXPR_STMT (t), args, complain, in_decl,
15856 integral_constant_expression_p);
15857 stmt_expr = finish_stmt_expr (stmt_expr, false);
15858 cur_stmt_expr = old_stmt_expr;
15860 /* If the resulting list of expression statement is empty,
15861 fold it further into void_node. */
15862 if (empty_expr_stmt_p (stmt_expr))
15863 stmt_expr = void_node;
15865 RETURN (stmt_expr);
15870 tree r = build_lambda_expr ();
15872 tree type = tsubst (LAMBDA_EXPR_CLOSURE (t), args, complain, NULL_TREE);
15873 LAMBDA_EXPR_CLOSURE (r) = type;
15874 CLASSTYPE_LAMBDA_EXPR (type) = r;
15876 LAMBDA_EXPR_LOCATION (r)
15877 = LAMBDA_EXPR_LOCATION (t);
15878 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r)
15879 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t);
15880 LAMBDA_EXPR_MUTABLE_P (r) = LAMBDA_EXPR_MUTABLE_P (t);
15881 LAMBDA_EXPR_DISCRIMINATOR (r)
15882 = (LAMBDA_EXPR_DISCRIMINATOR (t));
15883 /* For a function scope, we want to use tsubst so that we don't
15884 complain about referring to an auto function before its return
15885 type has been deduced. Otherwise, we want to use tsubst_copy so
15886 that we look up the existing field/parameter/variable rather
15887 than build a new one. */
15888 tree scope = LAMBDA_EXPR_EXTRA_SCOPE (t);
15889 if (scope && TREE_CODE (scope) == FUNCTION_DECL)
15890 scope = tsubst (scope, args, complain, in_decl);
15891 else if (scope && TREE_CODE (scope) == PARM_DECL)
15893 /* Look up the parameter we want directly, as tsubst_copy
15894 doesn't do what we need. */
15895 tree fn = tsubst (DECL_CONTEXT (scope), args, complain, in_decl);
15896 tree parm = FUNCTION_FIRST_USER_PARM (fn);
15897 while (DECL_PARM_INDEX (parm) != DECL_PARM_INDEX (scope))
15898 parm = DECL_CHAIN (parm);
15900 /* FIXME Work around the parm not having DECL_CONTEXT set. */
15901 if (DECL_CONTEXT (scope) == NULL_TREE)
15902 DECL_CONTEXT (scope) = fn;
15905 scope = RECUR (scope);
15906 LAMBDA_EXPR_EXTRA_SCOPE (r) = scope;
15908 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t) == NULL_TREE
15909 && LAMBDA_EXPR_PENDING_PROXIES (t) == NULL);
15911 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
15912 determine_visibility (TYPE_NAME (type));
15913 /* Now that we know visibility, instantiate the type so we have a
15914 declaration of the op() for later calls to lambda_function. */
15915 complete_type (type);
15917 if (tree fn = lambda_function (type))
15918 LAMBDA_EXPR_RETURN_TYPE (r) = TREE_TYPE (TREE_TYPE (fn));
15920 LAMBDA_EXPR_THIS_CAPTURE (r) = NULL_TREE;
15922 insert_pending_capture_proxies ();
15924 RETURN (build_lambda_object (r));
15928 /* We can get here for a constant initializer of non-dependent type.
15929 FIXME stop folding in cp_parser_initializer_clause. */
15931 tree r = get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t)),
15936 case TRANSACTION_EXPR:
15937 RETURN (tsubst_expr(t, args, complain, in_decl,
15938 integral_constant_expression_p));
15941 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t, 0))));
15943 case VEC_PERM_EXPR:
15945 tree op0 = RECUR (TREE_OPERAND (t, 0));
15946 tree op1 = RECUR (TREE_OPERAND (t, 1));
15947 tree op2 = RECUR (TREE_OPERAND (t, 2));
15948 RETURN (build_x_vec_perm_expr (input_location, op0, op1, op2,
15953 /* Handle Objective-C++ constructs, if appropriate. */
15956 = objcp_tsubst_copy_and_build (t, args, complain,
15957 in_decl, /*function_p=*/false);
15961 RETURN (tsubst_copy (t, args, complain, in_decl));
15967 input_location = loc;
15971 /* Verify that the instantiated ARGS are valid. For type arguments,
15972 make sure that the type's linkage is ok. For non-type arguments,
15973 make sure they are constants if they are integral or enumerations.
15974 Emit an error under control of COMPLAIN, and return TRUE on error. */
15977 check_instantiated_arg (tree tmpl, tree t, tsubst_flags_t complain)
15979 if (dependent_template_arg_p (t))
15981 if (ARGUMENT_PACK_P (t))
15983 tree vec = ARGUMENT_PACK_ARGS (t);
15984 int len = TREE_VEC_LENGTH (vec);
15985 bool result = false;
15988 for (i = 0; i < len; ++i)
15989 if (check_instantiated_arg (tmpl, TREE_VEC_ELT (vec, i), complain))
15993 else if (TYPE_P (t))
15995 /* [basic.link]: A name with no linkage (notably, the name
15996 of a class or enumeration declared in a local scope)
15997 shall not be used to declare an entity with linkage.
15998 This implies that names with no linkage cannot be used as
16001 DR 757 relaxes this restriction for C++0x. */
16002 tree nt = (cxx_dialect > cxx98 ? NULL_TREE
16003 : no_linkage_check (t, /*relaxed_p=*/false));
16007 /* DR 488 makes use of a type with no linkage cause
16008 type deduction to fail. */
16009 if (complain & tf_error)
16011 if (TYPE_ANONYMOUS_P (nt))
16012 error ("%qT is/uses anonymous type", t);
16014 error ("template argument for %qD uses local type %qT",
16019 /* In order to avoid all sorts of complications, we do not
16020 allow variably-modified types as template arguments. */
16021 else if (variably_modified_type_p (t, NULL_TREE))
16023 if (complain & tf_error)
16024 error ("%qT is a variably modified type", t);
16028 /* Class template and alias template arguments should be OK. */
16029 else if (DECL_TYPE_TEMPLATE_P (t))
16031 /* A non-type argument of integral or enumerated type must be a
16033 else if (TREE_TYPE (t)
16034 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t))
16035 && !REFERENCE_REF_P (t)
16036 && !TREE_CONSTANT (t))
16038 if (complain & tf_error)
16039 error ("integral expression %qE is not constant", t);
16046 check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain)
16048 int ix, len = DECL_NTPARMS (tmpl);
16049 bool result = false;
16051 for (ix = 0; ix != len; ix++)
16053 if (check_instantiated_arg (tmpl, TREE_VEC_ELT (args, ix), complain))
16056 if (result && (complain & tf_error))
16057 error (" trying to instantiate %qD", tmpl);
16061 /* We're out of SFINAE context now, so generate diagnostics for the access
16062 errors we saw earlier when instantiating D from TMPL and ARGS. */
16065 recheck_decl_substitution (tree d, tree tmpl, tree args)
16067 tree pattern = DECL_TEMPLATE_RESULT (tmpl);
16068 tree type = TREE_TYPE (pattern);
16069 location_t loc = input_location;
16071 push_access_scope (d);
16072 push_deferring_access_checks (dk_no_deferred);
16073 input_location = DECL_SOURCE_LOCATION (pattern);
16074 tsubst (type, args, tf_warning_or_error, d);
16075 input_location = loc;
16076 pop_deferring_access_checks ();
16077 pop_access_scope (d);
16080 /* Instantiate the indicated variable, function, or alias template TMPL with
16081 the template arguments in TARG_PTR. */
16084 instantiate_template_1 (tree tmpl, tree orig_args, tsubst_flags_t complain)
16086 tree targ_ptr = orig_args;
16090 bool access_ok = true;
16092 if (tmpl == error_mark_node)
16093 return error_mark_node;
16095 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
16097 /* If this function is a clone, handle it specially. */
16098 if (DECL_CLONED_FUNCTION_P (tmpl))
16103 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
16104 DECL_CLONED_FUNCTION. */
16105 spec = instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl),
16106 targ_ptr, complain);
16107 if (spec == error_mark_node)
16108 return error_mark_node;
16110 /* Look for the clone. */
16111 FOR_EACH_CLONE (clone, spec)
16112 if (DECL_NAME (clone) == DECL_NAME (tmpl))
16114 /* We should always have found the clone by now. */
16115 gcc_unreachable ();
16119 if (targ_ptr == error_mark_node)
16120 return error_mark_node;
16122 /* Check to see if we already have this specialization. */
16123 gen_tmpl = most_general_template (tmpl);
16124 if (tmpl != gen_tmpl)
16125 /* The TMPL is a partial instantiation. To get a full set of
16126 arguments we must add the arguments used to perform the
16127 partial instantiation. */
16128 targ_ptr = add_outermost_template_args (DECL_TI_ARGS (tmpl),
16131 /* It would be nice to avoid hashing here and then again in tsubst_decl,
16132 but it doesn't seem to be on the hot path. */
16133 spec = retrieve_specialization (gen_tmpl, targ_ptr, 0);
16135 gcc_assert (tmpl == gen_tmpl
16136 || ((fndecl = retrieve_specialization (tmpl, orig_args, 0))
16138 || fndecl == NULL_TREE);
16140 if (spec != NULL_TREE)
16142 if (FNDECL_HAS_ACCESS_ERRORS (spec))
16144 if (complain & tf_error)
16145 recheck_decl_substitution (spec, gen_tmpl, targ_ptr);
16146 return error_mark_node;
16151 if (check_instantiated_args (gen_tmpl, INNERMOST_TEMPLATE_ARGS (targ_ptr),
16153 return error_mark_node;
16155 /* We are building a FUNCTION_DECL, during which the access of its
16156 parameters and return types have to be checked. However this
16157 FUNCTION_DECL which is the desired context for access checking
16158 is not built yet. We solve this chicken-and-egg problem by
16159 deferring all checks until we have the FUNCTION_DECL. */
16160 push_deferring_access_checks (dk_deferred);
16162 /* Instantiation of the function happens in the context of the function
16163 template, not the context of the overload resolution we're doing. */
16164 push_to_top_level ();
16165 /* If there are dependent arguments, e.g. because we're doing partial
16166 ordering, make sure processing_template_decl stays set. */
16167 if (uses_template_parms (targ_ptr))
16168 ++processing_template_decl;
16169 if (DECL_CLASS_SCOPE_P (gen_tmpl))
16171 tree ctx = tsubst_aggr_type (DECL_CONTEXT (gen_tmpl), targ_ptr,
16172 complain, gen_tmpl, true);
16173 push_nested_class (ctx);
16176 tree pattern = DECL_TEMPLATE_RESULT (gen_tmpl);
16178 if (VAR_P (pattern))
16180 /* We need to determine if we're using a partial or explicit
16181 specialization now, because the type of the variable could be
16183 tree tid = lookup_template_variable (gen_tmpl, targ_ptr);
16184 tree elt = most_specialized_partial_spec (tid, complain);
16185 if (elt == error_mark_node)
16186 pattern = error_mark_node;
16189 tmpl = TREE_VALUE (elt);
16190 pattern = DECL_TEMPLATE_RESULT (tmpl);
16191 targ_ptr = TREE_PURPOSE (elt);
16195 /* Substitute template parameters to obtain the specialization. */
16196 fndecl = tsubst (pattern, targ_ptr, complain, gen_tmpl);
16197 if (DECL_CLASS_SCOPE_P (gen_tmpl))
16198 pop_nested_class ();
16199 pop_from_top_level ();
16201 if (fndecl == error_mark_node)
16203 pop_deferring_access_checks ();
16204 return error_mark_node;
16207 /* The DECL_TI_TEMPLATE should always be the immediate parent
16208 template, not the most general template. */
16209 DECL_TI_TEMPLATE (fndecl) = tmpl;
16210 if (VAR_P (fndecl))
16211 DECL_TI_ARGS (fndecl) = targ_ptr;
16213 /* Now we know the specialization, compute access previously
16215 push_access_scope (fndecl);
16216 if (!perform_deferred_access_checks (complain))
16218 pop_access_scope (fndecl);
16219 pop_deferring_access_checks ();
16221 /* If we've just instantiated the main entry point for a function,
16222 instantiate all the alternate entry points as well. We do this
16223 by cloning the instantiation of the main entry point, not by
16224 instantiating the template clones. */
16225 if (DECL_CHAIN (gen_tmpl) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl)))
16226 clone_function_decl (fndecl, /*update_method_vec_p=*/0);
16230 if (!(complain & tf_error))
16232 /* Remember to reinstantiate when we're out of SFINAE so the user
16233 can see the errors. */
16234 FNDECL_HAS_ACCESS_ERRORS (fndecl) = true;
16236 return error_mark_node;
16241 /* Wrapper for instantiate_template_1. */
16244 instantiate_template (tree tmpl, tree orig_args, tsubst_flags_t complain)
16247 timevar_push (TV_TEMPLATE_INST);
16248 ret = instantiate_template_1 (tmpl, orig_args, complain);
16249 timevar_pop (TV_TEMPLATE_INST);
16253 /* Instantiate the alias template TMPL with ARGS. Also push a template
16254 instantiation level, which instantiate_template doesn't do because
16255 functions and variables have sufficient context established by the
16259 instantiate_alias_template (tree tmpl, tree args, tsubst_flags_t complain)
16261 struct pending_template *old_last_pend = last_pending_template;
16262 struct tinst_level *old_error_tinst = last_error_tinst_level;
16263 if (tmpl == error_mark_node || args == error_mark_node)
16264 return error_mark_node;
16265 tree tinst = build_tree_list (tmpl, args);
16266 if (!push_tinst_level (tinst))
16269 return error_mark_node;
16273 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl),
16274 args, tmpl, complain,
16275 /*require_all_args=*/true,
16276 /*use_default_args=*/true);
16278 tree r = instantiate_template (tmpl, args, complain);
16279 pop_tinst_level ();
16280 /* We can't free this if a pending_template entry or last_error_tinst_level
16281 is pointing at it. */
16282 if (last_pending_template == old_last_pend
16283 && last_error_tinst_level == old_error_tinst)
16289 /* PARM is a template parameter pack for FN. Returns true iff
16290 PARM is used in a deducible way in the argument list of FN. */
16293 pack_deducible_p (tree parm, tree fn)
16295 tree t = FUNCTION_FIRST_USER_PARMTYPE (fn);
16296 for (; t; t = TREE_CHAIN (t))
16298 tree type = TREE_VALUE (t);
16300 if (!PACK_EXPANSION_P (type))
16302 for (packs = PACK_EXPANSION_PARAMETER_PACKS (type);
16303 packs; packs = TREE_CHAIN (packs))
16304 if (template_args_equal (TREE_VALUE (packs), parm))
16306 /* The template parameter pack is used in a function parameter
16307 pack. If this is the end of the parameter list, the
16308 template parameter pack is deducible. */
16309 if (TREE_CHAIN (t) == void_list_node)
16312 /* Otherwise, not. Well, it could be deduced from
16313 a non-pack parameter, but doing so would end up with
16314 a deduction mismatch, so don't bother. */
16318 /* The template parameter pack isn't used in any function parameter
16319 packs, but it might be used deeper, e.g. tuple<Args...>. */
16323 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
16324 NARGS elements of the arguments that are being used when calling
16325 it. TARGS is a vector into which the deduced template arguments
16328 Returns either a FUNCTION_DECL for the matching specialization of FN or
16329 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
16330 true, diagnostics will be printed to explain why it failed.
16332 If FN is a conversion operator, or we are trying to produce a specific
16333 specialization, RETURN_TYPE is the return type desired.
16335 The EXPLICIT_TARGS are explicit template arguments provided via a
16338 The parameter STRICT is one of:
16341 We are deducing arguments for a function call, as in
16342 [temp.deduct.call].
16345 We are deducing arguments for a conversion function, as in
16346 [temp.deduct.conv].
16349 We are deducing arguments when doing an explicit instantiation
16350 as in [temp.explicit], when determining an explicit specialization
16351 as in [temp.expl.spec], or when taking the address of a function
16352 template, as in [temp.deduct.funcaddr]. */
16355 fn_type_unification (tree fn,
16356 tree explicit_targs,
16359 unsigned int nargs,
16361 unification_kind_t strict,
16368 tree decl = NULL_TREE;
16369 tsubst_flags_t complain = (explain_p ? tf_warning_or_error : tf_none);
16371 static int deduction_depth;
16372 struct pending_template *old_last_pend = last_pending_template;
16373 struct tinst_level *old_error_tinst = last_error_tinst_level;
16374 tree tparms = DECL_INNERMOST_TEMPLATE_PARMS (fn);
16376 tree r = error_mark_node;
16379 complain |= tf_decltype;
16381 /* In C++0x, it's possible to have a function template whose type depends
16382 on itself recursively. This is most obvious with decltype, but can also
16383 occur with enumeration scope (c++/48969). So we need to catch infinite
16384 recursion and reject the substitution at deduction time; this function
16385 will return error_mark_node for any repeated substitution.
16387 This also catches excessive recursion such as when f<N> depends on
16388 f<N-1> across all integers, and returns error_mark_node for all the
16389 substitutions back up to the initial one.
16391 This is, of course, not reentrant. */
16392 if (excessive_deduction_depth)
16393 return error_mark_node;
16394 tinst = build_tree_list (fn, NULL_TREE);
16397 gcc_assert (TREE_CODE (fn) == TEMPLATE_DECL);
16399 fntype = TREE_TYPE (fn);
16400 if (explicit_targs)
16404 The specified template arguments must match the template
16405 parameters in kind (i.e., type, nontype, template), and there
16406 must not be more arguments than there are parameters;
16407 otherwise type deduction fails.
16409 Nontype arguments must match the types of the corresponding
16410 nontype template parameters, or must be convertible to the
16411 types of the corresponding nontype parameters as specified in
16412 _temp.arg.nontype_, otherwise type deduction fails.
16414 All references in the function type of the function template
16415 to the corresponding template parameters are replaced by the
16416 specified template argument values. If a substitution in a
16417 template parameter or in the function type of the function
16418 template results in an invalid type, type deduction fails. */
16419 int i, len = TREE_VEC_LENGTH (tparms);
16420 location_t loc = input_location;
16421 bool incomplete = false;
16423 /* Adjust any explicit template arguments before entering the
16424 substitution context. */
16426 = (coerce_template_parms (tparms, explicit_targs, NULL_TREE,
16428 /*require_all_args=*/false,
16429 /*use_default_args=*/false));
16430 if (explicit_targs == error_mark_node)
16433 /* Substitute the explicit args into the function type. This is
16434 necessary so that, for instance, explicitly declared function
16435 arguments can match null pointed constants. If we were given
16436 an incomplete set of explicit args, we must not do semantic
16437 processing during substitution as we could create partial
16439 for (i = 0; i < len; i++)
16441 tree parm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
16442 bool parameter_pack = false;
16443 tree targ = TREE_VEC_ELT (explicit_targs, i);
16445 /* Dig out the actual parm. */
16446 if (TREE_CODE (parm) == TYPE_DECL
16447 || TREE_CODE (parm) == TEMPLATE_DECL)
16449 parm = TREE_TYPE (parm);
16450 parameter_pack = TEMPLATE_TYPE_PARAMETER_PACK (parm);
16452 else if (TREE_CODE (parm) == PARM_DECL)
16454 parm = DECL_INITIAL (parm);
16455 parameter_pack = TEMPLATE_PARM_PARAMETER_PACK (parm);
16458 if (!parameter_pack && targ == NULL_TREE)
16459 /* No explicit argument for this template parameter. */
16462 if (parameter_pack && pack_deducible_p (parm, fn))
16464 /* Mark the argument pack as "incomplete". We could
16465 still deduce more arguments during unification.
16466 We remove this mark in type_unification_real. */
16469 ARGUMENT_PACK_INCOMPLETE_P(targ) = 1;
16470 ARGUMENT_PACK_EXPLICIT_ARGS (targ)
16471 = ARGUMENT_PACK_ARGS (targ);
16474 /* We have some incomplete argument packs. */
16479 TREE_VALUE (tinst) = explicit_targs;
16480 if (!push_tinst_level (tinst))
16482 excessive_deduction_depth = true;
16485 processing_template_decl += incomplete;
16486 input_location = DECL_SOURCE_LOCATION (fn);
16487 /* Ignore any access checks; we'll see them again in
16488 instantiate_template and they might have the wrong
16489 access path at this point. */
16490 push_deferring_access_checks (dk_deferred);
16491 fntype = tsubst (TREE_TYPE (fn), explicit_targs,
16492 complain | tf_partial, NULL_TREE);
16493 pop_deferring_access_checks ();
16494 input_location = loc;
16495 processing_template_decl -= incomplete;
16496 pop_tinst_level ();
16498 if (fntype == error_mark_node)
16501 /* Place the explicitly specified arguments in TARGS. */
16502 for (i = NUM_TMPL_ARGS (explicit_targs); i--;)
16503 TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (explicit_targs, i);
16506 /* Never do unification on the 'this' parameter. */
16507 parms = skip_artificial_parms_for (fn, TYPE_ARG_TYPES (fntype));
16513 parms = tree_cons (NULL_TREE, TREE_TYPE (fntype), parms);
16514 new_args = XALLOCAVEC (tree, nargs + 1);
16515 new_args[0] = return_type;
16516 memcpy (new_args + 1, args, nargs * sizeof (tree));
16521 /* We allow incomplete unification without an error message here
16522 because the standard doesn't seem to explicitly prohibit it. Our
16523 callers must be ready to deal with unification failures in any
16526 TREE_VALUE (tinst) = targs;
16527 /* If we aren't explaining yet, push tinst context so we can see where
16528 any errors (e.g. from class instantiations triggered by instantiation
16529 of default template arguments) come from. If we are explaining, this
16530 context is redundant. */
16531 if (!explain_p && !push_tinst_level (tinst))
16533 excessive_deduction_depth = true;
16537 /* type_unification_real will pass back any access checks from default
16538 template argument substitution. */
16539 vec<deferred_access_check, va_gc> *checks;
16542 ok = !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
16543 targs, parms, args, nargs, /*subr=*/0,
16544 strict, flags, &checks, explain_p);
16546 pop_tinst_level ();
16550 /* Now that we have bindings for all of the template arguments,
16551 ensure that the arguments deduced for the template template
16552 parameters have compatible template parameter lists. We cannot
16553 check this property before we have deduced all template
16554 arguments, because the template parameter types of a template
16555 template parameter might depend on prior template parameters
16556 deduced after the template template parameter. The following
16557 ill-formed example illustrates this issue:
16559 template<typename T, template<T> class C> void f(C<5>, T);
16561 template<int N> struct X {};
16564 f(X<5>(), 5l); // error: template argument deduction fails
16567 The template parameter list of 'C' depends on the template type
16568 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
16569 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
16570 time that we deduce 'C'. */
16571 if (!template_template_parm_bindings_ok_p
16572 (DECL_INNERMOST_TEMPLATE_PARMS (fn), targs))
16574 unify_inconsistent_template_template_parameters (explain_p);
16578 /* All is well so far. Now, check:
16582 When all template arguments have been deduced, all uses of
16583 template parameters in nondeduced contexts are replaced with
16584 the corresponding deduced argument values. If the
16585 substitution results in an invalid type, as described above,
16586 type deduction fails. */
16587 TREE_VALUE (tinst) = targs;
16588 if (!push_tinst_level (tinst))
16590 excessive_deduction_depth = true;
16594 /* Also collect access checks from the instantiation. */
16595 reopen_deferring_access_checks (checks);
16597 decl = instantiate_template (fn, targs, complain);
16599 checks = get_deferred_access_checks ();
16600 pop_deferring_access_checks ();
16602 pop_tinst_level ();
16604 if (decl == error_mark_node)
16607 /* Now perform any access checks encountered during substitution. */
16608 push_access_scope (decl);
16609 ok = perform_access_checks (checks, complain);
16610 pop_access_scope (decl);
16614 /* If we're looking for an exact match, check that what we got
16615 is indeed an exact match. It might not be if some template
16616 parameters are used in non-deduced contexts. But don't check
16617 for an exact match if we have dependent template arguments;
16618 in that case we're doing partial ordering, and we already know
16619 that we have two candidates that will provide the actual type. */
16620 if (strict == DEDUCE_EXACT && !any_dependent_template_arguments_p (targs))
16622 tree substed = TREE_TYPE (decl);
16626 = skip_artificial_parms_for (decl, TYPE_ARG_TYPES (substed));
16628 sarg = tree_cons (NULL_TREE, TREE_TYPE (substed), sarg);
16629 for (i = 0; i < nargs && sarg; ++i, sarg = TREE_CHAIN (sarg))
16630 if (!same_type_p (args[i], TREE_VALUE (sarg)))
16632 unify_type_mismatch (explain_p, args[i],
16633 TREE_VALUE (sarg));
16642 if (excessive_deduction_depth)
16644 if (deduction_depth == 0)
16645 /* Reset once we're all the way out. */
16646 excessive_deduction_depth = false;
16649 /* We can't free this if a pending_template entry or last_error_tinst_level
16650 is pointing at it. */
16651 if (last_pending_template == old_last_pend
16652 && last_error_tinst_level == old_error_tinst)
16658 /* Adjust types before performing type deduction, as described in
16659 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
16660 sections are symmetric. PARM is the type of a function parameter
16661 or the return type of the conversion function. ARG is the type of
16662 the argument passed to the call, or the type of the value
16663 initialized with the result of the conversion function.
16664 ARG_EXPR is the original argument expression, which may be null. */
16667 maybe_adjust_types_for_deduction (unification_kind_t strict,
16681 /* Swap PARM and ARG throughout the remainder of this
16682 function; the handling is precisely symmetric since PARM
16683 will initialize ARG rather than vice versa. */
16691 /* Core issue #873: Do the DR606 thing (see below) for these cases,
16692 too, but here handle it by stripping the reference from PARM
16693 rather than by adding it to ARG. */
16694 if (TREE_CODE (*parm) == REFERENCE_TYPE
16695 && TYPE_REF_IS_RVALUE (*parm)
16696 && TREE_CODE (TREE_TYPE (*parm)) == TEMPLATE_TYPE_PARM
16697 && cp_type_quals (TREE_TYPE (*parm)) == TYPE_UNQUALIFIED
16698 && TREE_CODE (*arg) == REFERENCE_TYPE
16699 && !TYPE_REF_IS_RVALUE (*arg))
16700 *parm = TREE_TYPE (*parm);
16701 /* Nothing else to do in this case. */
16705 gcc_unreachable ();
16708 if (TREE_CODE (*parm) != REFERENCE_TYPE)
16710 /* [temp.deduct.call]
16712 If P is not a reference type:
16714 --If A is an array type, the pointer type produced by the
16715 array-to-pointer standard conversion (_conv.array_) is
16716 used in place of A for type deduction; otherwise,
16718 --If A is a function type, the pointer type produced by
16719 the function-to-pointer standard conversion
16720 (_conv.func_) is used in place of A for type deduction;
16723 --If A is a cv-qualified type, the top level
16724 cv-qualifiers of A's type are ignored for type
16726 if (TREE_CODE (*arg) == ARRAY_TYPE)
16727 *arg = build_pointer_type (TREE_TYPE (*arg));
16728 else if (TREE_CODE (*arg) == FUNCTION_TYPE)
16729 *arg = build_pointer_type (*arg);
16731 *arg = TYPE_MAIN_VARIANT (*arg);
16734 /* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
16735 of the form T&&, where T is a template parameter, and the argument
16736 is an lvalue, T is deduced as A& */
16737 if (TREE_CODE (*parm) == REFERENCE_TYPE
16738 && TYPE_REF_IS_RVALUE (*parm)
16739 && TREE_CODE (TREE_TYPE (*parm)) == TEMPLATE_TYPE_PARM
16740 && cp_type_quals (TREE_TYPE (*parm)) == TYPE_UNQUALIFIED
16741 && (arg_expr ? real_lvalue_p (arg_expr)
16742 /* try_one_overload doesn't provide an arg_expr, but
16743 functions are always lvalues. */
16744 : TREE_CODE (*arg) == FUNCTION_TYPE))
16745 *arg = build_reference_type (*arg);
16747 /* [temp.deduct.call]
16749 If P is a cv-qualified type, the top level cv-qualifiers
16750 of P's type are ignored for type deduction. If P is a
16751 reference type, the type referred to by P is used for
16753 *parm = TYPE_MAIN_VARIANT (*parm);
16754 if (TREE_CODE (*parm) == REFERENCE_TYPE)
16756 *parm = TREE_TYPE (*parm);
16757 result |= UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
16760 /* DR 322. For conversion deduction, remove a reference type on parm
16761 too (which has been swapped into ARG). */
16762 if (strict == DEDUCE_CONV && TREE_CODE (*arg) == REFERENCE_TYPE)
16763 *arg = TREE_TYPE (*arg);
16768 /* Subroutine of unify_one_argument. PARM is a function parameter of a
16769 template which does contain any deducible template parameters; check if
16770 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
16771 unify_one_argument. */
16774 check_non_deducible_conversion (tree parm, tree arg, int strict,
16775 int flags, bool explain_p)
16780 type = TREE_TYPE (arg);
16784 if (same_type_p (parm, type))
16785 return unify_success (explain_p);
16787 if (strict == DEDUCE_CONV)
16789 if (can_convert_arg (type, parm, NULL_TREE, flags,
16790 explain_p ? tf_warning_or_error : tf_none))
16791 return unify_success (explain_p);
16793 else if (strict != DEDUCE_EXACT)
16795 if (can_convert_arg (parm, type,
16796 TYPE_P (arg) ? NULL_TREE : arg,
16797 flags, explain_p ? tf_warning_or_error : tf_none))
16798 return unify_success (explain_p);
16801 if (strict == DEDUCE_EXACT)
16802 return unify_type_mismatch (explain_p, parm, arg);
16804 return unify_arg_conversion (explain_p, parm, type, arg);
16807 static bool uses_deducible_template_parms (tree type);
16809 /* Returns true iff the expression EXPR is one from which a template
16810 argument can be deduced. In other words, if it's an undecorated
16811 use of a template non-type parameter. */
16814 deducible_expression (tree expr)
16816 return (TREE_CODE (expr) == TEMPLATE_PARM_INDEX);
16819 /* Returns true iff the array domain DOMAIN uses a template parameter in a
16820 deducible way; that is, if it has a max value of <PARM> - 1. */
16823 deducible_array_bound (tree domain)
16825 if (domain == NULL_TREE)
16828 tree max = TYPE_MAX_VALUE (domain);
16829 if (TREE_CODE (max) != MINUS_EXPR)
16832 return deducible_expression (TREE_OPERAND (max, 0));
16835 /* Returns true iff the template arguments ARGS use a template parameter
16836 in a deducible way. */
16839 deducible_template_args (tree args)
16841 for (int i = 0; i < TREE_VEC_LENGTH (args); ++i)
16844 tree elt = TREE_VEC_ELT (args, i);
16845 if (ARGUMENT_PACK_P (elt))
16846 deducible = deducible_template_args (ARGUMENT_PACK_ARGS (elt));
16849 if (PACK_EXPANSION_P (elt))
16850 elt = PACK_EXPANSION_PATTERN (elt);
16851 if (TREE_CODE (elt) == TEMPLATE_TEMPLATE_PARM)
16853 else if (TYPE_P (elt))
16854 deducible = uses_deducible_template_parms (elt);
16856 deducible = deducible_expression (elt);
16864 /* Returns true iff TYPE contains any deducible references to template
16865 parameters, as per 14.8.2.5. */
16868 uses_deducible_template_parms (tree type)
16870 if (PACK_EXPANSION_P (type))
16871 type = PACK_EXPANSION_PATTERN (type);
16878 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
16879 || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
16885 if (POINTER_TYPE_P (type))
16886 return uses_deducible_template_parms (TREE_TYPE (type));
16888 /* T[integer-constant ]
16890 if (TREE_CODE (type) == ARRAY_TYPE)
16891 return (uses_deducible_template_parms (TREE_TYPE (type))
16892 || deducible_array_bound (TYPE_DOMAIN (type)));
16904 if (TYPE_PTRMEM_P (type))
16905 return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type))
16906 || (uses_deducible_template_parms
16907 (TYPE_PTRMEM_POINTED_TO_TYPE (type))));
16909 /* template-name <T> (where template-name refers to a class template)
16910 template-name <i> (where template-name refers to a class template) */
16911 if (CLASS_TYPE_P (type)
16912 && CLASSTYPE_TEMPLATE_INFO (type)
16913 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
16914 return deducible_template_args (INNERMOST_TEMPLATE_ARGS
16915 (CLASSTYPE_TI_ARGS (type)));
16920 if (TREE_CODE (type) == FUNCTION_TYPE
16921 || TREE_CODE (type) == METHOD_TYPE)
16923 if (uses_deducible_template_parms (TREE_TYPE (type)))
16925 tree parm = TYPE_ARG_TYPES (type);
16926 if (TREE_CODE (type) == METHOD_TYPE)
16927 parm = TREE_CHAIN (parm);
16928 for (; parm; parm = TREE_CHAIN (parm))
16929 if (uses_deducible_template_parms (TREE_VALUE (parm)))
16936 /* Subroutine of type_unification_real and unify_pack_expansion to
16937 handle unification of a single P/A pair. Parameters are as
16938 for those functions. */
16941 unify_one_argument (tree tparms, tree targs, tree parm, tree arg,
16942 int subr, unification_kind_t strict, int flags,
16945 tree arg_expr = NULL_TREE;
16948 if (arg == error_mark_node || parm == error_mark_node)
16949 return unify_invalid (explain_p);
16950 if (arg == unknown_type_node)
16951 /* We can't deduce anything from this, but we might get all the
16952 template args from other function args. */
16953 return unify_success (explain_p);
16955 /* Implicit conversions (Clause 4) will be performed on a function
16956 argument to convert it to the type of the corresponding function
16957 parameter if the parameter type contains no template-parameters that
16958 participate in template argument deduction. */
16959 if (TYPE_P (parm) && !uses_template_parms (parm))
16960 /* For function parameters that contain no template-parameters at all,
16961 we have historically checked for convertibility in order to shortcut
16962 consideration of this candidate. */
16963 return check_non_deducible_conversion (parm, arg, strict, flags,
16965 else if (strict == DEDUCE_CALL
16966 && TYPE_P (parm) && !uses_deducible_template_parms (parm))
16967 /* For function parameters with only non-deducible template parameters,
16969 return unify_success (explain_p);
16974 arg_strict = (UNIFY_ALLOW_OUTER_LEVEL
16975 | UNIFY_ALLOW_MORE_CV_QUAL
16976 | UNIFY_ALLOW_DERIVED);
16980 arg_strict = UNIFY_ALLOW_LESS_CV_QUAL;
16984 arg_strict = UNIFY_ALLOW_NONE;
16988 gcc_unreachable ();
16991 /* We only do these transformations if this is the top-level
16992 parameter_type_list in a call or declaration matching; in other
16993 situations (nested function declarators, template argument lists) we
16994 won't be comparing a type to an expression, and we don't do any type
17000 gcc_assert (TREE_TYPE (arg) != NULL_TREE);
17001 if (type_unknown_p (arg))
17003 /* [temp.deduct.type] A template-argument can be
17004 deduced from a pointer to function or pointer
17005 to member function argument if the set of
17006 overloaded functions does not contain function
17007 templates and at most one of a set of
17008 overloaded functions provides a unique
17011 if (resolve_overloaded_unification
17012 (tparms, targs, parm, arg, strict,
17013 arg_strict, explain_p))
17014 return unify_success (explain_p);
17015 return unify_overload_resolution_failure (explain_p, arg);
17019 arg = unlowered_expr_type (arg);
17020 if (arg == error_mark_node)
17021 return unify_invalid (explain_p);
17025 maybe_adjust_types_for_deduction (strict, &parm, &arg, arg_expr);
17028 if ((TYPE_P (parm) || TREE_CODE (parm) == TEMPLATE_DECL)
17029 != (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL))
17030 return unify_template_argument_mismatch (explain_p, parm, arg);
17032 /* For deduction from an init-list we need the actual list. */
17033 if (arg_expr && BRACE_ENCLOSED_INITIALIZER_P (arg_expr))
17035 return unify (tparms, targs, parm, arg, arg_strict, explain_p);
17038 /* Most parms like fn_type_unification.
17040 If SUBR is 1, we're being called recursively (to unify the
17041 arguments of a function or method parameter of a function
17044 CHECKS is a pointer to a vector of access checks encountered while
17045 substituting default template arguments. */
17048 type_unification_real (tree tparms,
17052 unsigned int xnargs,
17054 unification_kind_t strict,
17056 vec<deferred_access_check, va_gc> **checks,
17061 int ntparms = TREE_VEC_LENGTH (tparms);
17062 int saw_undeduced = 0;
17065 unsigned int nargs;
17068 gcc_assert (TREE_CODE (tparms) == TREE_VEC);
17069 gcc_assert (xparms == NULL_TREE || TREE_CODE (xparms) == TREE_LIST);
17070 gcc_assert (ntparms > 0);
17072 /* Reset the number of non-defaulted template arguments contained
17074 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs) = NULL_TREE;
17082 while (parms && parms != void_list_node
17085 parm = TREE_VALUE (parms);
17087 if (TREE_CODE (parm) == TYPE_PACK_EXPANSION
17088 && (!TREE_CHAIN (parms) || TREE_CHAIN (parms) == void_list_node))
17089 /* For a function parameter pack that occurs at the end of the
17090 parameter-declaration-list, the type A of each remaining
17091 argument of the call is compared with the type P of the
17092 declarator-id of the function parameter pack. */
17095 parms = TREE_CHAIN (parms);
17097 if (TREE_CODE (parm) == TYPE_PACK_EXPANSION)
17098 /* For a function parameter pack that does not occur at the
17099 end of the parameter-declaration-list, the type of the
17100 parameter pack is a non-deduced context. */
17106 if (unify_one_argument (tparms, targs, parm, arg, subr, strict,
17112 && parms != void_list_node
17113 && TREE_CODE (TREE_VALUE (parms)) == TYPE_PACK_EXPANSION)
17115 /* Unify the remaining arguments with the pack expansion type. */
17117 tree parmvec = make_tree_vec (1);
17119 /* Allocate a TREE_VEC and copy in all of the arguments */
17120 argvec = make_tree_vec (nargs - ia);
17121 for (i = 0; ia < nargs; ++ia, ++i)
17122 TREE_VEC_ELT (argvec, i) = args[ia];
17124 /* Copy the parameter into parmvec. */
17125 TREE_VEC_ELT (parmvec, 0) = TREE_VALUE (parms);
17126 if (unify_pack_expansion (tparms, targs, parmvec, argvec, strict,
17127 /*subr=*/subr, explain_p))
17130 /* Advance to the end of the list of parameters. */
17131 parms = TREE_CHAIN (parms);
17134 /* Fail if we've reached the end of the parm list, and more args
17135 are present, and the parm list isn't variadic. */
17136 if (ia < nargs && parms == void_list_node)
17137 return unify_too_many_arguments (explain_p, nargs, ia);
17138 /* Fail if parms are left and they don't have default values and
17139 they aren't all deduced as empty packs (c++/57397). This is
17140 consistent with sufficient_parms_p. */
17141 if (parms && parms != void_list_node
17142 && TREE_PURPOSE (parms) == NULL_TREE)
17144 unsigned int count = nargs;
17149 type_pack_p = TREE_CODE (TREE_VALUE (p)) == TYPE_PACK_EXPANSION;
17152 p = TREE_CHAIN (p);
17154 while (p && p != void_list_node);
17155 if (count != nargs)
17156 return unify_too_few_arguments (explain_p, ia, count,
17162 tsubst_flags_t complain = (explain_p
17163 ? tf_warning_or_error
17166 for (i = 0; i < ntparms; i++)
17168 tree targ = TREE_VEC_ELT (targs, i);
17169 tree tparm = TREE_VEC_ELT (tparms, i);
17171 /* Clear the "incomplete" flags on all argument packs now so that
17172 substituting them into later default arguments works. */
17173 if (targ && ARGUMENT_PACK_P (targ))
17175 ARGUMENT_PACK_INCOMPLETE_P (targ) = 0;
17176 ARGUMENT_PACK_EXPLICIT_ARGS (targ) = NULL_TREE;
17179 if (targ || tparm == error_mark_node)
17181 tparm = TREE_VALUE (tparm);
17183 /* If this is an undeduced nontype parameter that depends on
17184 a type parameter, try another pass; its type may have been
17185 deduced from a later argument than the one from which
17186 this parameter can be deduced. */
17187 if (TREE_CODE (tparm) == PARM_DECL
17188 && uses_template_parms (TREE_TYPE (tparm))
17189 && !saw_undeduced++)
17192 /* Core issue #226 (C++0x) [temp.deduct]:
17194 If a template argument has not been deduced, its
17195 default template argument, if any, is used.
17197 When we are in C++98 mode, TREE_PURPOSE will either
17198 be NULL_TREE or ERROR_MARK_NODE, so we do not need
17199 to explicitly check cxx_dialect here. */
17200 if (TREE_PURPOSE (TREE_VEC_ELT (tparms, i)))
17202 tree parm = TREE_VALUE (TREE_VEC_ELT (tparms, i));
17203 tree arg = TREE_PURPOSE (TREE_VEC_ELT (tparms, i));
17204 reopen_deferring_access_checks (*checks);
17205 location_t save_loc = input_location;
17207 input_location = DECL_SOURCE_LOCATION (parm);
17208 arg = tsubst_template_arg (arg, targs, complain, NULL_TREE);
17209 arg = convert_template_argument (parm, arg, targs, complain,
17211 input_location = save_loc;
17212 *checks = get_deferred_access_checks ();
17213 pop_deferring_access_checks ();
17214 if (arg == error_mark_node)
17218 TREE_VEC_ELT (targs, i) = arg;
17219 /* The position of the first default template argument,
17220 is also the number of non-defaulted arguments in TARGS.
17222 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs))
17223 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs, i);
17228 /* If the type parameter is a parameter pack, then it will
17229 be deduced to an empty parameter pack. */
17230 if (template_parameter_pack_p (tparm))
17234 if (TREE_CODE (tparm) == TEMPLATE_PARM_INDEX)
17236 arg = make_node (NONTYPE_ARGUMENT_PACK);
17237 TREE_TYPE (arg) = TREE_TYPE (TEMPLATE_PARM_DECL (tparm));
17238 TREE_CONSTANT (arg) = 1;
17241 arg = cxx_make_type (TYPE_ARGUMENT_PACK);
17243 SET_ARGUMENT_PACK_ARGS (arg, make_tree_vec (0));
17245 TREE_VEC_ELT (targs, i) = arg;
17249 return unify_parameter_deduction_failure (explain_p, tparm);
17252 #ifdef ENABLE_CHECKING
17253 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs))
17254 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs, TREE_VEC_LENGTH (targs));
17257 return unify_success (explain_p);
17260 /* Subroutine of type_unification_real. Args are like the variables
17261 at the call site. ARG is an overloaded function (or template-id);
17262 we try deducing template args from each of the overloads, and if
17263 only one succeeds, we go with that. Modifies TARGS and returns
17264 true on success. */
17267 resolve_overloaded_unification (tree tparms,
17271 unification_kind_t strict,
17275 tree tempargs = copy_node (targs);
17277 tree goodfn = NULL_TREE;
17280 if (TREE_CODE (arg) == ADDR_EXPR)
17282 arg = TREE_OPERAND (arg, 0);
17288 if (TREE_CODE (arg) == COMPONENT_REF)
17289 /* Handle `&x' where `x' is some static or non-static member
17291 arg = TREE_OPERAND (arg, 1);
17293 if (TREE_CODE (arg) == OFFSET_REF)
17294 arg = TREE_OPERAND (arg, 1);
17296 /* Strip baselink information. */
17297 if (BASELINK_P (arg))
17298 arg = BASELINK_FUNCTIONS (arg);
17300 if (TREE_CODE (arg) == TEMPLATE_ID_EXPR)
17302 /* If we got some explicit template args, we need to plug them into
17303 the affected templates before we try to unify, in case the
17304 explicit args will completely resolve the templates in question. */
17307 tree expl_subargs = TREE_OPERAND (arg, 1);
17308 arg = TREE_OPERAND (arg, 0);
17310 for (; arg; arg = OVL_NEXT (arg))
17312 tree fn = OVL_CURRENT (arg);
17313 tree subargs, elem;
17315 if (TREE_CODE (fn) != TEMPLATE_DECL)
17318 subargs = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn),
17319 expl_subargs, NULL_TREE, tf_none,
17320 /*require_all_args=*/true,
17321 /*use_default_args=*/true);
17322 if (subargs != error_mark_node
17323 && !any_dependent_template_arguments_p (subargs))
17325 elem = TREE_TYPE (instantiate_template (fn, subargs, tf_none));
17326 if (try_one_overload (tparms, targs, tempargs, parm,
17327 elem, strict, sub_strict, addr_p, explain_p)
17328 && (!goodfn || !same_type_p (goodfn, elem)))
17337 /* If no templates (or more than one) are fully resolved by the
17338 explicit arguments, this template-id is a non-deduced context; it
17339 could still be OK if we deduce all template arguments for the
17340 enclosing call through other arguments. */
17344 else if (TREE_CODE (arg) != OVERLOAD
17345 && TREE_CODE (arg) != FUNCTION_DECL)
17346 /* If ARG is, for example, "(0, &f)" then its type will be unknown
17347 -- but the deduction does not succeed because the expression is
17348 not just the function on its own. */
17351 for (; arg; arg = OVL_NEXT (arg))
17352 if (try_one_overload (tparms, targs, tempargs, parm,
17353 TREE_TYPE (OVL_CURRENT (arg)),
17354 strict, sub_strict, addr_p, explain_p)
17355 && (!goodfn || !decls_match (goodfn, OVL_CURRENT (arg))))
17357 goodfn = OVL_CURRENT (arg);
17361 /* [temp.deduct.type] A template-argument can be deduced from a pointer
17362 to function or pointer to member function argument if the set of
17363 overloaded functions does not contain function templates and at most
17364 one of a set of overloaded functions provides a unique match.
17366 So if we found multiple possibilities, we return success but don't
17367 deduce anything. */
17371 int i = TREE_VEC_LENGTH (targs);
17373 if (TREE_VEC_ELT (tempargs, i))
17375 tree old = TREE_VEC_ELT (targs, i);
17376 tree new_ = TREE_VEC_ELT (tempargs, i);
17377 if (new_ && old && ARGUMENT_PACK_P (old)
17378 && ARGUMENT_PACK_EXPLICIT_ARGS (old))
17379 /* Don't forget explicit template arguments in a pack. */
17380 ARGUMENT_PACK_EXPLICIT_ARGS (new_)
17381 = ARGUMENT_PACK_EXPLICIT_ARGS (old);
17382 TREE_VEC_ELT (targs, i) = new_;
17391 /* Core DR 115: In contexts where deduction is done and fails, or in
17392 contexts where deduction is not done, if a template argument list is
17393 specified and it, along with any default template arguments, identifies
17394 a single function template specialization, then the template-id is an
17395 lvalue for the function template specialization. */
17398 resolve_nondeduced_context (tree orig_expr, tsubst_flags_t complain)
17400 tree expr, offset, baselink;
17403 if (!type_unknown_p (orig_expr))
17408 offset = NULL_TREE;
17409 baselink = NULL_TREE;
17411 if (TREE_CODE (expr) == ADDR_EXPR)
17413 expr = TREE_OPERAND (expr, 0);
17416 if (TREE_CODE (expr) == OFFSET_REF)
17419 expr = TREE_OPERAND (expr, 1);
17421 if (BASELINK_P (expr))
17424 expr = BASELINK_FUNCTIONS (expr);
17427 if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
17430 tree goodfn = NULL_TREE;
17432 /* If we got some explicit template args, we need to plug them into
17433 the affected templates before we try to unify, in case the
17434 explicit args will completely resolve the templates in question. */
17436 tree expl_subargs = TREE_OPERAND (expr, 1);
17437 tree arg = TREE_OPERAND (expr, 0);
17438 tree badfn = NULL_TREE;
17439 tree badargs = NULL_TREE;
17441 for (; arg; arg = OVL_NEXT (arg))
17443 tree fn = OVL_CURRENT (arg);
17444 tree subargs, elem;
17446 if (TREE_CODE (fn) != TEMPLATE_DECL)
17449 subargs = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn),
17450 expl_subargs, NULL_TREE, tf_none,
17451 /*require_all_args=*/true,
17452 /*use_default_args=*/true);
17453 if (subargs != error_mark_node
17454 && !any_dependent_template_arguments_p (subargs))
17456 elem = instantiate_template (fn, subargs, tf_none);
17457 if (elem == error_mark_node)
17462 else if (elem && (!goodfn || !decls_match (goodfn, elem)))
17471 mark_used (goodfn);
17474 expr = build_baselink (BASELINK_BINFO (baselink),
17475 BASELINK_ACCESS_BINFO (baselink),
17476 expr, BASELINK_OPTYPE (baselink));
17480 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset, 0)));
17481 expr = build_offset_ref (base, expr, addr, complain);
17484 expr = cp_build_addr_expr (expr, complain);
17487 else if (good == 0 && badargs && (complain & tf_error))
17488 /* There were no good options and at least one bad one, so let the
17489 user know what the problem is. */
17490 instantiate_template (badfn, badargs, complain);
17495 /* Subroutine of resolve_overloaded_unification; does deduction for a single
17496 overload. Fills TARGS with any deduced arguments, or error_mark_node if
17497 different overloads deduce different arguments for a given parm.
17498 ADDR_P is true if the expression for which deduction is being
17499 performed was of the form "& fn" rather than simply "fn".
17501 Returns 1 on success. */
17504 try_one_overload (tree tparms,
17509 unification_kind_t strict,
17518 if (arg == error_mark_node)
17521 /* [temp.deduct.type] A template-argument can be deduced from a pointer
17522 to function or pointer to member function argument if the set of
17523 overloaded functions does not contain function templates and at most
17524 one of a set of overloaded functions provides a unique match.
17526 So if this is a template, just return success. */
17528 if (uses_template_parms (arg))
17531 if (TREE_CODE (arg) == METHOD_TYPE)
17532 arg = build_ptrmemfunc_type (build_pointer_type (arg));
17534 arg = build_pointer_type (arg);
17536 sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg, NULL);
17538 /* We don't copy orig_targs for this because if we have already deduced
17539 some template args from previous args, unify would complain when we
17540 try to deduce a template parameter for the same argument, even though
17541 there isn't really a conflict. */
17542 nargs = TREE_VEC_LENGTH (targs);
17543 tempargs = make_tree_vec (nargs);
17545 if (unify (tparms, tempargs, parm, arg, sub_strict, explain_p))
17548 /* First make sure we didn't deduce anything that conflicts with
17549 explicitly specified args. */
17550 for (i = nargs; i--; )
17552 tree elt = TREE_VEC_ELT (tempargs, i);
17553 tree oldelt = TREE_VEC_ELT (orig_targs, i);
17557 else if (uses_template_parms (elt))
17558 /* Since we're unifying against ourselves, we will fill in
17559 template args used in the function parm list with our own
17560 template parms. Discard them. */
17561 TREE_VEC_ELT (tempargs, i) = NULL_TREE;
17562 else if (oldelt && !template_args_equal (oldelt, elt))
17566 for (i = nargs; i--; )
17568 tree elt = TREE_VEC_ELT (tempargs, i);
17571 TREE_VEC_ELT (targs, i) = elt;
17577 /* PARM is a template class (perhaps with unbound template
17578 parameters). ARG is a fully instantiated type. If ARG can be
17579 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
17580 TARGS are as for unify. */
17583 try_class_unification (tree tparms, tree targs, tree parm, tree arg,
17586 tree copy_of_targs;
17588 if (!CLASSTYPE_TEMPLATE_INFO (arg)
17589 || (most_general_template (CLASSTYPE_TI_TEMPLATE (arg))
17590 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm))))
17593 /* We need to make a new template argument vector for the call to
17594 unify. If we used TARGS, we'd clutter it up with the result of
17595 the attempted unification, even if this class didn't work out.
17596 We also don't want to commit ourselves to all the unifications
17597 we've already done, since unification is supposed to be done on
17598 an argument-by-argument basis. In other words, consider the
17599 following pathological case:
17601 template <int I, int J, int K>
17604 template <int I, int J>
17605 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
17607 template <int I, int J, int K>
17608 void f(S<I, J, K>, S<I, I, I>);
17617 Now, by the time we consider the unification involving `s2', we
17618 already know that we must have `f<0, 0, 0>'. But, even though
17619 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
17620 because there are two ways to unify base classes of S<0, 1, 2>
17621 with S<I, I, I>. If we kept the already deduced knowledge, we
17622 would reject the possibility I=1. */
17623 copy_of_targs = make_tree_vec (TREE_VEC_LENGTH (targs));
17625 /* If unification failed, we're done. */
17626 if (unify (tparms, copy_of_targs, CLASSTYPE_TI_ARGS (parm),
17627 CLASSTYPE_TI_ARGS (arg), UNIFY_ALLOW_NONE, explain_p))
17633 /* Given a template type PARM and a class type ARG, find the unique
17634 base type in ARG that is an instance of PARM. We do not examine
17635 ARG itself; only its base-classes. If there is not exactly one
17636 appropriate base class, return NULL_TREE. PARM may be the type of
17637 a partial specialization, as well as a plain template type. Used
17640 static enum template_base_result
17641 get_template_base (tree tparms, tree targs, tree parm, tree arg,
17642 bool explain_p, tree *result)
17644 tree rval = NULL_TREE;
17647 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg)));
17649 binfo = TYPE_BINFO (complete_type (arg));
17652 /* The type could not be completed. */
17653 *result = NULL_TREE;
17654 return tbr_incomplete_type;
17657 /* Walk in inheritance graph order. The search order is not
17658 important, and this avoids multiple walks of virtual bases. */
17659 for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo))
17661 tree r = try_class_unification (tparms, targs, parm,
17662 BINFO_TYPE (binfo), explain_p);
17666 /* If there is more than one satisfactory baseclass, then:
17670 If they yield more than one possible deduced A, the type
17674 if (rval && !same_type_p (r, rval))
17676 *result = NULL_TREE;
17677 return tbr_ambiguous_baseclass;
17685 return tbr_success;
17688 /* Returns the level of DECL, which declares a template parameter. */
17691 template_decl_level (tree decl)
17693 switch (TREE_CODE (decl))
17696 case TEMPLATE_DECL:
17697 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl));
17700 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl));
17703 gcc_unreachable ();
17708 /* Decide whether ARG can be unified with PARM, considering only the
17709 cv-qualifiers of each type, given STRICT as documented for unify.
17710 Returns nonzero iff the unification is OK on that basis. */
17713 check_cv_quals_for_unify (int strict, tree arg, tree parm)
17715 int arg_quals = cp_type_quals (arg);
17716 int parm_quals = cp_type_quals (parm);
17718 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
17719 && !(strict & UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
17721 /* Although a CVR qualifier is ignored when being applied to a
17722 substituted template parameter ([8.3.2]/1 for example), that
17723 does not allow us to unify "const T" with "int&" because both
17724 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
17725 It is ok when we're allowing additional CV qualifiers
17726 at the outer level [14.8.2.1]/3,1st bullet. */
17727 if ((TREE_CODE (arg) == REFERENCE_TYPE
17728 || TREE_CODE (arg) == FUNCTION_TYPE
17729 || TREE_CODE (arg) == METHOD_TYPE)
17730 && (parm_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)))
17733 if ((!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM)
17734 && (parm_quals & TYPE_QUAL_RESTRICT))
17738 if (!(strict & (UNIFY_ALLOW_MORE_CV_QUAL | UNIFY_ALLOW_OUTER_MORE_CV_QUAL))
17739 && (arg_quals & parm_quals) != parm_quals)
17742 if (!(strict & (UNIFY_ALLOW_LESS_CV_QUAL | UNIFY_ALLOW_OUTER_LESS_CV_QUAL))
17743 && (parm_quals & arg_quals) != arg_quals)
17749 /* Determines the LEVEL and INDEX for the template parameter PARM. */
17751 template_parm_level_and_index (tree parm, int* level, int* index)
17753 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
17754 || TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
17755 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
17757 *index = TEMPLATE_TYPE_IDX (parm);
17758 *level = TEMPLATE_TYPE_LEVEL (parm);
17762 *index = TEMPLATE_PARM_IDX (parm);
17763 *level = TEMPLATE_PARM_LEVEL (parm);
17767 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
17769 if (unify (TP, TA, P, A, S, EP)) \
17773 /* Unifies the remaining arguments in PACKED_ARGS with the pack
17774 expansion at the end of PACKED_PARMS. Returns 0 if the type
17775 deduction succeeds, 1 otherwise. STRICT is the same as in
17776 unify. CALL_ARGS_P is true iff PACKED_ARGS is actually a function
17777 call argument list. We'll need to adjust the arguments to make them
17778 types. SUBR tells us if this is from a recursive call to
17779 type_unification_real, or for comparing two template argument
17783 unify_pack_expansion (tree tparms, tree targs, tree packed_parms,
17784 tree packed_args, unification_kind_t strict,
17785 bool subr, bool explain_p)
17788 = TREE_VEC_ELT (packed_parms, TREE_VEC_LENGTH (packed_parms) - 1);
17789 tree pattern = PACK_EXPANSION_PATTERN (parm);
17790 tree pack, packs = NULL_TREE;
17791 int i, start = TREE_VEC_LENGTH (packed_parms) - 1;
17793 packed_args = expand_template_argument_pack (packed_args);
17795 int len = TREE_VEC_LENGTH (packed_args);
17797 /* Determine the parameter packs we will be deducing from the
17798 pattern, and record their current deductions. */
17799 for (pack = PACK_EXPANSION_PARAMETER_PACKS (parm);
17800 pack; pack = TREE_CHAIN (pack))
17802 tree parm_pack = TREE_VALUE (pack);
17805 /* Determine the index and level of this parameter pack. */
17806 template_parm_level_and_index (parm_pack, &level, &idx);
17808 /* Keep track of the parameter packs and their corresponding
17810 packs = tree_cons (parm_pack, TMPL_ARG (targs, level, idx), packs);
17811 TREE_TYPE (packs) = make_tree_vec (len - start);
17814 /* Loop through all of the arguments that have not yet been
17815 unified and unify each with the pattern. */
17816 for (i = start; i < len; i++)
17819 bool any_explicit = false;
17820 tree arg = TREE_VEC_ELT (packed_args, i);
17822 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
17823 or the element of its argument pack at the current index if
17824 this argument was explicitly specified. */
17825 for (pack = packs; pack; pack = TREE_CHAIN (pack))
17829 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
17832 if (TREE_VALUE (pack)
17833 && (pargs = ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack)))
17834 && (i - start < TREE_VEC_LENGTH (pargs)))
17836 any_explicit = true;
17837 arg = TREE_VEC_ELT (pargs, i - start);
17839 TMPL_ARG (targs, level, idx) = arg;
17842 /* If we had explicit template arguments, substitute them into the
17843 pattern before deduction. */
17846 /* Some arguments might still be unspecified or dependent. */
17848 ++processing_template_decl;
17849 dependent = any_dependent_template_arguments_p (targs);
17851 --processing_template_decl;
17852 parm = tsubst (pattern, targs,
17853 explain_p ? tf_warning_or_error : tf_none,
17856 --processing_template_decl;
17857 if (parm == error_mark_node)
17863 /* Unify the pattern with the current argument. */
17864 if (unify_one_argument (tparms, targs, parm, arg, subr, strict,
17865 LOOKUP_IMPLICIT, explain_p))
17868 /* For each parameter pack, collect the deduced value. */
17869 for (pack = packs; pack; pack = TREE_CHAIN (pack))
17872 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
17874 TREE_VEC_ELT (TREE_TYPE (pack), i - start) =
17875 TMPL_ARG (targs, level, idx);
17879 /* Verify that the results of unification with the parameter packs
17880 produce results consistent with what we've seen before, and make
17881 the deduced argument packs available. */
17882 for (pack = packs; pack; pack = TREE_CHAIN (pack))
17884 tree old_pack = TREE_VALUE (pack);
17885 tree new_args = TREE_TYPE (pack);
17886 int i, len = TREE_VEC_LENGTH (new_args);
17888 bool nondeduced_p = false;
17890 /* By default keep the original deduced argument pack.
17891 If necessary, more specific code is going to update the
17892 resulting deduced argument later down in this function. */
17893 template_parm_level_and_index (TREE_PURPOSE (pack), &level, &idx);
17894 TMPL_ARG (targs, level, idx) = old_pack;
17896 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
17897 actually deduce anything. */
17898 for (i = 0; i < len && !nondeduced_p; ++i)
17899 if (TREE_VEC_ELT (new_args, i) == NULL_TREE)
17900 nondeduced_p = true;
17904 if (old_pack && ARGUMENT_PACK_INCOMPLETE_P (old_pack))
17906 /* If we had fewer function args than explicit template args,
17907 just use the explicits. */
17908 tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
17909 int explicit_len = TREE_VEC_LENGTH (explicit_args);
17910 if (len < explicit_len)
17911 new_args = explicit_args;
17917 /* Build the deduced *_ARGUMENT_PACK. */
17918 if (TREE_CODE (TREE_PURPOSE (pack)) == TEMPLATE_PARM_INDEX)
17920 result = make_node (NONTYPE_ARGUMENT_PACK);
17921 TREE_TYPE (result) =
17922 TREE_TYPE (TEMPLATE_PARM_DECL (TREE_PURPOSE (pack)));
17923 TREE_CONSTANT (result) = 1;
17926 result = cxx_make_type (TYPE_ARGUMENT_PACK);
17928 SET_ARGUMENT_PACK_ARGS (result, new_args);
17930 /* Note the deduced argument packs for this parameter
17932 TMPL_ARG (targs, level, idx) = result;
17934 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack)
17935 && (ARGUMENT_PACK_ARGS (old_pack)
17936 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack)))
17938 /* We only had the explicitly-provided arguments before, but
17939 now we have a complete set of arguments. */
17940 tree explicit_args = ARGUMENT_PACK_EXPLICIT_ARGS (old_pack);
17942 SET_ARGUMENT_PACK_ARGS (old_pack, new_args);
17943 ARGUMENT_PACK_INCOMPLETE_P (old_pack) = 1;
17944 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack) = explicit_args;
17948 tree bad_old_arg = NULL_TREE, bad_new_arg = NULL_TREE;
17949 tree old_args = ARGUMENT_PACK_ARGS (old_pack);
17951 if (!comp_template_args_with_info (old_args, new_args,
17952 &bad_old_arg, &bad_new_arg))
17953 /* Inconsistent unification of this parameter pack. */
17954 return unify_parameter_pack_inconsistent (explain_p,
17960 return unify_success (explain_p);
17963 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
17964 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
17965 parameters and return value are as for unify. */
17968 unify_array_domain (tree tparms, tree targs,
17969 tree parm_dom, tree arg_dom,
17977 /* Our representation of array types uses "N - 1" as the
17978 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
17979 not an integer constant. We cannot unify arbitrarily
17980 complex expressions, so we eliminate the MINUS_EXPRs
17982 parm_max = TYPE_MAX_VALUE (parm_dom);
17983 parm_cst = TREE_CODE (parm_max) == INTEGER_CST;
17986 gcc_assert (TREE_CODE (parm_max) == MINUS_EXPR);
17987 parm_max = TREE_OPERAND (parm_max, 0);
17989 arg_max = TYPE_MAX_VALUE (arg_dom);
17990 arg_cst = TREE_CODE (arg_max) == INTEGER_CST;
17993 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
17994 trying to unify the type of a variable with the type
17995 of a template parameter. For example:
17997 template <unsigned int N>
17998 void f (char (&) [N]);
18005 Here, the type of the ARG will be "int [g(i)]", and
18006 may be a SAVE_EXPR, etc. */
18007 if (TREE_CODE (arg_max) != MINUS_EXPR)
18008 return unify_vla_arg (explain_p, arg_dom);
18009 arg_max = TREE_OPERAND (arg_max, 0);
18012 /* If only one of the bounds used a MINUS_EXPR, compensate
18013 by adding one to the other bound. */
18014 if (parm_cst && !arg_cst)
18015 parm_max = fold_build2_loc (input_location, PLUS_EXPR,
18019 else if (arg_cst && !parm_cst)
18020 arg_max = fold_build2_loc (input_location, PLUS_EXPR,
18025 return unify (tparms, targs, parm_max, arg_max,
18026 UNIFY_ALLOW_INTEGER, explain_p);
18029 /* Deduce the value of template parameters. TPARMS is the (innermost)
18030 set of template parameters to a template. TARGS is the bindings
18031 for those template parameters, as determined thus far; TARGS may
18032 include template arguments for outer levels of template parameters
18033 as well. PARM is a parameter to a template function, or a
18034 subcomponent of that parameter; ARG is the corresponding argument.
18035 This function attempts to match PARM with ARG in a manner
18036 consistent with the existing assignments in TARGS. If more values
18037 are deduced, then TARGS is updated.
18039 Returns 0 if the type deduction succeeds, 1 otherwise. The
18040 parameter STRICT is a bitwise or of the following flags:
18043 Require an exact match between PARM and ARG.
18044 UNIFY_ALLOW_MORE_CV_QUAL:
18045 Allow the deduced ARG to be more cv-qualified (by qualification
18046 conversion) than ARG.
18047 UNIFY_ALLOW_LESS_CV_QUAL:
18048 Allow the deduced ARG to be less cv-qualified than ARG.
18049 UNIFY_ALLOW_DERIVED:
18050 Allow the deduced ARG to be a template base class of ARG,
18051 or a pointer to a template base class of the type pointed to by
18053 UNIFY_ALLOW_INTEGER:
18054 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
18055 case for more information.
18056 UNIFY_ALLOW_OUTER_LEVEL:
18057 This is the outermost level of a deduction. Used to determine validity
18058 of qualification conversions. A valid qualification conversion must
18059 have const qualified pointers leading up to the inner type which
18060 requires additional CV quals, except at the outer level, where const
18061 is not required [conv.qual]. It would be normal to set this flag in
18062 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
18063 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
18064 This is the outermost level of a deduction, and PARM can be more CV
18065 qualified at this point.
18066 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
18067 This is the outermost level of a deduction, and PARM can be less CV
18068 qualified at this point. */
18071 unify (tree tparms, tree targs, tree parm, tree arg, int strict,
18077 int strict_in = strict;
18079 /* I don't think this will do the right thing with respect to types.
18080 But the only case I've seen it in so far has been array bounds, where
18081 signedness is the only information lost, and I think that will be
18083 while (TREE_CODE (parm) == NOP_EXPR)
18084 parm = TREE_OPERAND (parm, 0);
18086 if (arg == error_mark_node)
18087 return unify_invalid (explain_p);
18088 if (arg == unknown_type_node
18089 || arg == init_list_type_node)
18090 /* We can't deduce anything from this, but we might get all the
18091 template args from other function args. */
18092 return unify_success (explain_p);
18094 /* If PARM uses template parameters, then we can't bail out here,
18095 even if ARG == PARM, since we won't record unifications for the
18096 template parameters. We might need them if we're trying to
18097 figure out which of two things is more specialized. */
18098 if (arg == parm && !uses_template_parms (parm))
18099 return unify_success (explain_p);
18101 /* Handle init lists early, so the rest of the function can assume
18102 we're dealing with a type. */
18103 if (BRACE_ENCLOSED_INITIALIZER_P (arg))
18107 tree orig_parm = parm;
18109 /* Replace T with std::initializer_list<T> for deduction. */
18110 if (TREE_CODE (parm) == TEMPLATE_TYPE_PARM
18111 && flag_deduce_init_list)
18112 parm = listify (parm);
18114 if (!is_std_init_list (parm)
18115 && TREE_CODE (parm) != ARRAY_TYPE)
18116 /* We can only deduce from an initializer list argument if the
18117 parameter is std::initializer_list or an array; otherwise this
18118 is a non-deduced context. */
18119 return unify_success (explain_p);
18121 if (TREE_CODE (parm) == ARRAY_TYPE)
18122 elttype = TREE_TYPE (parm);
18125 elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm), 0);
18126 /* Deduction is defined in terms of a single type, so just punt
18127 on the (bizarre) std::initializer_list<T...>. */
18128 if (PACK_EXPANSION_P (elttype))
18129 return unify_success (explain_p);
18132 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg), i, elt)
18134 int elt_strict = strict;
18136 if (elt == error_mark_node)
18137 return unify_invalid (explain_p);
18139 if (!BRACE_ENCLOSED_INITIALIZER_P (elt))
18141 tree type = TREE_TYPE (elt);
18142 if (type == error_mark_node)
18143 return unify_invalid (explain_p);
18144 /* It should only be possible to get here for a call. */
18145 gcc_assert (elt_strict & UNIFY_ALLOW_OUTER_LEVEL);
18146 elt_strict |= maybe_adjust_types_for_deduction
18147 (DEDUCE_CALL, &elttype, &type, elt);
18151 RECUR_AND_CHECK_FAILURE (tparms, targs, elttype, elt, elt_strict,
18155 if (TREE_CODE (parm) == ARRAY_TYPE
18156 && deducible_array_bound (TYPE_DOMAIN (parm)))
18158 /* Also deduce from the length of the initializer list. */
18159 tree max = size_int (CONSTRUCTOR_NELTS (arg));
18160 tree idx = compute_array_index_type (NULL_TREE, max, tf_none);
18161 if (idx == error_mark_node)
18162 return unify_invalid (explain_p);
18163 return unify_array_domain (tparms, targs, TYPE_DOMAIN (parm),
18167 /* If the std::initializer_list<T> deduction worked, replace the
18168 deduced A with std::initializer_list<A>. */
18169 if (orig_parm != parm)
18171 idx = TEMPLATE_TYPE_IDX (orig_parm);
18172 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
18173 targ = listify (targ);
18174 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = targ;
18176 return unify_success (explain_p);
18179 /* Immediately reject some pairs that won't unify because of
18180 cv-qualification mismatches. */
18181 if (TREE_CODE (arg) == TREE_CODE (parm)
18183 /* It is the elements of the array which hold the cv quals of an array
18184 type, and the elements might be template type parms. We'll check
18185 when we recurse. */
18186 && TREE_CODE (arg) != ARRAY_TYPE
18187 /* We check the cv-qualifiers when unifying with template type
18188 parameters below. We want to allow ARG `const T' to unify with
18189 PARM `T' for example, when computing which of two templates
18190 is more specialized, for example. */
18191 && TREE_CODE (arg) != TEMPLATE_TYPE_PARM
18192 && !check_cv_quals_for_unify (strict_in, arg, parm))
18193 return unify_cv_qual_mismatch (explain_p, parm, arg);
18195 if (!(strict & UNIFY_ALLOW_OUTER_LEVEL)
18196 && TYPE_P (parm) && !CP_TYPE_CONST_P (parm))
18197 strict &= ~UNIFY_ALLOW_MORE_CV_QUAL;
18198 strict &= ~UNIFY_ALLOW_OUTER_LEVEL;
18199 strict &= ~UNIFY_ALLOW_DERIVED;
18200 strict &= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL;
18201 strict &= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL;
18203 switch (TREE_CODE (parm))
18205 case TYPENAME_TYPE:
18207 case UNBOUND_CLASS_TEMPLATE:
18208 /* In a type which contains a nested-name-specifier, template
18209 argument values cannot be deduced for template parameters used
18210 within the nested-name-specifier. */
18211 return unify_success (explain_p);
18213 case TEMPLATE_TYPE_PARM:
18214 case TEMPLATE_TEMPLATE_PARM:
18215 case BOUND_TEMPLATE_TEMPLATE_PARM:
18216 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
18217 if (error_operand_p (tparm))
18218 return unify_invalid (explain_p);
18220 if (TEMPLATE_TYPE_LEVEL (parm)
18221 != template_decl_level (tparm))
18222 /* The PARM is not one we're trying to unify. Just check
18223 to see if it matches ARG. */
18225 if (TREE_CODE (arg) == TREE_CODE (parm)
18226 && (is_auto (parm) ? is_auto (arg)
18227 : same_type_p (parm, arg)))
18228 return unify_success (explain_p);
18230 return unify_type_mismatch (explain_p, parm, arg);
18232 idx = TEMPLATE_TYPE_IDX (parm);
18233 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
18234 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, idx));
18235 if (error_operand_p (tparm))
18236 return unify_invalid (explain_p);
18238 /* Check for mixed types and values. */
18239 if ((TREE_CODE (parm) == TEMPLATE_TYPE_PARM
18240 && TREE_CODE (tparm) != TYPE_DECL)
18241 || (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
18242 && TREE_CODE (tparm) != TEMPLATE_DECL))
18243 gcc_unreachable ();
18245 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
18247 /* ARG must be constructed from a template class or a template
18248 template parameter. */
18249 if (TREE_CODE (arg) != BOUND_TEMPLATE_TEMPLATE_PARM
18250 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg))
18251 return unify_template_deduction_failure (explain_p, parm, arg);
18253 tree parmvec = TYPE_TI_ARGS (parm);
18254 /* An alias template name is never deduced. */
18255 if (TYPE_ALIAS_P (arg))
18256 arg = strip_typedefs (arg);
18257 tree argvec = INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg));
18258 tree full_argvec = add_to_template_args (targs, argvec);
18260 = DECL_INNERMOST_TEMPLATE_PARMS
18261 (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (parm));
18263 int parm_variadic_p = 0;
18265 /* The resolution to DR150 makes clear that default
18266 arguments for an N-argument may not be used to bind T
18267 to a template template parameter with fewer than N
18268 parameters. It is not safe to permit the binding of
18269 default arguments as an extension, as that may change
18270 the meaning of a conforming program. Consider:
18272 struct Dense { static const unsigned int dim = 1; };
18274 template <template <typename> class View,
18276 void operator+(float, View<Block> const&);
18278 template <typename Block,
18279 unsigned int Dim = Block::dim>
18280 struct Lvalue_proxy { operator float() const; };
18284 Lvalue_proxy<Dense> p;
18289 Here, if Lvalue_proxy is permitted to bind to View, then
18290 the global operator+ will be used; if they are not, the
18291 Lvalue_proxy will be converted to float. */
18292 if (coerce_template_parms (parm_parms,
18294 TYPE_TI_TEMPLATE (parm),
18296 ? tf_warning_or_error
18298 /*require_all_args=*/true,
18299 /*use_default_args=*/false)
18300 == error_mark_node)
18303 /* Deduce arguments T, i from TT<T> or TT<i>.
18304 We check each element of PARMVEC and ARGVEC individually
18305 rather than the whole TREE_VEC since they can have
18306 different number of elements. */
18308 parmvec = expand_template_argument_pack (parmvec);
18309 argvec = expand_template_argument_pack (argvec);
18311 len = TREE_VEC_LENGTH (parmvec);
18313 /* Check if the parameters end in a pack, making them
18316 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec, len - 1)))
18317 parm_variadic_p = 1;
18319 for (i = 0; i < len - parm_variadic_p; ++i)
18320 /* If the template argument list of P contains a pack
18321 expansion that is not the last template argument, the
18322 entire template argument list is a non-deduced
18324 if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec, i)))
18325 return unify_success (explain_p);
18327 if (TREE_VEC_LENGTH (argvec) < len - parm_variadic_p)
18328 return unify_too_few_arguments (explain_p,
18329 TREE_VEC_LENGTH (argvec), len);
18331 for (i = 0; i < len - parm_variadic_p; ++i)
18333 RECUR_AND_CHECK_FAILURE (tparms, targs,
18334 TREE_VEC_ELT (parmvec, i),
18335 TREE_VEC_ELT (argvec, i),
18336 UNIFY_ALLOW_NONE, explain_p);
18339 if (parm_variadic_p
18340 && unify_pack_expansion (tparms, targs,
18343 /*subr=*/true, explain_p))
18346 arg = TYPE_TI_TEMPLATE (arg);
18348 /* Fall through to deduce template name. */
18351 if (TREE_CODE (parm) == TEMPLATE_TEMPLATE_PARM
18352 || TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
18354 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
18356 /* Simple cases: Value already set, does match or doesn't. */
18357 if (targ != NULL_TREE && template_args_equal (targ, arg))
18358 return unify_success (explain_p);
18360 return unify_inconsistency (explain_p, parm, targ, arg);
18364 /* If PARM is `const T' and ARG is only `int', we don't have
18365 a match unless we are allowing additional qualification.
18366 If ARG is `const int' and PARM is just `T' that's OK;
18367 that binds `const int' to `T'. */
18368 if (!check_cv_quals_for_unify (strict_in | UNIFY_ALLOW_LESS_CV_QUAL,
18370 return unify_cv_qual_mismatch (explain_p, parm, arg);
18372 /* Consider the case where ARG is `const volatile int' and
18373 PARM is `const T'. Then, T should be `volatile int'. */
18374 arg = cp_build_qualified_type_real
18375 (arg, cp_type_quals (arg) & ~cp_type_quals (parm), tf_none);
18376 if (arg == error_mark_node)
18377 return unify_invalid (explain_p);
18379 /* Simple cases: Value already set, does match or doesn't. */
18380 if (targ != NULL_TREE && same_type_p (targ, arg))
18381 return unify_success (explain_p);
18383 return unify_inconsistency (explain_p, parm, targ, arg);
18385 /* Make sure that ARG is not a variable-sized array. (Note
18386 that were talking about variable-sized arrays (like
18387 `int[n]'), rather than arrays of unknown size (like
18388 `int[]').) We'll get very confused by such a type since
18389 the bound of the array is not constant, and therefore
18390 not mangleable. Besides, such types are not allowed in
18391 ISO C++, so we can do as we please here. We do allow
18392 them for 'auto' deduction, since that isn't ABI-exposed. */
18393 if (!is_auto (parm) && variably_modified_type_p (arg, NULL_TREE))
18394 return unify_vla_arg (explain_p, arg);
18396 /* Strip typedefs as in convert_template_argument. */
18397 arg = canonicalize_type_argument (arg, tf_none);
18400 /* If ARG is a parameter pack or an expansion, we cannot unify
18401 against it unless PARM is also a parameter pack. */
18402 if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
18403 && !template_parameter_pack_p (parm))
18404 return unify_parameter_pack_mismatch (explain_p, parm, arg);
18406 /* If the argument deduction results is a METHOD_TYPE,
18407 then there is a problem.
18408 METHOD_TYPE doesn't map to any real C++ type the result of
18409 the deduction can not be of that type. */
18410 if (TREE_CODE (arg) == METHOD_TYPE)
18411 return unify_method_type_error (explain_p, arg);
18413 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
18414 return unify_success (explain_p);
18416 case TEMPLATE_PARM_INDEX:
18417 tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
18418 if (error_operand_p (tparm))
18419 return unify_invalid (explain_p);
18421 if (TEMPLATE_PARM_LEVEL (parm)
18422 != template_decl_level (tparm))
18424 /* The PARM is not one we're trying to unify. Just check
18425 to see if it matches ARG. */
18426 int result = !(TREE_CODE (arg) == TREE_CODE (parm)
18427 && cp_tree_equal (parm, arg));
18429 unify_expression_unequal (explain_p, parm, arg);
18433 idx = TEMPLATE_PARM_IDX (parm);
18434 targ = TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx);
18438 int x = !cp_tree_equal (targ, arg);
18440 unify_inconsistency (explain_p, parm, targ, arg);
18444 /* [temp.deduct.type] If, in the declaration of a function template
18445 with a non-type template-parameter, the non-type
18446 template-parameter is used in an expression in the function
18447 parameter-list and, if the corresponding template-argument is
18448 deduced, the template-argument type shall match the type of the
18449 template-parameter exactly, except that a template-argument
18450 deduced from an array bound may be of any integral type.
18451 The non-type parameter might use already deduced type parameters. */
18452 tparm = tsubst (TREE_TYPE (parm), targs, 0, NULL_TREE);
18453 if (!TREE_TYPE (arg))
18454 /* Template-parameter dependent expression. Just accept it for now.
18455 It will later be processed in convert_template_argument. */
18457 else if (same_type_p (TREE_TYPE (arg), tparm))
18459 else if ((strict & UNIFY_ALLOW_INTEGER)
18460 && CP_INTEGRAL_TYPE_P (tparm))
18461 /* Convert the ARG to the type of PARM; the deduced non-type
18462 template argument must exactly match the types of the
18463 corresponding parameter. */
18464 arg = fold (build_nop (tparm, arg));
18465 else if (uses_template_parms (tparm))
18466 /* We haven't deduced the type of this parameter yet. Try again
18468 return unify_success (explain_p);
18470 return unify_type_mismatch (explain_p, tparm, TREE_TYPE (arg));
18472 /* If ARG is a parameter pack or an expansion, we cannot unify
18473 against it unless PARM is also a parameter pack. */
18474 if ((template_parameter_pack_p (arg) || PACK_EXPANSION_P (arg))
18475 && !TEMPLATE_PARM_PARAMETER_PACK (parm))
18476 return unify_parameter_pack_mismatch (explain_p, parm, arg);
18478 arg = strip_typedefs_expr (arg);
18479 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs), idx) = arg;
18480 return unify_success (explain_p);
18484 /* A pointer-to-member constant can be unified only with
18485 another constant. */
18486 if (TREE_CODE (arg) != PTRMEM_CST)
18487 return unify_ptrmem_cst_mismatch (explain_p, parm, arg);
18489 /* Just unify the class member. It would be useless (and possibly
18490 wrong, depending on the strict flags) to unify also
18491 PTRMEM_CST_CLASS, because we want to be sure that both parm and
18492 arg refer to the same variable, even if through different
18493 classes. For instance:
18495 struct A { int x; };
18498 Unification of &A::x and &B::x must succeed. */
18499 return unify (tparms, targs, PTRMEM_CST_MEMBER (parm),
18500 PTRMEM_CST_MEMBER (arg), strict, explain_p);
18505 if (!TYPE_PTR_P (arg))
18506 return unify_type_mismatch (explain_p, parm, arg);
18508 /* [temp.deduct.call]
18510 A can be another pointer or pointer to member type that can
18511 be converted to the deduced A via a qualification
18512 conversion (_conv.qual_).
18514 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
18515 This will allow for additional cv-qualification of the
18516 pointed-to types if appropriate. */
18518 if (TREE_CODE (TREE_TYPE (arg)) == RECORD_TYPE)
18519 /* The derived-to-base conversion only persists through one
18520 level of pointers. */
18521 strict |= (strict_in & UNIFY_ALLOW_DERIVED);
18523 return unify (tparms, targs, TREE_TYPE (parm),
18524 TREE_TYPE (arg), strict, explain_p);
18527 case REFERENCE_TYPE:
18528 if (TREE_CODE (arg) != REFERENCE_TYPE)
18529 return unify_type_mismatch (explain_p, parm, arg);
18530 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
18531 strict & UNIFY_ALLOW_MORE_CV_QUAL, explain_p);
18534 if (TREE_CODE (arg) != ARRAY_TYPE)
18535 return unify_type_mismatch (explain_p, parm, arg);
18536 if ((TYPE_DOMAIN (parm) == NULL_TREE)
18537 != (TYPE_DOMAIN (arg) == NULL_TREE))
18538 return unify_type_mismatch (explain_p, parm, arg);
18539 RECUR_AND_CHECK_FAILURE (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
18540 strict & UNIFY_ALLOW_MORE_CV_QUAL, explain_p);
18541 if (TYPE_DOMAIN (parm) != NULL_TREE)
18542 return unify_array_domain (tparms, targs, TYPE_DOMAIN (parm),
18543 TYPE_DOMAIN (arg), explain_p);
18544 return unify_success (explain_p);
18551 case ENUMERAL_TYPE:
18554 if (TREE_CODE (arg) != TREE_CODE (parm))
18555 return unify_type_mismatch (explain_p, parm, arg);
18557 /* We have already checked cv-qualification at the top of the
18559 if (!same_type_ignoring_top_level_qualifiers_p (arg, parm))
18560 return unify_type_mismatch (explain_p, parm, arg);
18562 /* As far as unification is concerned, this wins. Later checks
18563 will invalidate it if necessary. */
18564 return unify_success (explain_p);
18566 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
18567 /* Type INTEGER_CST can come from ordinary constant template args. */
18569 while (TREE_CODE (arg) == NOP_EXPR)
18570 arg = TREE_OPERAND (arg, 0);
18572 if (TREE_CODE (arg) != INTEGER_CST)
18573 return unify_template_argument_mismatch (explain_p, parm, arg);
18574 return (tree_int_cst_equal (parm, arg)
18575 ? unify_success (explain_p)
18576 : unify_template_argument_mismatch (explain_p, parm, arg));
18580 int i, len, argslen;
18581 int parm_variadic_p = 0;
18583 if (TREE_CODE (arg) != TREE_VEC)
18584 return unify_template_argument_mismatch (explain_p, parm, arg);
18586 len = TREE_VEC_LENGTH (parm);
18587 argslen = TREE_VEC_LENGTH (arg);
18589 /* Check for pack expansions in the parameters. */
18590 for (i = 0; i < len; ++i)
18592 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm, i)))
18595 /* We can unify against something with a trailing
18597 parm_variadic_p = 1;
18599 /* [temp.deduct.type]/9: If the template argument list of
18600 P contains a pack expansion that is not the last
18601 template argument, the entire template argument list
18602 is a non-deduced context. */
18603 return unify_success (explain_p);
18607 /* If we don't have enough arguments to satisfy the parameters
18608 (not counting the pack expression at the end), or we have
18609 too many arguments for a parameter list that doesn't end in
18610 a pack expression, we can't unify. */
18611 if (parm_variadic_p
18612 ? argslen < len - parm_variadic_p
18614 return unify_arity (explain_p, TREE_VEC_LENGTH (arg), len);
18616 /* Unify all of the parameters that precede the (optional)
18617 pack expression. */
18618 for (i = 0; i < len - parm_variadic_p; ++i)
18620 RECUR_AND_CHECK_FAILURE (tparms, targs,
18621 TREE_VEC_ELT (parm, i),
18622 TREE_VEC_ELT (arg, i),
18623 UNIFY_ALLOW_NONE, explain_p);
18625 if (parm_variadic_p)
18626 return unify_pack_expansion (tparms, targs, parm, arg,
18628 /*subr=*/true, explain_p);
18629 return unify_success (explain_p);
18634 if (TREE_CODE (arg) != TREE_CODE (parm))
18635 return unify_type_mismatch (explain_p, parm, arg);
18637 if (TYPE_PTRMEMFUNC_P (parm))
18639 if (!TYPE_PTRMEMFUNC_P (arg))
18640 return unify_type_mismatch (explain_p, parm, arg);
18642 return unify (tparms, targs,
18643 TYPE_PTRMEMFUNC_FN_TYPE (parm),
18644 TYPE_PTRMEMFUNC_FN_TYPE (arg),
18645 strict, explain_p);
18647 else if (TYPE_PTRMEMFUNC_P (arg))
18648 return unify_type_mismatch (explain_p, parm, arg);
18650 if (CLASSTYPE_TEMPLATE_INFO (parm))
18652 tree t = NULL_TREE;
18654 if (strict_in & UNIFY_ALLOW_DERIVED)
18656 /* First, we try to unify the PARM and ARG directly. */
18657 t = try_class_unification (tparms, targs,
18658 parm, arg, explain_p);
18662 /* Fallback to the special case allowed in
18663 [temp.deduct.call]:
18665 If P is a class, and P has the form
18666 template-id, then A can be a derived class of
18667 the deduced A. Likewise, if P is a pointer to
18668 a class of the form template-id, A can be a
18669 pointer to a derived class pointed to by the
18671 enum template_base_result r;
18672 r = get_template_base (tparms, targs, parm, arg,
18676 return unify_no_common_base (explain_p, r, parm, arg);
18679 else if (CLASSTYPE_TEMPLATE_INFO (arg)
18680 && (CLASSTYPE_TI_TEMPLATE (parm)
18681 == CLASSTYPE_TI_TEMPLATE (arg)))
18682 /* Perhaps PARM is something like S<U> and ARG is S<int>.
18683 Then, we should unify `int' and `U'. */
18686 /* There's no chance of unification succeeding. */
18687 return unify_type_mismatch (explain_p, parm, arg);
18689 return unify (tparms, targs, CLASSTYPE_TI_ARGS (parm),
18690 CLASSTYPE_TI_ARGS (t), UNIFY_ALLOW_NONE, explain_p);
18692 else if (!same_type_ignoring_top_level_qualifiers_p (parm, arg))
18693 return unify_type_mismatch (explain_p, parm, arg);
18694 return unify_success (explain_p);
18697 case FUNCTION_TYPE:
18699 unsigned int nargs;
18704 if (TREE_CODE (arg) != TREE_CODE (parm))
18705 return unify_type_mismatch (explain_p, parm, arg);
18707 /* CV qualifications for methods can never be deduced, they must
18708 match exactly. We need to check them explicitly here,
18709 because type_unification_real treats them as any other
18710 cv-qualified parameter. */
18711 if (TREE_CODE (parm) == METHOD_TYPE
18712 && (!check_cv_quals_for_unify
18714 class_of_this_parm (arg),
18715 class_of_this_parm (parm))))
18716 return unify_cv_qual_mismatch (explain_p, parm, arg);
18718 RECUR_AND_CHECK_FAILURE (tparms, targs, TREE_TYPE (parm),
18719 TREE_TYPE (arg), UNIFY_ALLOW_NONE, explain_p);
18721 nargs = list_length (TYPE_ARG_TYPES (arg));
18722 args = XALLOCAVEC (tree, nargs);
18723 for (a = TYPE_ARG_TYPES (arg), i = 0;
18724 a != NULL_TREE && a != void_list_node;
18725 a = TREE_CHAIN (a), ++i)
18726 args[i] = TREE_VALUE (a);
18729 return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
18730 args, nargs, 1, DEDUCE_EXACT,
18731 LOOKUP_NORMAL, NULL, explain_p);
18735 /* Unify a pointer to member with a pointer to member function, which
18736 deduces the type of the member as a function type. */
18737 if (TYPE_PTRMEMFUNC_P (arg))
18739 /* Check top-level cv qualifiers */
18740 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE, arg, parm))
18741 return unify_cv_qual_mismatch (explain_p, parm, arg);
18743 RECUR_AND_CHECK_FAILURE (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
18744 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg),
18745 UNIFY_ALLOW_NONE, explain_p);
18747 /* Determine the type of the function we are unifying against. */
18748 tree fntype = static_fn_type (arg);
18750 return unify (tparms, targs, TREE_TYPE (parm), fntype, strict, explain_p);
18753 if (TREE_CODE (arg) != OFFSET_TYPE)
18754 return unify_type_mismatch (explain_p, parm, arg);
18755 RECUR_AND_CHECK_FAILURE (tparms, targs, TYPE_OFFSET_BASETYPE (parm),
18756 TYPE_OFFSET_BASETYPE (arg),
18757 UNIFY_ALLOW_NONE, explain_p);
18758 return unify (tparms, targs, TREE_TYPE (parm), TREE_TYPE (arg),
18759 strict, explain_p);
18762 if (DECL_TEMPLATE_PARM_P (parm))
18763 return unify (tparms, targs, DECL_INITIAL (parm), arg, strict, explain_p);
18764 if (arg != scalar_constant_value (parm))
18765 return unify_template_argument_mismatch (explain_p, parm, arg);
18766 return unify_success (explain_p);
18769 case TEMPLATE_DECL:
18770 /* Matched cases are handled by the ARG == PARM test above. */
18771 return unify_template_argument_mismatch (explain_p, parm, arg);
18774 /* A non-type template parameter that is a variable should be a
18775 an integral constant, in which case, it whould have been
18776 folded into its (constant) value. So we should not be getting
18777 a variable here. */
18778 gcc_unreachable ();
18780 case TYPE_ARGUMENT_PACK:
18781 case NONTYPE_ARGUMENT_PACK:
18782 return unify (tparms, targs, ARGUMENT_PACK_ARGS (parm),
18783 ARGUMENT_PACK_ARGS (arg), strict, explain_p);
18786 case DECLTYPE_TYPE:
18787 case UNDERLYING_TYPE:
18788 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
18789 or UNDERLYING_TYPE nodes. */
18790 return unify_success (explain_p);
18793 /* Unification fails if we hit an error node. */
18794 return unify_invalid (explain_p);
18797 if (REFERENCE_REF_P (parm))
18799 if (REFERENCE_REF_P (arg))
18800 arg = TREE_OPERAND (arg, 0);
18801 return unify (tparms, targs, TREE_OPERAND (parm, 0), arg,
18802 strict, explain_p);
18807 /* An unresolved overload is a nondeduced context. */
18808 if (is_overloaded_fn (parm) || type_unknown_p (parm))
18809 return unify_success (explain_p);
18810 gcc_assert (EXPR_P (parm) || TREE_CODE (parm) == TRAIT_EXPR);
18812 /* We must be looking at an expression. This can happen with
18816 void foo(S<I>, S<I + 2>);
18818 This is a "nondeduced context":
18822 The nondeduced contexts are:
18824 --A type that is a template-id in which one or more of
18825 the template-arguments is an expression that references
18826 a template-parameter.
18828 In these cases, we assume deduction succeeded, but don't
18829 actually infer any unifications. */
18831 if (!uses_template_parms (parm)
18832 && !template_args_equal (parm, arg))
18833 return unify_expression_unequal (explain_p, parm, arg);
18835 return unify_success (explain_p);
18838 #undef RECUR_AND_CHECK_FAILURE
18840 /* Note that DECL can be defined in this translation unit, if
18844 mark_definable (tree decl)
18847 DECL_NOT_REALLY_EXTERN (decl) = 1;
18848 FOR_EACH_CLONE (clone, decl)
18849 DECL_NOT_REALLY_EXTERN (clone) = 1;
18852 /* Called if RESULT is explicitly instantiated, or is a member of an
18853 explicitly instantiated class. */
18856 mark_decl_instantiated (tree result, int extern_p)
18858 SET_DECL_EXPLICIT_INSTANTIATION (result);
18860 /* If this entity has already been written out, it's too late to
18861 make any modifications. */
18862 if (TREE_ASM_WRITTEN (result))
18865 /* For anonymous namespace we don't need to do anything. */
18866 if (decl_anon_ns_mem_p (result))
18868 gcc_assert (!TREE_PUBLIC (result));
18872 if (TREE_CODE (result) != FUNCTION_DECL)
18873 /* The TREE_PUBLIC flag for function declarations will have been
18874 set correctly by tsubst. */
18875 TREE_PUBLIC (result) = 1;
18877 /* This might have been set by an earlier implicit instantiation. */
18878 DECL_COMDAT (result) = 0;
18881 DECL_NOT_REALLY_EXTERN (result) = 0;
18884 mark_definable (result);
18885 mark_needed (result);
18886 /* Always make artificials weak. */
18887 if (DECL_ARTIFICIAL (result) && flag_weak)
18888 comdat_linkage (result);
18889 /* For WIN32 we also want to put explicit instantiations in
18890 linkonce sections. */
18891 else if (TREE_PUBLIC (result))
18892 maybe_make_one_only (result);
18895 /* If EXTERN_P, then this function will not be emitted -- unless
18896 followed by an explicit instantiation, at which point its linkage
18897 will be adjusted. If !EXTERN_P, then this function will be
18898 emitted here. In neither circumstance do we want
18899 import_export_decl to adjust the linkage. */
18900 DECL_INTERFACE_KNOWN (result) = 1;
18903 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
18904 important template arguments. If any are missing, we check whether
18905 they're important by using error_mark_node for substituting into any
18906 args that were used for partial ordering (the ones between ARGS and END)
18907 and seeing if it bubbles up. */
18910 check_undeduced_parms (tree targs, tree args, tree end)
18912 bool found = false;
18914 for (i = TREE_VEC_LENGTH (targs) - 1; i >= 0; --i)
18915 if (TREE_VEC_ELT (targs, i) == NULL_TREE)
18918 TREE_VEC_ELT (targs, i) = error_mark_node;
18922 tree substed = tsubst_arg_types (args, targs, end, tf_none, NULL_TREE);
18923 if (substed == error_mark_node)
18929 /* Given two function templates PAT1 and PAT2, return:
18931 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
18932 -1 if PAT2 is more specialized than PAT1.
18933 0 if neither is more specialized.
18935 LEN indicates the number of parameters we should consider
18936 (defaulted parameters should not be considered).
18938 The 1998 std underspecified function template partial ordering, and
18939 DR214 addresses the issue. We take pairs of arguments, one from
18940 each of the templates, and deduce them against each other. One of
18941 the templates will be more specialized if all the *other*
18942 template's arguments deduce against its arguments and at least one
18943 of its arguments *does* *not* deduce against the other template's
18944 corresponding argument. Deduction is done as for class templates.
18945 The arguments used in deduction have reference and top level cv
18946 qualifiers removed. Iff both arguments were originally reference
18947 types *and* deduction succeeds in both directions, an lvalue reference
18948 wins against an rvalue reference and otherwise the template
18949 with the more cv-qualified argument wins for that pairing (if
18950 neither is more cv-qualified, they both are equal). Unlike regular
18951 deduction, after all the arguments have been deduced in this way,
18952 we do *not* verify the deduced template argument values can be
18953 substituted into non-deduced contexts.
18955 The logic can be a bit confusing here, because we look at deduce1 and
18956 targs1 to see if pat2 is at least as specialized, and vice versa; if we
18957 can find template arguments for pat1 to make arg1 look like arg2, that
18958 means that arg2 is at least as specialized as arg1. */
18961 more_specialized_fn (tree pat1, tree pat2, int len)
18963 tree decl1 = DECL_TEMPLATE_RESULT (pat1);
18964 tree decl2 = DECL_TEMPLATE_RESULT (pat2);
18965 tree targs1 = make_tree_vec (DECL_NTPARMS (pat1));
18966 tree targs2 = make_tree_vec (DECL_NTPARMS (pat2));
18967 tree tparms1 = DECL_INNERMOST_TEMPLATE_PARMS (pat1);
18968 tree tparms2 = DECL_INNERMOST_TEMPLATE_PARMS (pat2);
18969 tree args1 = TYPE_ARG_TYPES (TREE_TYPE (decl1));
18970 tree args2 = TYPE_ARG_TYPES (TREE_TYPE (decl2));
18971 tree origs1, origs2;
18972 bool lose1 = false;
18973 bool lose2 = false;
18975 /* Remove the this parameter from non-static member functions. If
18976 one is a non-static member function and the other is not a static
18977 member function, remove the first parameter from that function
18978 also. This situation occurs for operator functions where we
18979 locate both a member function (with this pointer) and non-member
18980 operator (with explicit first operand). */
18981 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1))
18983 len--; /* LEN is the number of significant arguments for DECL1 */
18984 args1 = TREE_CHAIN (args1);
18985 if (!DECL_STATIC_FUNCTION_P (decl2))
18986 args2 = TREE_CHAIN (args2);
18988 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2))
18990 args2 = TREE_CHAIN (args2);
18991 if (!DECL_STATIC_FUNCTION_P (decl1))
18994 args1 = TREE_CHAIN (args1);
18998 /* If only one is a conversion operator, they are unordered. */
18999 if (DECL_CONV_FN_P (decl1) != DECL_CONV_FN_P (decl2))
19002 /* Consider the return type for a conversion function */
19003 if (DECL_CONV_FN_P (decl1))
19005 args1 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl1)), args1);
19006 args2 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl2)), args2);
19010 processing_template_decl++;
19016 /* Stop when an ellipsis is seen. */
19017 && args1 != NULL_TREE && args2 != NULL_TREE)
19019 tree arg1 = TREE_VALUE (args1);
19020 tree arg2 = TREE_VALUE (args2);
19021 int deduce1, deduce2;
19027 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
19028 && TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
19030 /* When both arguments are pack expansions, we need only
19031 unify the patterns themselves. */
19032 arg1 = PACK_EXPANSION_PATTERN (arg1);
19033 arg2 = PACK_EXPANSION_PATTERN (arg2);
19035 /* This is the last comparison we need to do. */
19039 if (TREE_CODE (arg1) == REFERENCE_TYPE)
19041 ref1 = TYPE_REF_IS_RVALUE (arg1) + 1;
19042 arg1 = TREE_TYPE (arg1);
19043 quals1 = cp_type_quals (arg1);
19046 if (TREE_CODE (arg2) == REFERENCE_TYPE)
19048 ref2 = TYPE_REF_IS_RVALUE (arg2) + 1;
19049 arg2 = TREE_TYPE (arg2);
19050 quals2 = cp_type_quals (arg2);
19053 arg1 = TYPE_MAIN_VARIANT (arg1);
19054 arg2 = TYPE_MAIN_VARIANT (arg2);
19056 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION)
19058 int i, len2 = remaining_arguments (args2);
19059 tree parmvec = make_tree_vec (1);
19060 tree argvec = make_tree_vec (len2);
19063 /* Setup the parameter vector, which contains only ARG1. */
19064 TREE_VEC_ELT (parmvec, 0) = arg1;
19066 /* Setup the argument vector, which contains the remaining
19068 for (i = 0; i < len2; i++, ta = TREE_CHAIN (ta))
19069 TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
19071 deduce1 = (unify_pack_expansion (tparms1, targs1, parmvec,
19072 argvec, DEDUCE_EXACT,
19073 /*subr=*/true, /*explain_p=*/false)
19076 /* We cannot deduce in the other direction, because ARG1 is
19077 a pack expansion but ARG2 is not. */
19080 else if (TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
19082 int i, len1 = remaining_arguments (args1);
19083 tree parmvec = make_tree_vec (1);
19084 tree argvec = make_tree_vec (len1);
19087 /* Setup the parameter vector, which contains only ARG1. */
19088 TREE_VEC_ELT (parmvec, 0) = arg2;
19090 /* Setup the argument vector, which contains the remaining
19092 for (i = 0; i < len1; i++, ta = TREE_CHAIN (ta))
19093 TREE_VEC_ELT (argvec, i) = TREE_VALUE (ta);
19095 deduce2 = (unify_pack_expansion (tparms2, targs2, parmvec,
19096 argvec, DEDUCE_EXACT,
19097 /*subr=*/true, /*explain_p=*/false)
19100 /* We cannot deduce in the other direction, because ARG2 is
19101 a pack expansion but ARG1 is not.*/
19107 /* The normal case, where neither argument is a pack
19109 deduce1 = (unify (tparms1, targs1, arg1, arg2,
19110 UNIFY_ALLOW_NONE, /*explain_p=*/false)
19112 deduce2 = (unify (tparms2, targs2, arg2, arg1,
19113 UNIFY_ALLOW_NONE, /*explain_p=*/false)
19117 /* If we couldn't deduce arguments for tparms1 to make arg1 match
19118 arg2, then arg2 is not as specialized as arg1. */
19124 /* "If, for a given type, deduction succeeds in both directions
19125 (i.e., the types are identical after the transformations above)
19126 and both P and A were reference types (before being replaced with
19127 the type referred to above):
19128 - if the type from the argument template was an lvalue reference and
19129 the type from the parameter template was not, the argument type is
19130 considered to be more specialized than the other; otherwise,
19131 - if the type from the argument template is more cv-qualified
19132 than the type from the parameter template (as described above),
19133 the argument type is considered to be more specialized than the other;
19135 - neither type is more specialized than the other." */
19137 if (deduce1 && deduce2)
19139 if (ref1 && ref2 && ref1 != ref2)
19146 else if (quals1 != quals2 && quals1 >= 0 && quals2 >= 0)
19148 if ((quals1 & quals2) == quals2)
19150 if ((quals1 & quals2) == quals1)
19155 if (lose1 && lose2)
19156 /* We've failed to deduce something in either direction.
19157 These must be unordered. */
19160 if (TREE_CODE (arg1) == TYPE_PACK_EXPANSION
19161 || TREE_CODE (arg2) == TYPE_PACK_EXPANSION)
19162 /* We have already processed all of the arguments in our
19163 handing of the pack expansion type. */
19166 args1 = TREE_CHAIN (args1);
19167 args2 = TREE_CHAIN (args2);
19170 /* "In most cases, all template parameters must have values in order for
19171 deduction to succeed, but for partial ordering purposes a template
19172 parameter may remain without a value provided it is not used in the
19173 types being used for partial ordering."
19175 Thus, if we are missing any of the targs1 we need to substitute into
19176 origs1, then pat2 is not as specialized as pat1. This can happen when
19177 there is a nondeduced context. */
19178 if (!lose2 && check_undeduced_parms (targs1, origs1, args1))
19180 if (!lose1 && check_undeduced_parms (targs2, origs2, args2))
19183 processing_template_decl--;
19185 /* All things being equal, if the next argument is a pack expansion
19186 for one function but not for the other, prefer the
19187 non-variadic function. FIXME this is bogus; see c++/41958. */
19189 && args1 && TREE_VALUE (args1)
19190 && args2 && TREE_VALUE (args2))
19192 lose1 = TREE_CODE (TREE_VALUE (args1)) == TYPE_PACK_EXPANSION;
19193 lose2 = TREE_CODE (TREE_VALUE (args2)) == TYPE_PACK_EXPANSION;
19196 if (lose1 == lose2)
19204 /* Determine which of two partial specializations of TMPL is more
19207 PAT1 is a TREE_LIST whose TREE_VALUE is the TEMPLATE_DECL corresponding
19208 to the first partial specialization. The TREE_PURPOSE is the
19209 innermost set of template parameters for the partial
19210 specialization. PAT2 is similar, but for the second template.
19212 Return 1 if the first partial specialization is more specialized;
19213 -1 if the second is more specialized; 0 if neither is more
19216 See [temp.class.order] for information about determining which of
19217 two templates is more specialized. */
19220 more_specialized_partial_spec (tree tmpl, tree pat1, tree pat2)
19224 bool any_deductions = false;
19226 tree tmpl1 = TREE_VALUE (pat1);
19227 tree tmpl2 = TREE_VALUE (pat2);
19228 tree parms1 = DECL_INNERMOST_TEMPLATE_PARMS (tmpl1);
19229 tree parms2 = DECL_INNERMOST_TEMPLATE_PARMS (tmpl2);
19230 tree specargs1 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl1)));
19231 tree specargs2 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl2)));
19233 /* Just like what happens for functions, if we are ordering between
19234 different template specializations, we may encounter dependent
19235 types in the arguments, and we need our dependency check functions
19236 to behave correctly. */
19237 ++processing_template_decl;
19238 targs = get_partial_spec_bindings (tmpl, parms1, specargs1, specargs2);
19242 any_deductions = true;
19245 targs = get_partial_spec_bindings (tmpl, parms2, specargs2, specargs1);
19249 any_deductions = true;
19251 --processing_template_decl;
19253 /* In the case of a tie where at least one of the templates
19254 has a parameter pack at the end, the template with the most
19255 non-packed parameters wins. */
19258 && (template_args_variadic_p (TREE_PURPOSE (pat1))
19259 || template_args_variadic_p (TREE_PURPOSE (pat2))))
19261 tree args1 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1));
19262 tree args2 = INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2));
19263 int len1 = TREE_VEC_LENGTH (args1);
19264 int len2 = TREE_VEC_LENGTH (args2);
19266 /* We don't count the pack expansion at the end. */
19267 if (template_args_variadic_p (TREE_PURPOSE (pat1)))
19269 if (template_args_variadic_p (TREE_PURPOSE (pat2)))
19274 else if (len1 < len2)
19281 /* Return the template arguments that will produce the function signature
19282 DECL from the function template FN, with the explicit template
19283 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
19284 also match. Return NULL_TREE if no satisfactory arguments could be
19288 get_bindings (tree fn, tree decl, tree explicit_args, bool check_rettype)
19290 int ntparms = DECL_NTPARMS (fn);
19291 tree targs = make_tree_vec (ntparms);
19292 tree decl_type = TREE_TYPE (decl);
19293 tree decl_arg_types;
19295 unsigned int nargs, ix;
19298 gcc_assert (decl != DECL_TEMPLATE_RESULT (fn));
19300 /* Never do unification on the 'this' parameter. */
19301 decl_arg_types = skip_artificial_parms_for (decl,
19302 TYPE_ARG_TYPES (decl_type));
19304 nargs = list_length (decl_arg_types);
19305 args = XALLOCAVEC (tree, nargs);
19306 for (arg = decl_arg_types, ix = 0;
19307 arg != NULL_TREE && arg != void_list_node;
19308 arg = TREE_CHAIN (arg), ++ix)
19309 args[ix] = TREE_VALUE (arg);
19311 if (fn_type_unification (fn, explicit_args, targs,
19313 (check_rettype || DECL_CONV_FN_P (fn)
19314 ? TREE_TYPE (decl_type) : NULL_TREE),
19315 DEDUCE_EXACT, LOOKUP_NORMAL, /*explain_p=*/false,
19317 == error_mark_node)
19323 /* Return the innermost template arguments that, when applied to a partial
19324 specialization of TMPL whose innermost template parameters are
19325 TPARMS, and whose specialization arguments are SPEC_ARGS, yield the
19328 For example, suppose we have:
19330 template <class T, class U> struct S {};
19331 template <class T> struct S<T*, int> {};
19333 Then, suppose we want to get `S<double*, int>'. The TPARMS will be
19334 {T}, the SPEC_ARGS will be {T*, int} and the ARGS will be {double*,
19335 int}. The resulting vector will be {double}, indicating that `T'
19336 is bound to `double'. */
19339 get_partial_spec_bindings (tree tmpl, tree tparms, tree spec_args, tree args)
19341 int i, ntparms = TREE_VEC_LENGTH (tparms);
19343 tree innermost_deduced_args;
19345 innermost_deduced_args = make_tree_vec (ntparms);
19346 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
19348 deduced_args = copy_node (args);
19349 SET_TMPL_ARGS_LEVEL (deduced_args,
19350 TMPL_ARGS_DEPTH (deduced_args),
19351 innermost_deduced_args);
19354 deduced_args = innermost_deduced_args;
19356 if (unify (tparms, deduced_args,
19357 INNERMOST_TEMPLATE_ARGS (spec_args),
19358 INNERMOST_TEMPLATE_ARGS (args),
19359 UNIFY_ALLOW_NONE, /*explain_p=*/false))
19362 for (i = 0; i < ntparms; ++i)
19363 if (! TREE_VEC_ELT (innermost_deduced_args, i))
19366 /* Verify that nondeduced template arguments agree with the type
19367 obtained from argument deduction.
19371 struct A { typedef int X; };
19372 template <class T, class U> struct C {};
19373 template <class T> struct C<T, typename T::X> {};
19375 Then with the instantiation `C<A, int>', we can deduce that
19376 `T' is `A' but unify () does not check whether `typename T::X'
19378 spec_args = tsubst (spec_args, deduced_args, tf_none, NULL_TREE);
19379 spec_args = coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
19381 tf_none, false, false);
19382 if (spec_args == error_mark_node
19383 /* We only need to check the innermost arguments; the other
19384 arguments will always agree. */
19385 || !comp_template_args (INNERMOST_TEMPLATE_ARGS (spec_args),
19386 INNERMOST_TEMPLATE_ARGS (args)))
19389 /* Now that we have bindings for all of the template arguments,
19390 ensure that the arguments deduced for the template template
19391 parameters have compatible template parameter lists. See the use
19392 of template_template_parm_bindings_ok_p in fn_type_unification
19393 for more information. */
19394 if (!template_template_parm_bindings_ok_p (tparms, deduced_args))
19397 return deduced_args;
19400 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
19401 Return the TREE_LIST node with the most specialized template, if
19402 any. If there is no most specialized template, the error_mark_node
19405 Note that this function does not look at, or modify, the
19406 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
19407 returned is one of the elements of INSTANTIATIONS, callers may
19408 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
19409 and retrieve it from the value returned. */
19412 most_specialized_instantiation (tree templates)
19416 ++processing_template_decl;
19419 for (fn = TREE_CHAIN (templates); fn; fn = TREE_CHAIN (fn))
19423 if (get_bindings (TREE_VALUE (champ),
19424 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
19425 NULL_TREE, /*check_ret=*/true))
19428 if (get_bindings (TREE_VALUE (fn),
19429 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
19430 NULL_TREE, /*check_ret=*/true))
19437 /* Equally specialized, move to next function. If there
19438 is no next function, nothing's most specialized. */
19439 fn = TREE_CHAIN (fn);
19447 /* Now verify that champ is better than everything earlier in the
19448 instantiation list. */
19449 for (fn = templates; fn != champ; fn = TREE_CHAIN (fn))
19450 if (get_bindings (TREE_VALUE (champ),
19451 DECL_TEMPLATE_RESULT (TREE_VALUE (fn)),
19452 NULL_TREE, /*check_ret=*/true)
19453 || !get_bindings (TREE_VALUE (fn),
19454 DECL_TEMPLATE_RESULT (TREE_VALUE (champ)),
19455 NULL_TREE, /*check_ret=*/true))
19461 processing_template_decl--;
19464 return error_mark_node;
19469 /* If DECL is a specialization of some template, return the most
19470 general such template. Otherwise, returns NULL_TREE.
19472 For example, given:
19474 template <class T> struct S { template <class U> void f(U); };
19476 if TMPL is `template <class U> void S<int>::f(U)' this will return
19477 the full template. This function will not trace past partial
19478 specializations, however. For example, given in addition:
19480 template <class T> struct S<T*> { template <class U> void f(U); };
19482 if TMPL is `template <class U> void S<int*>::f(U)' this will return
19483 `template <class T> template <class U> S<T*>::f(U)'. */
19486 most_general_template (tree decl)
19488 if (TREE_CODE (decl) != TEMPLATE_DECL)
19490 if (tree tinfo = get_template_info (decl))
19491 decl = TI_TEMPLATE (tinfo);
19492 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
19493 template friend, or a FIELD_DECL for a capture pack. */
19494 if (TREE_CODE (decl) != TEMPLATE_DECL)
19498 /* Look for more and more general templates. */
19499 while (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
19501 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
19502 (See cp-tree.h for details.) */
19503 if (TREE_CODE (DECL_TI_TEMPLATE (decl)) != TEMPLATE_DECL)
19506 if (CLASS_TYPE_P (TREE_TYPE (decl))
19507 && !TYPE_DECL_ALIAS_P (TYPE_NAME (TREE_TYPE (decl)))
19508 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
19511 /* Stop if we run into an explicitly specialized class template. */
19512 if (!DECL_NAMESPACE_SCOPE_P (decl)
19513 && DECL_CONTEXT (decl)
19514 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl)))
19517 decl = DECL_TI_TEMPLATE (decl);
19523 /* True iff the TEMPLATE_DECL tmpl is a partial specialization. */
19526 partial_specialization_p (tree tmpl)
19528 /* Any specialization has DECL_TEMPLATE_SPECIALIZATION. */
19529 if (!DECL_TEMPLATE_SPECIALIZATION (tmpl))
19531 if (!VAR_P (DECL_TEMPLATE_RESULT (tmpl)))
19533 tree t = DECL_TI_TEMPLATE (tmpl);
19534 /* A specialization that fully specializes one of the containing classes is
19535 not a partial specialization. */
19536 return (list_length (DECL_TEMPLATE_PARMS (tmpl))
19537 == list_length (DECL_TEMPLATE_PARMS (t)));
19540 /* If TMPL is a partial specialization, return the arguments for its primary
19544 impartial_args (tree tmpl, tree args)
19546 if (!partial_specialization_p (tmpl))
19549 /* If TMPL is a partial specialization, we need to substitute to get
19550 the args for the primary template. */
19551 return tsubst_template_args (DECL_TI_ARGS (tmpl), args,
19552 tf_warning_or_error, tmpl);
19555 /* Return the most specialized of the template partial specializations
19556 which can produce TARGET, a specialization of some class or variable
19557 template. The value returned is actually a TREE_LIST; the TREE_VALUE is
19558 a TEMPLATE_DECL node corresponding to the partial specialization, while
19559 the TREE_PURPOSE is the set of template arguments that must be
19560 substituted into the template pattern in order to generate TARGET.
19562 If the choice of partial specialization is ambiguous, a diagnostic
19563 is issued, and the error_mark_node is returned. If there are no
19564 partial specializations matching TARGET, then NULL_TREE is
19565 returned, indicating that the primary template should be used. */
19568 most_specialized_partial_spec (tree target, tsubst_flags_t complain)
19570 tree list = NULL_TREE;
19575 tree outer_args = NULL_TREE;
19578 if (TYPE_P (target))
19580 tree tinfo = CLASSTYPE_TEMPLATE_INFO (target);
19581 tmpl = TI_TEMPLATE (tinfo);
19582 args = TI_ARGS (tinfo);
19584 else if (TREE_CODE (target) == TEMPLATE_ID_EXPR)
19586 tmpl = TREE_OPERAND (target, 0);
19587 args = TREE_OPERAND (target, 1);
19589 else if (VAR_P (target))
19591 tree tinfo = DECL_TEMPLATE_INFO (target);
19592 tmpl = TI_TEMPLATE (tinfo);
19593 args = TI_ARGS (tinfo);
19596 gcc_unreachable ();
19598 tree main_tmpl = most_general_template (tmpl);
19600 /* For determining which partial specialization to use, only the
19601 innermost args are interesting. */
19602 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args))
19604 outer_args = strip_innermost_template_args (args, 1);
19605 args = INNERMOST_TEMPLATE_ARGS (args);
19608 for (t = DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl); t; t = TREE_CHAIN (t))
19610 tree partial_spec_args;
19612 tree spec_tmpl = TREE_VALUE (t);
19614 partial_spec_args = TREE_PURPOSE (t);
19616 ++processing_template_decl;
19620 /* Discard the outer levels of args, and then substitute in the
19621 template args from the enclosing class. */
19622 partial_spec_args = INNERMOST_TEMPLATE_ARGS (partial_spec_args);
19623 partial_spec_args = tsubst_template_args
19624 (partial_spec_args, outer_args, tf_none, NULL_TREE);
19626 /* And the same for the partial specialization TEMPLATE_DECL. */
19627 spec_tmpl = tsubst (spec_tmpl, outer_args, tf_none, NULL_TREE);
19630 partial_spec_args =
19631 coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl),
19634 /*require_all_args=*/true,
19635 /*use_default_args=*/true);
19637 --processing_template_decl;
19639 if (partial_spec_args == error_mark_node)
19640 return error_mark_node;
19641 if (spec_tmpl == error_mark_node)
19642 return error_mark_node;
19644 tree parms = DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl);
19645 spec_args = get_partial_spec_bindings (tmpl, parms,
19651 spec_args = add_to_template_args (outer_args, spec_args);
19652 list = tree_cons (spec_args, TREE_VALUE (t), list);
19653 TREE_TYPE (list) = TREE_TYPE (t);
19660 ambiguous_p = false;
19663 t = TREE_CHAIN (t);
19664 for (; t; t = TREE_CHAIN (t))
19666 fate = more_specialized_partial_spec (tmpl, champ, t);
19673 t = TREE_CHAIN (t);
19676 ambiguous_p = true;
19685 for (t = list; t && t != champ; t = TREE_CHAIN (t))
19687 fate = more_specialized_partial_spec (tmpl, champ, t);
19690 ambiguous_p = true;
19698 char *spaces = NULL;
19699 if (!(complain & tf_error))
19700 return error_mark_node;
19701 if (TYPE_P (target))
19702 error ("ambiguous template instantiation for %q#T", target);
19704 error ("ambiguous template instantiation for %q#D", target);
19705 str = ngettext ("candidate is:", "candidates are:", list_length (list));
19706 for (t = list; t; t = TREE_CHAIN (t))
19708 tree subst = build_tree_list (TREE_VALUE (t), TREE_PURPOSE (t));
19709 inform (DECL_SOURCE_LOCATION (TREE_VALUE (t)),
19710 "%s %#S", spaces ? spaces : str, subst);
19711 spaces = spaces ? spaces : get_spaces (str);
19714 return error_mark_node;
19720 /* Explicitly instantiate DECL. */
19723 do_decl_instantiation (tree decl, tree storage)
19725 tree result = NULL_TREE;
19728 if (!decl || decl == error_mark_node)
19729 /* An error occurred, for which grokdeclarator has already issued
19730 an appropriate message. */
19732 else if (! DECL_LANG_SPECIFIC (decl))
19734 error ("explicit instantiation of non-template %q#D", decl);
19738 bool var_templ = (DECL_TEMPLATE_INFO (decl)
19739 && variable_template_p (DECL_TI_TEMPLATE (decl)));
19741 if (VAR_P (decl) && !var_templ)
19743 /* There is an asymmetry here in the way VAR_DECLs and
19744 FUNCTION_DECLs are handled by grokdeclarator. In the case of
19745 the latter, the DECL we get back will be marked as a
19746 template instantiation, and the appropriate
19747 DECL_TEMPLATE_INFO will be set up. This does not happen for
19748 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
19749 should handle VAR_DECLs as it currently handles
19751 if (!DECL_CLASS_SCOPE_P (decl))
19753 error ("%qD is not a static data member of a class template", decl);
19756 result = lookup_field (DECL_CONTEXT (decl), DECL_NAME (decl), 0, false);
19757 if (!result || !VAR_P (result))
19759 error ("no matching template for %qD found", decl);
19762 if (!same_type_p (TREE_TYPE (result), TREE_TYPE (decl)))
19764 error ("type %qT for explicit instantiation %qD does not match "
19765 "declared type %qT", TREE_TYPE (result), decl,
19770 else if (TREE_CODE (decl) != FUNCTION_DECL && !var_templ)
19772 error ("explicit instantiation of %q#D", decl);
19778 /* Check for various error cases. Note that if the explicit
19779 instantiation is valid the RESULT will currently be marked as an
19780 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
19781 until we get here. */
19783 if (DECL_TEMPLATE_SPECIALIZATION (result))
19785 /* DR 259 [temp.spec].
19787 Both an explicit instantiation and a declaration of an explicit
19788 specialization shall not appear in a program unless the explicit
19789 instantiation follows a declaration of the explicit specialization.
19791 For a given set of template parameters, if an explicit
19792 instantiation of a template appears after a declaration of an
19793 explicit specialization for that template, the explicit
19794 instantiation has no effect. */
19797 else if (DECL_EXPLICIT_INSTANTIATION (result))
19801 No program shall explicitly instantiate any template more
19804 We check DECL_NOT_REALLY_EXTERN so as not to complain when
19805 the first instantiation was `extern' and the second is not,
19806 and EXTERN_P for the opposite case. */
19807 if (DECL_NOT_REALLY_EXTERN (result) && !extern_p)
19808 permerror (input_location, "duplicate explicit instantiation of %q#D", result);
19809 /* If an "extern" explicit instantiation follows an ordinary
19810 explicit instantiation, the template is instantiated. */
19814 else if (!DECL_IMPLICIT_INSTANTIATION (result))
19816 error ("no matching template for %qD found", result);
19819 else if (!DECL_TEMPLATE_INFO (result))
19821 permerror (input_location, "explicit instantiation of non-template %q#D", result);
19825 if (storage == NULL_TREE)
19827 else if (storage == ridpointers[(int) RID_EXTERN])
19829 if (!in_system_header_at (input_location) && (cxx_dialect == cxx98))
19830 pedwarn (input_location, OPT_Wpedantic,
19831 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
19836 error ("storage class %qD applied to template instantiation", storage);
19838 check_explicit_instantiation_namespace (result);
19839 mark_decl_instantiated (result, extern_p);
19841 instantiate_decl (result, /*defer_ok=*/1,
19842 /*expl_inst_class_mem_p=*/false);
19846 mark_class_instantiated (tree t, int extern_p)
19848 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t);
19849 SET_CLASSTYPE_INTERFACE_KNOWN (t);
19850 CLASSTYPE_INTERFACE_ONLY (t) = extern_p;
19851 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = extern_p;
19854 CLASSTYPE_DEBUG_REQUESTED (t) = 1;
19855 rest_of_type_compilation (t, 1);
19859 /* Called from do_type_instantiation through binding_table_foreach to
19860 do recursive instantiation for the type bound in ENTRY. */
19862 bt_instantiate_type_proc (binding_entry entry, void *data)
19864 tree storage = *(tree *) data;
19866 if (MAYBE_CLASS_TYPE_P (entry->type)
19867 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry->type)))
19868 do_type_instantiation (TYPE_MAIN_DECL (entry->type), storage, 0);
19871 /* Called from do_type_instantiation to instantiate a member
19872 (a member function or a static member variable) of an
19873 explicitly instantiated class template. */
19875 instantiate_class_member (tree decl, int extern_p)
19877 mark_decl_instantiated (decl, extern_p);
19879 instantiate_decl (decl, /*defer_ok=*/1,
19880 /*expl_inst_class_mem_p=*/true);
19883 /* Perform an explicit instantiation of template class T. STORAGE, if
19884 non-null, is the RID for extern, inline or static. COMPLAIN is
19885 nonzero if this is called from the parser, zero if called recursively,
19886 since the standard is unclear (as detailed below). */
19889 do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
19894 int previous_instantiation_extern_p = 0;
19896 if (TREE_CODE (t) == TYPE_DECL)
19899 if (! CLASS_TYPE_P (t) || ! CLASSTYPE_TEMPLATE_INFO (t))
19902 (TYPE_TEMPLATE_INFO (t)) ? TYPE_TI_TEMPLATE (t) : NULL;
19904 error ("explicit instantiation of non-class template %qD", tmpl);
19906 error ("explicit instantiation of non-template type %qT", t);
19912 if (!COMPLETE_TYPE_P (t))
19914 if (complain & tf_error)
19915 error ("explicit instantiation of %q#T before definition of template",
19920 if (storage != NULL_TREE)
19922 if (!in_system_header_at (input_location))
19924 if (storage == ridpointers[(int) RID_EXTERN])
19926 if (cxx_dialect == cxx98)
19927 pedwarn (input_location, OPT_Wpedantic,
19928 "ISO C++ 1998 forbids the use of %<extern%> on "
19929 "explicit instantiations");
19932 pedwarn (input_location, OPT_Wpedantic,
19933 "ISO C++ forbids the use of %qE"
19934 " on explicit instantiations", storage);
19937 if (storage == ridpointers[(int) RID_INLINE])
19939 else if (storage == ridpointers[(int) RID_EXTERN])
19941 else if (storage == ridpointers[(int) RID_STATIC])
19945 error ("storage class %qD applied to template instantiation",
19951 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
19953 /* DR 259 [temp.spec].
19955 Both an explicit instantiation and a declaration of an explicit
19956 specialization shall not appear in a program unless the explicit
19957 instantiation follows a declaration of the explicit specialization.
19959 For a given set of template parameters, if an explicit
19960 instantiation of a template appears after a declaration of an
19961 explicit specialization for that template, the explicit
19962 instantiation has no effect. */
19965 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t))
19969 No program shall explicitly instantiate any template more
19972 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
19973 instantiation was `extern'. If EXTERN_P then the second is.
19974 These cases are OK. */
19975 previous_instantiation_extern_p = CLASSTYPE_INTERFACE_ONLY (t);
19977 if (!previous_instantiation_extern_p && !extern_p
19978 && (complain & tf_error))
19979 permerror (input_location, "duplicate explicit instantiation of %q#T", t);
19981 /* If we've already instantiated the template, just return now. */
19982 if (!CLASSTYPE_INTERFACE_ONLY (t))
19986 check_explicit_instantiation_namespace (TYPE_NAME (t));
19987 mark_class_instantiated (t, extern_p);
19995 /* In contrast to implicit instantiation, where only the
19996 declarations, and not the definitions, of members are
19997 instantiated, we have here:
20001 The explicit instantiation of a class template specialization
20002 implies the instantiation of all of its members not
20003 previously explicitly specialized in the translation unit
20004 containing the explicit instantiation.
20006 Of course, we can't instantiate member template classes, since
20007 we don't have any arguments for them. Note that the standard
20008 is unclear on whether the instantiation of the members are
20009 *explicit* instantiations or not. However, the most natural
20010 interpretation is that it should be an explicit instantiation. */
20013 for (tmp = TYPE_METHODS (t); tmp; tmp = DECL_CHAIN (tmp))
20014 if (TREE_CODE (tmp) == FUNCTION_DECL
20015 && DECL_TEMPLATE_INSTANTIATION (tmp))
20016 instantiate_class_member (tmp, extern_p);
20018 for (tmp = TYPE_FIELDS (t); tmp; tmp = DECL_CHAIN (tmp))
20019 if (VAR_P (tmp) && DECL_TEMPLATE_INSTANTIATION (tmp))
20020 instantiate_class_member (tmp, extern_p);
20022 if (CLASSTYPE_NESTED_UTDS (t))
20023 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t),
20024 bt_instantiate_type_proc, &storage);
20028 /* Given a function DECL, which is a specialization of TMPL, modify
20029 DECL to be a re-instantiation of TMPL with the same template
20030 arguments. TMPL should be the template into which tsubst'ing
20031 should occur for DECL, not the most general template.
20033 One reason for doing this is a scenario like this:
20036 void f(const T&, int i);
20038 void g() { f(3, 7); }
20041 void f(const T& t, const int i) { }
20043 Note that when the template is first instantiated, with
20044 instantiate_template, the resulting DECL will have no name for the
20045 first parameter, and the wrong type for the second. So, when we go
20046 to instantiate the DECL, we regenerate it. */
20049 regenerate_decl_from_template (tree decl, tree tmpl)
20051 /* The arguments used to instantiate DECL, from the most general
20056 args = DECL_TI_ARGS (decl);
20057 code_pattern = DECL_TEMPLATE_RESULT (tmpl);
20059 /* Make sure that we can see identifiers, and compute access
20061 push_access_scope (decl);
20063 if (TREE_CODE (decl) == FUNCTION_DECL)
20071 args_depth = TMPL_ARGS_DEPTH (args);
20072 parms_depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
20073 if (args_depth > parms_depth)
20074 args = get_innermost_template_args (args, parms_depth);
20076 specs = tsubst_exception_specification (TREE_TYPE (code_pattern),
20077 args, tf_error, NULL_TREE,
20078 /*defer_ok*/false);
20079 if (specs && specs != error_mark_node)
20080 TREE_TYPE (decl) = build_exception_variant (TREE_TYPE (decl),
20083 /* Merge parameter declarations. */
20084 decl_parm = skip_artificial_parms_for (decl,
20085 DECL_ARGUMENTS (decl));
20087 = skip_artificial_parms_for (code_pattern,
20088 DECL_ARGUMENTS (code_pattern));
20089 while (decl_parm && !DECL_PACK_P (pattern_parm))
20094 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
20095 DECL_NAME (decl_parm) = DECL_NAME (pattern_parm);
20096 parm_type = tsubst (TREE_TYPE (pattern_parm), args, tf_error,
20098 parm_type = type_decays_to (parm_type);
20099 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
20100 TREE_TYPE (decl_parm) = parm_type;
20101 attributes = DECL_ATTRIBUTES (pattern_parm);
20102 if (DECL_ATTRIBUTES (decl_parm) != attributes)
20104 DECL_ATTRIBUTES (decl_parm) = attributes;
20105 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
20107 decl_parm = DECL_CHAIN (decl_parm);
20108 pattern_parm = DECL_CHAIN (pattern_parm);
20110 /* Merge any parameters that match with the function parameter
20112 if (pattern_parm && DECL_PACK_P (pattern_parm))
20115 tree expanded_types;
20116 /* Expand the TYPE_PACK_EXPANSION that provides the types for
20117 the parameters in this function parameter pack. */
20118 expanded_types = tsubst_pack_expansion (TREE_TYPE (pattern_parm),
20119 args, tf_error, NULL_TREE);
20120 len = TREE_VEC_LENGTH (expanded_types);
20121 for (i = 0; i < len; i++)
20126 if (DECL_NAME (decl_parm) != DECL_NAME (pattern_parm))
20127 /* Rename the parameter to include the index. */
20128 DECL_NAME (decl_parm) =
20129 make_ith_pack_parameter_name (DECL_NAME (pattern_parm), i);
20130 parm_type = TREE_VEC_ELT (expanded_types, i);
20131 parm_type = type_decays_to (parm_type);
20132 if (!same_type_p (TREE_TYPE (decl_parm), parm_type))
20133 TREE_TYPE (decl_parm) = parm_type;
20134 attributes = DECL_ATTRIBUTES (pattern_parm);
20135 if (DECL_ATTRIBUTES (decl_parm) != attributes)
20137 DECL_ATTRIBUTES (decl_parm) = attributes;
20138 cplus_decl_attributes (&decl_parm, attributes, /*flags=*/0);
20140 decl_parm = DECL_CHAIN (decl_parm);
20143 /* Merge additional specifiers from the CODE_PATTERN. */
20144 if (DECL_DECLARED_INLINE_P (code_pattern)
20145 && !DECL_DECLARED_INLINE_P (decl))
20146 DECL_DECLARED_INLINE_P (decl) = 1;
20148 else if (VAR_P (decl))
20150 DECL_INITIAL (decl) =
20151 tsubst_expr (DECL_INITIAL (code_pattern), args,
20152 tf_error, DECL_TI_TEMPLATE (decl),
20153 /*integral_constant_expression_p=*/false);
20154 if (VAR_HAD_UNKNOWN_BOUND (decl))
20155 TREE_TYPE (decl) = tsubst (TREE_TYPE (code_pattern), args,
20156 tf_error, DECL_TI_TEMPLATE (decl));
20159 gcc_unreachable ();
20161 pop_access_scope (decl);
20164 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
20165 substituted to get DECL. */
20168 template_for_substitution (tree decl)
20170 tree tmpl = DECL_TI_TEMPLATE (decl);
20172 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
20173 for the instantiation. This is not always the most general
20174 template. Consider, for example:
20177 struct S { template <class U> void f();
20178 template <> void f<int>(); };
20180 and an instantiation of S<double>::f<int>. We want TD to be the
20181 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
20182 while (/* An instantiation cannot have a definition, so we need a
20183 more general template. */
20184 DECL_TEMPLATE_INSTANTIATION (tmpl)
20185 /* We must also deal with friend templates. Given:
20187 template <class T> struct S {
20188 template <class U> friend void f() {};
20191 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
20192 so far as the language is concerned, but that's still
20193 where we get the pattern for the instantiation from. On
20194 other hand, if the definition comes outside the class, say:
20196 template <class T> struct S {
20197 template <class U> friend void f();
20199 template <class U> friend void f() {}
20201 we don't need to look any further. That's what the check for
20202 DECL_INITIAL is for. */
20203 || (TREE_CODE (decl) == FUNCTION_DECL
20204 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl)
20205 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl))))
20207 /* The present template, TD, should not be a definition. If it
20208 were a definition, we should be using it! Note that we
20209 cannot restructure the loop to just keep going until we find
20210 a template with a definition, since that might go too far if
20211 a specialization was declared, but not defined. */
20213 /* Fetch the more general template. */
20214 tmpl = DECL_TI_TEMPLATE (tmpl);
20220 /* Returns true if we need to instantiate this template instance even if we
20221 know we aren't going to emit it.. */
20224 always_instantiate_p (tree decl)
20226 /* We always instantiate inline functions so that we can inline them. An
20227 explicit instantiation declaration prohibits implicit instantiation of
20228 non-inline functions. With high levels of optimization, we would
20229 normally inline non-inline functions -- but we're not allowed to do
20230 that for "extern template" functions. Therefore, we check
20231 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
20232 return ((TREE_CODE (decl) == FUNCTION_DECL
20233 && (DECL_DECLARED_INLINE_P (decl)
20234 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl)))))
20235 /* And we need to instantiate static data members so that
20236 their initializers are available in integral constant
20239 && decl_maybe_constant_var_p (decl)));
20242 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
20243 instantiate it now, modifying TREE_TYPE (fn). */
20246 maybe_instantiate_noexcept (tree fn)
20248 tree fntype, spec, noex, clone;
20250 /* Don't instantiate a noexcept-specification from template context. */
20251 if (processing_template_decl)
20254 if (DECL_CLONED_FUNCTION_P (fn))
20255 fn = DECL_CLONED_FUNCTION (fn);
20256 fntype = TREE_TYPE (fn);
20257 spec = TYPE_RAISES_EXCEPTIONS (fntype);
20259 if (!spec || !TREE_PURPOSE (spec))
20262 noex = TREE_PURPOSE (spec);
20264 if (TREE_CODE (noex) == DEFERRED_NOEXCEPT)
20266 if (DEFERRED_NOEXCEPT_PATTERN (noex) == NULL_TREE)
20267 spec = get_defaulted_eh_spec (fn);
20268 else if (push_tinst_level (fn))
20270 push_access_scope (fn);
20271 push_deferring_access_checks (dk_no_deferred);
20272 input_location = DECL_SOURCE_LOCATION (fn);
20273 noex = tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex),
20274 DEFERRED_NOEXCEPT_ARGS (noex),
20275 tf_warning_or_error, fn,
20276 /*function_p=*/false,
20277 /*integral_constant_expression_p=*/true);
20278 pop_deferring_access_checks ();
20279 pop_access_scope (fn);
20280 pop_tinst_level ();
20281 spec = build_noexcept_spec (noex, tf_warning_or_error);
20282 if (spec == error_mark_node)
20283 spec = noexcept_false_spec;
20286 spec = noexcept_false_spec;
20288 TREE_TYPE (fn) = build_exception_variant (fntype, spec);
20291 FOR_EACH_CLONE (clone, fn)
20293 if (TREE_TYPE (clone) == fntype)
20294 TREE_TYPE (clone) = TREE_TYPE (fn);
20296 TREE_TYPE (clone) = build_exception_variant (TREE_TYPE (clone), spec);
20300 /* Produce the definition of D, a _DECL generated from a template. If
20301 DEFER_OK is nonzero, then we don't have to actually do the
20302 instantiation now; we just have to do it sometime. Normally it is
20303 an error if this is an explicit instantiation but D is undefined.
20304 EXPL_INST_CLASS_MEM_P is true iff D is a member of an
20305 explicitly instantiated class template. */
20308 instantiate_decl (tree d, int defer_ok,
20309 bool expl_inst_class_mem_p)
20311 tree tmpl = DECL_TI_TEMPLATE (d);
20318 bool pattern_defined;
20319 location_t saved_loc = input_location;
20320 int saved_unevaluated_operand = cp_unevaluated_operand;
20321 int saved_inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
20327 /* This function should only be used to instantiate templates for
20328 functions and static member variables. */
20329 gcc_assert (VAR_OR_FUNCTION_DECL_P (d));
20331 /* Variables are never deferred; if instantiation is required, they
20332 are instantiated right away. That allows for better code in the
20333 case that an expression refers to the value of the variable --
20334 if the variable has a constant value the referring expression can
20335 take advantage of that fact. */
20337 || DECL_DECLARED_CONSTEXPR_P (d))
20340 /* Don't instantiate cloned functions. Instead, instantiate the
20341 functions they cloned. */
20342 if (TREE_CODE (d) == FUNCTION_DECL && DECL_CLONED_FUNCTION_P (d))
20343 d = DECL_CLONED_FUNCTION (d);
20345 if (DECL_TEMPLATE_INSTANTIATED (d)
20346 || (TREE_CODE (d) == FUNCTION_DECL
20347 && DECL_DEFAULTED_FN (d) && DECL_INITIAL (d))
20348 || DECL_TEMPLATE_SPECIALIZATION (d))
20349 /* D has already been instantiated or explicitly specialized, so
20350 there's nothing for us to do here.
20352 It might seem reasonable to check whether or not D is an explicit
20353 instantiation, and, if so, stop here. But when an explicit
20354 instantiation is deferred until the end of the compilation,
20355 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
20356 the instantiation. */
20359 /* Check to see whether we know that this template will be
20360 instantiated in some other file, as with "extern template"
20362 external_p = (DECL_INTERFACE_KNOWN (d) && DECL_REALLY_EXTERN (d));
20364 /* In general, we do not instantiate such templates. */
20365 if (external_p && !always_instantiate_p (d))
20368 gen_tmpl = most_general_template (tmpl);
20369 gen_args = impartial_args (tmpl, DECL_TI_ARGS (d));
20371 if (tmpl != gen_tmpl)
20372 /* We should already have the extra args. */
20373 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl))
20374 == TMPL_ARGS_DEPTH (gen_args));
20375 /* And what's in the hash table should match D. */
20376 gcc_assert ((spec = retrieve_specialization (gen_tmpl, gen_args, 0)) == d
20377 || spec == NULL_TREE);
20379 /* This needs to happen before any tsubsting. */
20380 if (! push_tinst_level (d))
20383 timevar_push (TV_TEMPLATE_INST);
20385 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
20386 for the instantiation. */
20387 td = template_for_substitution (d);
20388 code_pattern = DECL_TEMPLATE_RESULT (td);
20390 /* We should never be trying to instantiate a member of a class
20391 template or partial specialization. */
20392 gcc_assert (d != code_pattern);
20394 if ((DECL_NAMESPACE_SCOPE_P (d) && !DECL_INITIALIZED_IN_CLASS_P (d))
20395 || DECL_TEMPLATE_SPECIALIZATION (td))
20396 /* In the case of a friend template whose definition is provided
20397 outside the class, we may have too many arguments. Drop the
20398 ones we don't need. The same is true for specializations. */
20399 args = get_innermost_template_args
20400 (gen_args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td)));
20404 if (TREE_CODE (d) == FUNCTION_DECL)
20406 deleted_p = DECL_DELETED_FN (code_pattern);
20407 pattern_defined = (DECL_SAVED_TREE (code_pattern) != NULL_TREE
20408 || DECL_DEFAULTED_OUTSIDE_CLASS_P (code_pattern)
20414 if (DECL_CLASS_SCOPE_P (code_pattern))
20415 pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
20417 pattern_defined = ! DECL_EXTERNAL (code_pattern);
20420 /* We may be in the middle of deferred access check. Disable it now. */
20421 push_deferring_access_checks (dk_no_deferred);
20423 /* Unless an explicit instantiation directive has already determined
20424 the linkage of D, remember that a definition is available for
20426 if (pattern_defined
20427 && !DECL_INTERFACE_KNOWN (d)
20428 && !DECL_NOT_REALLY_EXTERN (d))
20429 mark_definable (d);
20431 DECL_SOURCE_LOCATION (td) = DECL_SOURCE_LOCATION (code_pattern);
20432 DECL_SOURCE_LOCATION (d) = DECL_SOURCE_LOCATION (code_pattern);
20433 input_location = DECL_SOURCE_LOCATION (d);
20435 /* If D is a member of an explicitly instantiated class template,
20436 and no definition is available, treat it like an implicit
20438 if (!pattern_defined && expl_inst_class_mem_p
20439 && DECL_EXPLICIT_INSTANTIATION (d))
20441 /* Leave linkage flags alone on instantiations with anonymous
20443 if (TREE_PUBLIC (d))
20445 DECL_NOT_REALLY_EXTERN (d) = 0;
20446 DECL_INTERFACE_KNOWN (d) = 0;
20448 SET_DECL_IMPLICIT_INSTANTIATION (d);
20451 /* Defer all other templates, unless we have been explicitly
20452 forbidden from doing so. */
20453 if (/* If there is no definition, we cannot instantiate the
20456 /* If it's OK to postpone instantiation, do so. */
20458 /* If this is a static data member that will be defined
20459 elsewhere, we don't want to instantiate the entire data
20460 member, but we do want to instantiate the initializer so that
20461 we can substitute that elsewhere. */
20462 || (external_p && VAR_P (d))
20463 /* Handle here a deleted function too, avoid generating
20464 its body (c++/61080). */
20467 /* The definition of the static data member is now required so
20468 we must substitute the initializer. */
20470 && !DECL_INITIAL (d)
20471 && DECL_INITIAL (code_pattern))
20475 bool const_init = false;
20476 bool enter_context = DECL_CLASS_SCOPE_P (d);
20478 ns = decl_namespace_context (d);
20479 push_nested_namespace (ns);
20481 push_nested_class (DECL_CONTEXT (d));
20482 init = tsubst_expr (DECL_INITIAL (code_pattern),
20484 tf_warning_or_error, NULL_TREE,
20485 /*integral_constant_expression_p=*/false);
20486 /* If instantiating the initializer involved instantiating this
20487 again, don't call cp_finish_decl twice. */
20488 if (!DECL_INITIAL (d))
20490 /* Make sure the initializer is still constant, in case of
20491 circular dependency (template/instantiate6.C). */
20493 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern);
20494 cp_finish_decl (d, init, /*init_const_expr_p=*/const_init,
20495 /*asmspec_tree=*/NULL_TREE,
20496 LOOKUP_ONLYCONVERTING);
20499 pop_nested_class ();
20500 pop_nested_namespace (ns);
20503 /* We restore the source position here because it's used by
20504 add_pending_template. */
20505 input_location = saved_loc;
20507 if (at_eof && !pattern_defined
20508 && DECL_EXPLICIT_INSTANTIATION (d)
20509 && DECL_NOT_REALLY_EXTERN (d))
20512 The definition of a non-exported function template, a
20513 non-exported member function template, or a non-exported
20514 member function or static data member of a class template
20515 shall be present in every translation unit in which it is
20516 explicitly instantiated. */
20517 permerror (input_location, "explicit instantiation of %qD "
20518 "but no definition available", d);
20520 /* If we're in unevaluated context, we just wanted to get the
20521 constant value; this isn't an odr use, so don't queue
20522 a full instantiation. */
20523 if (cp_unevaluated_operand != 0)
20525 /* ??? Historically, we have instantiated inline functions, even
20526 when marked as "extern template". */
20527 if (!(external_p && VAR_P (d)))
20528 add_pending_template (d);
20531 /* Tell the repository that D is available in this translation unit
20532 -- and see if it is supposed to be instantiated here. */
20533 if (TREE_PUBLIC (d) && !DECL_REALLY_EXTERN (d) && !repo_emit_p (d))
20535 /* In a PCH file, despite the fact that the repository hasn't
20536 requested instantiation in the PCH it is still possible that
20537 an instantiation will be required in a file that includes the
20540 add_pending_template (d);
20541 /* Instantiate inline functions so that the inliner can do its
20542 job, even though we'll not be emitting a copy of this
20544 if (!(TREE_CODE (d) == FUNCTION_DECL && possibly_inlined_p (d)))
20548 fn_context = decl_function_context (d);
20549 nested = (current_function_decl != NULL_TREE);
20551 push_to_top_level ();
20555 push_function_context ();
20556 cp_unevaluated_operand = 0;
20557 c_inhibit_evaluation_warnings = 0;
20560 /* Mark D as instantiated so that recursive calls to
20561 instantiate_decl do not try to instantiate it again. */
20562 DECL_TEMPLATE_INSTANTIATED (d) = 1;
20564 /* Regenerate the declaration in case the template has been modified
20565 by a subsequent redeclaration. */
20566 regenerate_decl_from_template (d, td);
20568 /* We already set the file and line above. Reset them now in case
20569 they changed as a result of calling regenerate_decl_from_template. */
20570 input_location = DECL_SOURCE_LOCATION (d);
20575 bool const_init = false;
20577 /* Clear out DECL_RTL; whatever was there before may not be right
20578 since we've reset the type of the declaration. */
20579 SET_DECL_RTL (d, NULL);
20580 DECL_IN_AGGR_P (d) = 0;
20582 /* The initializer is placed in DECL_INITIAL by
20583 regenerate_decl_from_template so we don't need to
20584 push/pop_access_scope again here. Pull it out so that
20585 cp_finish_decl can process it. */
20586 init = DECL_INITIAL (d);
20587 DECL_INITIAL (d) = NULL_TREE;
20588 DECL_INITIALIZED_P (d) = 0;
20590 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
20591 initializer. That function will defer actual emission until
20592 we have a chance to determine linkage. */
20593 DECL_EXTERNAL (d) = 0;
20595 /* Enter the scope of D so that access-checking works correctly. */
20596 bool enter_context = DECL_CLASS_SCOPE_P (d);
20598 push_nested_class (DECL_CONTEXT (d));
20600 const_init = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern);
20601 cp_finish_decl (d, init, const_init, NULL_TREE, 0);
20604 pop_nested_class ();
20606 if (variable_template_p (gen_tmpl))
20607 note_variable_template_instantiation (d);
20609 else if (TREE_CODE (d) == FUNCTION_DECL && DECL_DEFAULTED_FN (code_pattern))
20610 synthesize_method (d);
20611 else if (TREE_CODE (d) == FUNCTION_DECL)
20613 hash_map<tree, tree> *saved_local_specializations;
20617 tree block = NULL_TREE;
20619 /* Save away the current list, in case we are instantiating one
20620 template from within the body of another. */
20621 saved_local_specializations = local_specializations;
20623 /* Set up the list of local specializations. */
20624 local_specializations = new hash_map<tree, tree>;
20626 /* Set up context. */
20627 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern)
20628 && TREE_CODE (DECL_CONTEXT (code_pattern)) == FUNCTION_DECL)
20629 block = push_stmt_list ();
20631 start_preparsed_function (d, NULL_TREE, SF_PRE_PARSED);
20633 /* Some typedefs referenced from within the template code need to be
20634 access checked at template instantiation time, i.e now. These
20635 types were added to the template at parsing time. Let's get those
20636 and perform the access checks then. */
20637 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (gen_tmpl),
20640 /* Create substitution entries for the parameters. */
20641 subst_decl = DECL_TEMPLATE_RESULT (template_for_substitution (d));
20642 tmpl_parm = DECL_ARGUMENTS (subst_decl);
20643 spec_parm = DECL_ARGUMENTS (d);
20644 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (d))
20646 register_local_specialization (spec_parm, tmpl_parm);
20647 spec_parm = skip_artificial_parms_for (d, spec_parm);
20648 tmpl_parm = skip_artificial_parms_for (subst_decl, tmpl_parm);
20650 for (; tmpl_parm; tmpl_parm = DECL_CHAIN (tmpl_parm))
20652 if (!DECL_PACK_P (tmpl_parm))
20654 register_local_specialization (spec_parm, tmpl_parm);
20655 spec_parm = DECL_CHAIN (spec_parm);
20659 /* Register the (value) argument pack as a specialization of
20660 TMPL_PARM, then move on. */
20661 tree argpack = extract_fnparm_pack (tmpl_parm, &spec_parm);
20662 register_local_specialization (argpack, tmpl_parm);
20665 gcc_assert (!spec_parm);
20667 /* Substitute into the body of the function. */
20668 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern))
20669 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern), args,
20670 tf_warning_or_error, tmpl);
20673 tsubst_expr (DECL_SAVED_TREE (code_pattern), args,
20674 tf_warning_or_error, tmpl,
20675 /*integral_constant_expression_p=*/false);
20677 /* Set the current input_location to the end of the function
20678 so that finish_function knows where we are. */
20680 = DECL_STRUCT_FUNCTION (code_pattern)->function_end_locus;
20682 /* Remember if we saw an infinite loop in the template. */
20683 current_function_infinite_loop
20684 = DECL_STRUCT_FUNCTION (code_pattern)->language->infinite_loop;
20687 /* We don't need the local specializations any more. */
20688 delete local_specializations;
20689 local_specializations = saved_local_specializations;
20691 /* Finish the function. */
20692 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern)
20693 && TREE_CODE (DECL_CONTEXT (code_pattern)) == FUNCTION_DECL)
20694 DECL_SAVED_TREE (d) = pop_stmt_list (block);
20697 d = finish_function (0);
20698 expand_or_defer_fn (d);
20701 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern))
20702 cp_check_omp_declare_reduction (d);
20705 /* We're not deferring instantiation any more. */
20706 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d)) = 0;
20709 pop_from_top_level ();
20711 pop_function_context ();
20714 input_location = saved_loc;
20715 cp_unevaluated_operand = saved_unevaluated_operand;
20716 c_inhibit_evaluation_warnings = saved_inhibit_evaluation_warnings;
20717 pop_deferring_access_checks ();
20718 pop_tinst_level ();
20720 timevar_pop (TV_TEMPLATE_INST);
20725 /* Run through the list of templates that we wish we could
20726 instantiate, and instantiate any we can. RETRIES is the
20727 number of times we retry pending template instantiation. */
20730 instantiate_pending_templates (int retries)
20733 location_t saved_loc = input_location;
20735 /* Instantiating templates may trigger vtable generation. This in turn
20736 may require further template instantiations. We place a limit here
20737 to avoid infinite loop. */
20738 if (pending_templates && retries >= max_tinst_depth)
20740 tree decl = pending_templates->tinst->decl;
20742 fatal_error (input_location,
20743 "template instantiation depth exceeds maximum of %d"
20744 " instantiating %q+D, possibly from virtual table generation"
20745 " (use -ftemplate-depth= to increase the maximum)",
20746 max_tinst_depth, decl);
20747 if (TREE_CODE (decl) == FUNCTION_DECL)
20748 /* Pretend that we defined it. */
20749 DECL_INITIAL (decl) = error_mark_node;
20755 struct pending_template **t = &pending_templates;
20756 struct pending_template *last = NULL;
20760 tree instantiation = reopen_tinst_level ((*t)->tinst);
20761 bool complete = false;
20763 if (TYPE_P (instantiation))
20767 if (!COMPLETE_TYPE_P (instantiation))
20769 instantiate_class_template (instantiation);
20770 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation))
20771 for (fn = TYPE_METHODS (instantiation);
20773 fn = TREE_CHAIN (fn))
20774 if (! DECL_ARTIFICIAL (fn))
20775 instantiate_decl (fn,
20777 /*expl_inst_class_mem_p=*/false);
20778 if (COMPLETE_TYPE_P (instantiation))
20782 complete = COMPLETE_TYPE_P (instantiation);
20786 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation)
20787 && !DECL_TEMPLATE_INSTANTIATED (instantiation))
20790 = instantiate_decl (instantiation,
20792 /*expl_inst_class_mem_p=*/false);
20793 if (DECL_TEMPLATE_INSTANTIATED (instantiation))
20797 complete = (DECL_TEMPLATE_SPECIALIZATION (instantiation)
20798 || DECL_TEMPLATE_INSTANTIATED (instantiation));
20802 /* If INSTANTIATION has been instantiated, then we don't
20803 need to consider it again in the future. */
20811 current_tinst_level = NULL;
20813 last_pending_template = last;
20815 while (reconsider);
20817 input_location = saved_loc;
20820 /* Substitute ARGVEC into T, which is a list of initializers for
20821 either base class or a non-static data member. The TREE_PURPOSEs
20822 are DECLs, and the TREE_VALUEs are the initializer values. Used by
20823 instantiate_decl. */
20826 tsubst_initializer_list (tree t, tree argvec)
20828 tree inits = NULL_TREE;
20830 for (; t; t = TREE_CHAIN (t))
20834 tree expanded_bases = NULL_TREE;
20835 tree expanded_arguments = NULL_TREE;
20838 if (TREE_CODE (TREE_PURPOSE (t)) == TYPE_PACK_EXPANSION)
20843 /* Expand the base class expansion type into separate base
20845 expanded_bases = tsubst_pack_expansion (TREE_PURPOSE (t), argvec,
20846 tf_warning_or_error,
20848 if (expanded_bases == error_mark_node)
20851 /* We'll be building separate TREE_LISTs of arguments for
20853 len = TREE_VEC_LENGTH (expanded_bases);
20854 expanded_arguments = make_tree_vec (len);
20855 for (i = 0; i < len; i++)
20856 TREE_VEC_ELT (expanded_arguments, i) = NULL_TREE;
20858 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
20859 expand each argument in the TREE_VALUE of t. */
20860 expr = make_node (EXPR_PACK_EXPANSION);
20861 PACK_EXPANSION_LOCAL_P (expr) = true;
20862 PACK_EXPANSION_PARAMETER_PACKS (expr) =
20863 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t));
20865 if (TREE_VALUE (t) == void_type_node)
20866 /* VOID_TYPE_NODE is used to indicate
20867 value-initialization. */
20869 for (i = 0; i < len; i++)
20870 TREE_VEC_ELT (expanded_arguments, i) = void_type_node;
20874 /* Substitute parameter packs into each argument in the
20876 in_base_initializer = 1;
20877 for (arg = TREE_VALUE (t); arg; arg = TREE_CHAIN (arg))
20879 tree expanded_exprs;
20881 /* Expand the argument. */
20882 SET_PACK_EXPANSION_PATTERN (expr, TREE_VALUE (arg));
20884 = tsubst_pack_expansion (expr, argvec,
20885 tf_warning_or_error,
20887 if (expanded_exprs == error_mark_node)
20890 /* Prepend each of the expanded expressions to the
20891 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
20892 for (i = 0; i < len; i++)
20894 TREE_VEC_ELT (expanded_arguments, i) =
20895 tree_cons (NULL_TREE,
20896 TREE_VEC_ELT (expanded_exprs, i),
20897 TREE_VEC_ELT (expanded_arguments, i));
20900 in_base_initializer = 0;
20902 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
20903 since we built them backwards. */
20904 for (i = 0; i < len; i++)
20906 TREE_VEC_ELT (expanded_arguments, i) =
20907 nreverse (TREE_VEC_ELT (expanded_arguments, i));
20912 for (i = 0; i < len; ++i)
20914 if (expanded_bases)
20916 decl = TREE_VEC_ELT (expanded_bases, i);
20917 decl = expand_member_init (decl);
20918 init = TREE_VEC_ELT (expanded_arguments, i);
20923 decl = tsubst_copy (TREE_PURPOSE (t), argvec,
20924 tf_warning_or_error, NULL_TREE);
20926 decl = expand_member_init (decl);
20927 if (decl && !DECL_P (decl))
20928 in_base_initializer = 1;
20930 init = TREE_VALUE (t);
20932 if (init != void_type_node)
20933 init = tsubst_expr (init, argvec,
20934 tf_warning_or_error, NULL_TREE,
20935 /*integral_constant_expression_p=*/false);
20936 if (init == NULL_TREE && tmp != NULL_TREE)
20937 /* If we had an initializer but it instantiated to nothing,
20938 value-initialize the object. This will only occur when
20939 the initializer was a pack expansion where the parameter
20940 packs used in that expansion were of length zero. */
20941 init = void_type_node;
20942 in_base_initializer = 0;
20947 init = build_tree_list (decl, init);
20948 TREE_CHAIN (init) = inits;
20956 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
20959 set_current_access_from_decl (tree decl)
20961 if (TREE_PRIVATE (decl))
20962 current_access_specifier = access_private_node;
20963 else if (TREE_PROTECTED (decl))
20964 current_access_specifier = access_protected_node;
20966 current_access_specifier = access_public_node;
20969 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
20970 is the instantiation (which should have been created with
20971 start_enum) and ARGS are the template arguments to use. */
20974 tsubst_enum (tree tag, tree newtag, tree args)
20978 if (SCOPED_ENUM_P (newtag))
20979 begin_scope (sk_scoped_enum, newtag);
20981 for (e = TYPE_VALUES (tag); e; e = TREE_CHAIN (e))
20986 decl = TREE_VALUE (e);
20987 /* Note that in a template enum, the TREE_VALUE is the
20988 CONST_DECL, not the corresponding INTEGER_CST. */
20989 value = tsubst_expr (DECL_INITIAL (decl),
20990 args, tf_warning_or_error, NULL_TREE,
20991 /*integral_constant_expression_p=*/true);
20993 /* Give this enumeration constant the correct access. */
20994 set_current_access_from_decl (decl);
20996 /* Actually build the enumerator itself. */
20998 (DECL_NAME (decl), value, newtag, DECL_SOURCE_LOCATION (decl));
21001 if (SCOPED_ENUM_P (newtag))
21004 finish_enum_value_list (newtag);
21005 finish_enum (newtag);
21007 DECL_SOURCE_LOCATION (TYPE_NAME (newtag))
21008 = DECL_SOURCE_LOCATION (TYPE_NAME (tag));
21011 /* DECL is a FUNCTION_DECL that is a template specialization. Return
21012 its type -- but without substituting the innermost set of template
21013 arguments. So, innermost set of template parameters will appear in
21017 get_mostly_instantiated_function_type (tree decl)
21019 /* For a function, DECL_TI_TEMPLATE is partially instantiated. */
21020 return TREE_TYPE (DECL_TI_TEMPLATE (decl));
21023 /* Return truthvalue if we're processing a template different from
21024 the last one involved in diagnostics. */
21026 problematic_instantiation_changed (void)
21028 return current_tinst_level != last_error_tinst_level;
21031 /* Remember current template involved in diagnostics. */
21033 record_last_problematic_instantiation (void)
21035 last_error_tinst_level = current_tinst_level;
21038 struct tinst_level *
21039 current_instantiation (void)
21041 return current_tinst_level;
21044 /* Return TRUE if current_function_decl is being instantiated, false
21048 instantiating_current_function_p (void)
21050 return (current_instantiation ()
21051 && current_instantiation ()->decl == current_function_decl);
21054 /* [temp.param] Check that template non-type parm TYPE is of an allowable
21055 type. Return zero for ok, nonzero for disallowed. Issue error and
21056 warning messages under control of COMPLAIN. */
21059 invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain)
21061 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type))
21063 else if (POINTER_TYPE_P (type))
21065 else if (TYPE_PTRMEM_P (type))
21067 else if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
21069 else if (TREE_CODE (type) == TYPENAME_TYPE)
21071 else if (TREE_CODE (type) == DECLTYPE_TYPE)
21073 else if (TREE_CODE (type) == NULLPTR_TYPE)
21076 if (complain & tf_error)
21078 if (type == error_mark_node)
21079 inform (input_location, "invalid template non-type parameter");
21081 error ("%q#T is not a valid type for a template non-type parameter",
21087 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
21088 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
21091 dependent_type_p_r (tree type)
21097 A type is dependent if it is:
21099 -- a template parameter. Template template parameters are types
21100 for us (since TYPE_P holds true for them) so we handle
21102 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
21103 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM)
21105 /* -- a qualified-id with a nested-name-specifier which contains a
21106 class-name that names a dependent type or whose unqualified-id
21107 names a dependent type. */
21108 if (TREE_CODE (type) == TYPENAME_TYPE)
21111 /* An alias template specialization can be dependent even if the
21112 resulting type is not. */
21113 if (dependent_alias_template_spec_p (type))
21116 /* -- a cv-qualified type where the cv-unqualified type is
21118 No code is necessary for this bullet; the code below handles
21119 cv-qualified types, and we don't want to strip aliases with
21120 TYPE_MAIN_VARIANT because of DR 1558. */
21121 /* -- a compound type constructed from any dependent type. */
21122 if (TYPE_PTRMEM_P (type))
21123 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type))
21124 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
21126 else if (TYPE_PTR_P (type)
21127 || TREE_CODE (type) == REFERENCE_TYPE)
21128 return dependent_type_p (TREE_TYPE (type));
21129 else if (TREE_CODE (type) == FUNCTION_TYPE
21130 || TREE_CODE (type) == METHOD_TYPE)
21134 if (dependent_type_p (TREE_TYPE (type)))
21136 for (arg_type = TYPE_ARG_TYPES (type);
21138 arg_type = TREE_CHAIN (arg_type))
21139 if (dependent_type_p (TREE_VALUE (arg_type)))
21143 /* -- an array type constructed from any dependent type or whose
21144 size is specified by a constant expression that is
21147 We checked for type- and value-dependence of the bounds in
21148 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
21149 if (TREE_CODE (type) == ARRAY_TYPE)
21151 if (TYPE_DOMAIN (type)
21152 && dependent_type_p (TYPE_DOMAIN (type)))
21154 return dependent_type_p (TREE_TYPE (type));
21157 /* -- a template-id in which either the template name is a template
21159 if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
21161 /* ... or any of the template arguments is a dependent type or
21162 an expression that is type-dependent or value-dependent. */
21163 else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
21164 && (any_dependent_template_arguments_p
21165 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))
21168 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
21169 dependent; if the argument of the `typeof' expression is not
21170 type-dependent, then it should already been have resolved. */
21171 if (TREE_CODE (type) == TYPEOF_TYPE
21172 || TREE_CODE (type) == DECLTYPE_TYPE
21173 || TREE_CODE (type) == UNDERLYING_TYPE)
21176 /* A template argument pack is dependent if any of its packed
21178 if (TREE_CODE (type) == TYPE_ARGUMENT_PACK)
21180 tree args = ARGUMENT_PACK_ARGS (type);
21181 int i, len = TREE_VEC_LENGTH (args);
21182 for (i = 0; i < len; ++i)
21183 if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
21187 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
21188 be template parameters. */
21189 if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
21192 /* The standard does not specifically mention types that are local
21193 to template functions or local classes, but they should be
21194 considered dependent too. For example:
21196 template <int I> void f() {
21201 The size of `E' cannot be known until the value of `I' has been
21202 determined. Therefore, `E' must be considered dependent. */
21203 scope = TYPE_CONTEXT (type);
21204 if (scope && TYPE_P (scope))
21205 return dependent_type_p (scope);
21206 /* Don't use type_dependent_expression_p here, as it can lead
21207 to infinite recursion trying to determine whether a lambda
21208 nested in a lambda is dependent (c++/47687). */
21209 else if (scope && TREE_CODE (scope) == FUNCTION_DECL
21210 && DECL_LANG_SPECIFIC (scope)
21211 && DECL_TEMPLATE_INFO (scope)
21212 && (any_dependent_template_arguments_p
21213 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope)))))
21216 /* Other types are non-dependent. */
21220 /* Returns TRUE if TYPE is dependent, in the sense of
21221 [temp.dep.type]. Note that a NULL type is considered dependent. */
21224 dependent_type_p (tree type)
21226 /* If there are no template parameters in scope, then there can't be
21227 any dependent types. */
21228 if (!processing_template_decl)
21230 /* If we are not processing a template, then nobody should be
21231 providing us with a dependent type. */
21233 gcc_assert (TREE_CODE (type) != TEMPLATE_TYPE_PARM || is_auto (type));
21237 /* If the type is NULL, we have not computed a type for the entity
21238 in question; in that case, the type is dependent. */
21242 /* Erroneous types can be considered non-dependent. */
21243 if (type == error_mark_node)
21246 /* If we have not already computed the appropriate value for TYPE,
21248 if (!TYPE_DEPENDENT_P_VALID (type))
21250 TYPE_DEPENDENT_P (type) = dependent_type_p_r (type);
21251 TYPE_DEPENDENT_P_VALID (type) = 1;
21254 return TYPE_DEPENDENT_P (type);
21257 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
21258 lookup. In other words, a dependent type that is not the current
21262 dependent_scope_p (tree scope)
21264 return (scope && TYPE_P (scope) && dependent_type_p (scope)
21265 && !currently_open_class (scope));
21268 /* T is a SCOPE_REF; return whether we need to consider it
21269 instantiation-dependent so that we can check access at instantiation
21270 time even though we know which member it resolves to. */
21273 instantiation_dependent_scope_ref_p (tree t)
21275 if (DECL_P (TREE_OPERAND (t, 1))
21276 && CLASS_TYPE_P (TREE_OPERAND (t, 0))
21277 && accessible_in_template_p (TREE_OPERAND (t, 0),
21278 TREE_OPERAND (t, 1)))
21284 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
21285 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
21288 /* Note that this predicate is not appropriate for general expressions;
21289 only constant expressions (that satisfy potential_constant_expression)
21290 can be tested for value dependence. */
21293 value_dependent_expression_p (tree expression)
21295 if (!processing_template_decl)
21298 /* A name declared with a dependent type. */
21299 if (DECL_P (expression) && type_dependent_expression_p (expression))
21302 switch (TREE_CODE (expression))
21304 case IDENTIFIER_NODE:
21305 /* A name that has not been looked up -- must be dependent. */
21308 case TEMPLATE_PARM_INDEX:
21309 /* A non-type template parm. */
21313 /* A non-type template parm. */
21314 if (DECL_TEMPLATE_PARM_P (expression))
21316 return value_dependent_expression_p (DECL_INITIAL (expression));
21319 /* A constant with literal type and is initialized
21320 with an expression that is value-dependent.
21322 Note that a non-dependent parenthesized initializer will have
21323 already been replaced with its constant value, so if we see
21324 a TREE_LIST it must be dependent. */
21325 if (DECL_INITIAL (expression)
21326 && decl_constant_var_p (expression)
21327 && (TREE_CODE (DECL_INITIAL (expression)) == TREE_LIST
21328 /* cp_finish_decl doesn't fold reference initializers. */
21329 || TREE_CODE (TREE_TYPE (expression)) == REFERENCE_TYPE
21330 || value_dependent_expression_p (DECL_INITIAL (expression))))
21334 case DYNAMIC_CAST_EXPR:
21335 case STATIC_CAST_EXPR:
21336 case CONST_CAST_EXPR:
21337 case REINTERPRET_CAST_EXPR:
21339 /* These expressions are value-dependent if the type to which
21340 the cast occurs is dependent or the expression being casted
21341 is value-dependent. */
21343 tree type = TREE_TYPE (expression);
21345 if (dependent_type_p (type))
21348 /* A functional cast has a list of operands. */
21349 expression = TREE_OPERAND (expression, 0);
21352 /* If there are no operands, it must be an expression such
21353 as "int()". This should not happen for aggregate types
21354 because it would form non-constant expressions. */
21355 gcc_assert (cxx_dialect >= cxx11
21356 || INTEGRAL_OR_ENUMERATION_TYPE_P (type));
21361 if (TREE_CODE (expression) == TREE_LIST)
21362 return any_value_dependent_elements_p (expression);
21364 return value_dependent_expression_p (expression);
21368 if (SIZEOF_EXPR_TYPE_P (expression))
21369 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression, 0)));
21373 /* A `sizeof' expression is value-dependent if the operand is
21374 type-dependent or is a pack expansion. */
21375 expression = TREE_OPERAND (expression, 0);
21376 if (PACK_EXPANSION_P (expression))
21378 else if (TYPE_P (expression))
21379 return dependent_type_p (expression);
21380 return instantiation_dependent_expression_p (expression);
21382 case AT_ENCODE_EXPR:
21383 /* An 'encode' expression is value-dependent if the operand is
21385 expression = TREE_OPERAND (expression, 0);
21386 return dependent_type_p (expression);
21388 case NOEXCEPT_EXPR:
21389 expression = TREE_OPERAND (expression, 0);
21390 return instantiation_dependent_expression_p (expression);
21393 /* All instantiation-dependent expressions should also be considered
21394 value-dependent. */
21395 return instantiation_dependent_scope_ref_p (expression);
21397 case COMPONENT_REF:
21398 return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
21399 || value_dependent_expression_p (TREE_OPERAND (expression, 1)));
21401 case NONTYPE_ARGUMENT_PACK:
21402 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
21403 is value-dependent. */
21405 tree values = ARGUMENT_PACK_ARGS (expression);
21406 int i, len = TREE_VEC_LENGTH (values);
21408 for (i = 0; i < len; ++i)
21409 if (value_dependent_expression_p (TREE_VEC_ELT (values, i)))
21417 tree type2 = TRAIT_EXPR_TYPE2 (expression);
21418 return (dependent_type_p (TRAIT_EXPR_TYPE1 (expression))
21419 || (type2 ? dependent_type_p (type2) : false));
21423 return ((value_dependent_expression_p (TREE_OPERAND (expression, 0)))
21424 || (value_dependent_expression_p (TREE_OPERAND (expression, 2))));
21427 return ((value_dependent_expression_p (TREE_OPERAND (expression, 0)))
21428 || (value_dependent_expression_p (TREE_OPERAND (expression, 1))));
21432 tree op = TREE_OPERAND (expression, 0);
21433 return (value_dependent_expression_p (op)
21434 || has_value_dependent_address (op));
21439 tree fn = get_callee_fndecl (expression);
21441 if (!fn && value_dependent_expression_p (CALL_EXPR_FN (expression)))
21443 nargs = call_expr_nargs (expression);
21444 for (i = 0; i < nargs; ++i)
21446 tree op = CALL_EXPR_ARG (expression, i);
21447 /* In a call to a constexpr member function, look through the
21448 implicit ADDR_EXPR on the object argument so that it doesn't
21449 cause the call to be considered value-dependent. We also
21450 look through it in potential_constant_expression. */
21451 if (i == 0 && fn && DECL_DECLARED_CONSTEXPR_P (fn)
21452 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
21453 && TREE_CODE (op) == ADDR_EXPR)
21454 op = TREE_OPERAND (op, 0);
21455 if (value_dependent_expression_p (op))
21461 case TEMPLATE_ID_EXPR:
21462 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
21464 return type_dependent_expression_p (expression);
21470 if (dependent_type_p (TREE_TYPE (expression)))
21472 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression), ix, val)
21473 if (value_dependent_expression_p (val))
21479 /* Treat a GNU statement expression as dependent to avoid crashing
21480 under instantiate_non_dependent_expr; it can't be constant. */
21484 /* A constant expression is value-dependent if any subexpression is
21485 value-dependent. */
21486 switch (TREE_CODE_CLASS (TREE_CODE (expression)))
21488 case tcc_reference:
21490 case tcc_comparison:
21492 case tcc_expression:
21495 int i, len = cp_tree_operand_length (expression);
21497 for (i = 0; i < len; i++)
21499 tree t = TREE_OPERAND (expression, i);
21501 /* In some cases, some of the operands may be missing.l
21502 (For example, in the case of PREDECREMENT_EXPR, the
21503 amount to increment by may be missing.) That doesn't
21504 make the expression dependent. */
21505 if (t && value_dependent_expression_p (t))
21516 /* The expression is not value-dependent. */
21520 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
21521 [temp.dep.expr]. Note that an expression with no type is
21522 considered dependent. Other parts of the compiler arrange for an
21523 expression with type-dependent subexpressions to have no type, so
21524 this function doesn't have to be fully recursive. */
21527 type_dependent_expression_p (tree expression)
21529 if (!processing_template_decl)
21532 if (expression == NULL_TREE || expression == error_mark_node)
21535 /* An unresolved name is always dependent. */
21536 if (identifier_p (expression) || TREE_CODE (expression) == USING_DECL)
21539 /* Some expression forms are never type-dependent. */
21540 if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR
21541 || TREE_CODE (expression) == SIZEOF_EXPR
21542 || TREE_CODE (expression) == ALIGNOF_EXPR
21543 || TREE_CODE (expression) == AT_ENCODE_EXPR
21544 || TREE_CODE (expression) == NOEXCEPT_EXPR
21545 || TREE_CODE (expression) == TRAIT_EXPR
21546 || TREE_CODE (expression) == TYPEID_EXPR
21547 || TREE_CODE (expression) == DELETE_EXPR
21548 || TREE_CODE (expression) == VEC_DELETE_EXPR
21549 || TREE_CODE (expression) == THROW_EXPR)
21552 /* The types of these expressions depends only on the type to which
21553 the cast occurs. */
21554 if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
21555 || TREE_CODE (expression) == STATIC_CAST_EXPR
21556 || TREE_CODE (expression) == CONST_CAST_EXPR
21557 || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
21558 || TREE_CODE (expression) == IMPLICIT_CONV_EXPR
21559 || TREE_CODE (expression) == CAST_EXPR)
21560 return dependent_type_p (TREE_TYPE (expression));
21562 /* The types of these expressions depends only on the type created
21563 by the expression. */
21564 if (TREE_CODE (expression) == NEW_EXPR
21565 || TREE_CODE (expression) == VEC_NEW_EXPR)
21567 /* For NEW_EXPR tree nodes created inside a template, either
21568 the object type itself or a TREE_LIST may appear as the
21570 tree type = TREE_OPERAND (expression, 1);
21571 if (TREE_CODE (type) == TREE_LIST)
21572 /* This is an array type. We need to check array dimensions
21574 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type)))
21575 || value_dependent_expression_p
21576 (TREE_OPERAND (TREE_VALUE (type), 1));
21578 return dependent_type_p (type);
21581 if (TREE_CODE (expression) == SCOPE_REF)
21583 tree scope = TREE_OPERAND (expression, 0);
21584 tree name = TREE_OPERAND (expression, 1);
21586 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
21587 contains an identifier associated by name lookup with one or more
21588 declarations declared with a dependent type, or...a
21589 nested-name-specifier or qualified-id that names a member of an
21590 unknown specialization. */
21591 return (type_dependent_expression_p (name)
21592 || dependent_scope_p (scope));
21595 if (TREE_CODE (expression) == FUNCTION_DECL
21596 && DECL_LANG_SPECIFIC (expression)
21597 && DECL_TEMPLATE_INFO (expression)
21598 && (any_dependent_template_arguments_p
21599 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
21602 if (TREE_CODE (expression) == TEMPLATE_DECL
21603 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression))
21606 if (TREE_CODE (expression) == STMT_EXPR)
21607 expression = stmt_expr_value_expr (expression);
21609 if (BRACE_ENCLOSED_INITIALIZER_P (expression))
21614 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression), i, elt)
21616 if (type_dependent_expression_p (elt))
21622 /* A static data member of the current instantiation with incomplete
21623 array type is type-dependent, as the definition and specializations
21624 can have different bounds. */
21625 if (VAR_P (expression)
21626 && DECL_CLASS_SCOPE_P (expression)
21627 && dependent_type_p (DECL_CONTEXT (expression))
21628 && VAR_HAD_UNKNOWN_BOUND (expression))
21631 /* An array of unknown bound depending on a variadic parameter, eg:
21633 template<typename... Args>
21634 void foo (Args... args)
21636 int arr[] = { args... };
21639 template<int... vals>
21642 int arr[] = { vals... };
21645 If the array has no length and has an initializer, it must be that
21646 we couldn't determine its length in cp_complete_array_type because
21647 it is dependent. */
21648 if (VAR_P (expression)
21649 && TREE_CODE (TREE_TYPE (expression)) == ARRAY_TYPE
21650 && !TYPE_DOMAIN (TREE_TYPE (expression))
21651 && DECL_INITIAL (expression))
21654 /* A variable template specialization is type-dependent if it has any
21655 dependent template arguments. */
21656 if (VAR_P (expression)
21657 && DECL_LANG_SPECIFIC (expression)
21658 && DECL_TEMPLATE_INFO (expression)
21659 && variable_template_p (DECL_TI_TEMPLATE (expression)))
21660 return any_dependent_template_arguments_p (DECL_TI_ARGS (expression));
21662 /* Always dependent, on the number of arguments if nothing else. */
21663 if (TREE_CODE (expression) == EXPR_PACK_EXPANSION)
21666 if (TREE_TYPE (expression) == unknown_type_node)
21668 if (TREE_CODE (expression) == ADDR_EXPR)
21669 return type_dependent_expression_p (TREE_OPERAND (expression, 0));
21670 if (TREE_CODE (expression) == COMPONENT_REF
21671 || TREE_CODE (expression) == OFFSET_REF)
21673 if (type_dependent_expression_p (TREE_OPERAND (expression, 0)))
21675 expression = TREE_OPERAND (expression, 1);
21676 if (identifier_p (expression))
21679 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
21680 if (TREE_CODE (expression) == SCOPE_REF)
21683 if (BASELINK_P (expression))
21685 if (BASELINK_OPTYPE (expression)
21686 && dependent_type_p (BASELINK_OPTYPE (expression)))
21688 expression = BASELINK_FUNCTIONS (expression);
21691 if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
21693 if (any_dependent_template_arguments_p
21694 (TREE_OPERAND (expression, 1)))
21696 expression = TREE_OPERAND (expression, 0);
21698 gcc_assert (TREE_CODE (expression) == OVERLOAD
21699 || TREE_CODE (expression) == FUNCTION_DECL);
21703 if (type_dependent_expression_p (OVL_CURRENT (expression)))
21705 expression = OVL_NEXT (expression);
21710 gcc_assert (TREE_CODE (expression) != TYPE_DECL);
21712 return (dependent_type_p (TREE_TYPE (expression)));
21715 /* walk_tree callback function for instantiation_dependent_expression_p,
21716 below. Returns non-zero if a dependent subexpression is found. */
21719 instantiation_dependent_r (tree *tp, int *walk_subtrees,
21724 /* We don't have to worry about decltype currently because decltype
21725 of an instantiation-dependent expr is a dependent type. This
21726 might change depending on the resolution of DR 1172. */
21727 *walk_subtrees = false;
21730 enum tree_code code = TREE_CODE (*tp);
21733 /* Don't treat an argument list as dependent just because it has no
21741 /* A constant with a dependent initializer is dependent. */
21742 if (value_dependent_expression_p (*tp))
21746 case TEMPLATE_PARM_INDEX:
21749 /* Handle expressions with type operands. */
21753 case AT_ENCODE_EXPR:
21755 tree op = TREE_OPERAND (*tp, 0);
21756 if (code == SIZEOF_EXPR && SIZEOF_EXPR_TYPE_P (*tp))
21757 op = TREE_TYPE (op);
21760 if (dependent_type_p (op))
21764 *walk_subtrees = false;
21772 if (dependent_type_p (TRAIT_EXPR_TYPE1 (*tp))
21773 || (TRAIT_EXPR_TYPE2 (*tp)
21774 && dependent_type_p (TRAIT_EXPR_TYPE2 (*tp))))
21776 *walk_subtrees = false;
21779 case COMPONENT_REF:
21780 if (identifier_p (TREE_OPERAND (*tp, 1)))
21781 /* In a template, finish_class_member_access_expr creates a
21782 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
21783 type-dependent, so that we can check access control at
21784 instantiation time (PR 42277). See also Core issue 1273. */
21789 if (instantiation_dependent_scope_ref_p (*tp))
21794 /* Treat statement-expressions as dependent. */
21802 if (type_dependent_expression_p (*tp))
21808 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
21809 sense defined by the ABI:
21811 "An expression is instantiation-dependent if it is type-dependent
21812 or value-dependent, or it has a subexpression that is type-dependent
21813 or value-dependent." */
21816 instantiation_dependent_expression_p (tree expression)
21820 if (!processing_template_decl)
21823 if (expression == error_mark_node)
21826 result = cp_walk_tree_without_duplicates (&expression,
21827 instantiation_dependent_r, NULL);
21828 return result != NULL_TREE;
21831 /* Like type_dependent_expression_p, but it also works while not processing
21832 a template definition, i.e. during substitution or mangling. */
21835 type_dependent_expression_p_push (tree expr)
21838 ++processing_template_decl;
21839 b = type_dependent_expression_p (expr);
21840 --processing_template_decl;
21844 /* Returns TRUE if ARGS contains a type-dependent expression. */
21847 any_type_dependent_arguments_p (const vec<tree, va_gc> *args)
21852 FOR_EACH_VEC_SAFE_ELT (args, i, arg)
21854 if (type_dependent_expression_p (arg))
21860 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21861 expressions) contains any type-dependent expressions. */
21864 any_type_dependent_elements_p (const_tree list)
21866 for (; list; list = TREE_CHAIN (list))
21867 if (type_dependent_expression_p (TREE_VALUE (list)))
21873 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
21874 expressions) contains any value-dependent expressions. */
21877 any_value_dependent_elements_p (const_tree list)
21879 for (; list; list = TREE_CHAIN (list))
21880 if (value_dependent_expression_p (TREE_VALUE (list)))
21886 /* Returns TRUE if the ARG (a template argument) is dependent. */
21889 dependent_template_arg_p (tree arg)
21891 if (!processing_template_decl)
21894 /* Assume a template argument that was wrongly written by the user
21895 is dependent. This is consistent with what
21896 any_dependent_template_arguments_p [that calls this function]
21898 if (!arg || arg == error_mark_node)
21901 if (TREE_CODE (arg) == ARGUMENT_PACK_SELECT)
21902 arg = ARGUMENT_PACK_SELECT_ARG (arg);
21904 if (TREE_CODE (arg) == TEMPLATE_DECL
21905 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
21906 return dependent_template_p (arg);
21907 else if (ARGUMENT_PACK_P (arg))
21909 tree args = ARGUMENT_PACK_ARGS (arg);
21910 int i, len = TREE_VEC_LENGTH (args);
21911 for (i = 0; i < len; ++i)
21913 if (dependent_template_arg_p (TREE_VEC_ELT (args, i)))
21919 else if (TYPE_P (arg))
21920 return dependent_type_p (arg);
21922 return (type_dependent_expression_p (arg)
21923 || value_dependent_expression_p (arg));
21926 /* Returns true if ARGS (a collection of template arguments) contains
21927 any types that require structural equality testing. */
21930 any_template_arguments_need_structural_equality_p (tree args)
21937 if (args == error_mark_node)
21940 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
21942 tree level = TMPL_ARGS_LEVEL (args, i + 1);
21943 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
21945 tree arg = TREE_VEC_ELT (level, j);
21946 tree packed_args = NULL_TREE;
21949 if (ARGUMENT_PACK_P (arg))
21951 /* Look inside the argument pack. */
21952 packed_args = ARGUMENT_PACK_ARGS (arg);
21953 len = TREE_VEC_LENGTH (packed_args);
21956 for (k = 0; k < len; ++k)
21959 arg = TREE_VEC_ELT (packed_args, k);
21961 if (error_operand_p (arg))
21963 else if (TREE_CODE (arg) == TEMPLATE_DECL)
21965 else if (TYPE_P (arg) && TYPE_STRUCTURAL_EQUALITY_P (arg))
21967 else if (!TYPE_P (arg) && TREE_TYPE (arg)
21968 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg)))
21977 /* Returns true if ARGS (a collection of template arguments) contains
21978 any dependent arguments. */
21981 any_dependent_template_arguments_p (const_tree args)
21988 if (args == error_mark_node)
21991 for (i = 0; i < TMPL_ARGS_DEPTH (args); ++i)
21993 const_tree level = TMPL_ARGS_LEVEL (args, i + 1);
21994 for (j = 0; j < TREE_VEC_LENGTH (level); ++j)
21995 if (dependent_template_arg_p (TREE_VEC_ELT (level, j)))
22002 /* Returns TRUE if the template TMPL is dependent. */
22005 dependent_template_p (tree tmpl)
22007 if (TREE_CODE (tmpl) == OVERLOAD)
22011 if (dependent_template_p (OVL_CURRENT (tmpl)))
22013 tmpl = OVL_NEXT (tmpl);
22018 /* Template template parameters are dependent. */
22019 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl)
22020 || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
22022 /* So are names that have not been looked up. */
22023 if (TREE_CODE (tmpl) == SCOPE_REF || identifier_p (tmpl))
22025 /* So are member templates of dependent classes. */
22026 if (TYPE_P (CP_DECL_CONTEXT (tmpl)))
22027 return dependent_type_p (DECL_CONTEXT (tmpl));
22031 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
22034 dependent_template_id_p (tree tmpl, tree args)
22036 return (dependent_template_p (tmpl)
22037 || any_dependent_template_arguments_p (args));
22040 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
22044 dependent_omp_for_p (tree declv, tree initv, tree condv, tree incrv)
22048 if (!processing_template_decl)
22051 for (i = 0; i < TREE_VEC_LENGTH (declv); i++)
22053 tree decl = TREE_VEC_ELT (declv, i);
22054 tree init = TREE_VEC_ELT (initv, i);
22055 tree cond = TREE_VEC_ELT (condv, i);
22056 tree incr = TREE_VEC_ELT (incrv, i);
22058 if (type_dependent_expression_p (decl))
22061 if (init && type_dependent_expression_p (init))
22064 if (type_dependent_expression_p (cond))
22067 if (COMPARISON_CLASS_P (cond)
22068 && (type_dependent_expression_p (TREE_OPERAND (cond, 0))
22069 || type_dependent_expression_p (TREE_OPERAND (cond, 1))))
22072 if (TREE_CODE (incr) == MODOP_EXPR)
22074 if (type_dependent_expression_p (TREE_OPERAND (incr, 0))
22075 || type_dependent_expression_p (TREE_OPERAND (incr, 2)))
22078 else if (type_dependent_expression_p (incr))
22080 else if (TREE_CODE (incr) == MODIFY_EXPR)
22082 if (type_dependent_expression_p (TREE_OPERAND (incr, 0)))
22084 else if (BINARY_CLASS_P (TREE_OPERAND (incr, 1)))
22086 tree t = TREE_OPERAND (incr, 1);
22087 if (type_dependent_expression_p (TREE_OPERAND (t, 0))
22088 || type_dependent_expression_p (TREE_OPERAND (t, 1)))
22097 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
22098 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
22099 no such TYPE can be found. Note that this function peers inside
22100 uninstantiated templates and therefore should be used only in
22101 extremely limited situations. ONLY_CURRENT_P restricts this
22102 peering to the currently open classes hierarchy (which is required
22103 when comparing types). */
22106 resolve_typename_type (tree type, bool only_current_p)
22115 gcc_assert (TREE_CODE (type) == TYPENAME_TYPE);
22117 scope = TYPE_CONTEXT (type);
22118 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
22119 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
22120 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
22121 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
22122 identifier of the TYPENAME_TYPE anymore.
22123 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
22124 TYPENAME_TYPE instead, we avoid messing up with a possible
22125 typedef variant case. */
22126 name = TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
22128 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
22129 it first before we can figure out what NAME refers to. */
22130 if (TREE_CODE (scope) == TYPENAME_TYPE)
22132 if (TYPENAME_IS_RESOLVING_P (scope))
22133 /* Given a class template A with a dependent base with nested type C,
22134 typedef typename A::C::C C will land us here, as trying to resolve
22135 the initial A::C leads to the local C typedef, which leads back to
22136 A::C::C. So we break the recursion now. */
22139 scope = resolve_typename_type (scope, only_current_p);
22141 /* If we don't know what SCOPE refers to, then we cannot resolve the
22143 if (TREE_CODE (scope) == TYPENAME_TYPE)
22145 /* If the SCOPE is a template type parameter, we have no way of
22146 resolving the name. */
22147 if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
22149 /* If the SCOPE is not the current instantiation, there's no reason
22150 to look inside it. */
22151 if (only_current_p && !currently_open_class (scope))
22153 /* If this is a typedef, we don't want to look inside (c++/11987). */
22154 if (typedef_variant_p (type))
22156 /* If SCOPE isn't the template itself, it will not have a valid
22157 TYPE_FIELDS list. */
22158 if (same_type_p (scope, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope)))
22159 /* scope is either the template itself or a compatible instantiation
22160 like X<T>, so look up the name in the original template. */
22161 scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope);
22163 /* scope is a partial instantiation, so we can't do the lookup or we
22164 will lose the template arguments. */
22166 /* Enter the SCOPE so that name lookup will be resolved as if we
22167 were in the class definition. In particular, SCOPE will no
22168 longer be considered a dependent type. */
22169 pushed_scope = push_scope (scope);
22170 /* Look up the declaration. */
22171 decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true,
22172 tf_warning_or_error);
22174 result = NULL_TREE;
22176 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
22177 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
22180 else if (identifier_p (TYPENAME_TYPE_FULLNAME (type))
22181 && TREE_CODE (decl) == TYPE_DECL)
22183 result = TREE_TYPE (decl);
22184 if (result == error_mark_node)
22185 result = NULL_TREE;
22187 else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == TEMPLATE_ID_EXPR
22188 && DECL_CLASS_TEMPLATE_P (decl))
22192 /* Obtain the template and the arguments. */
22193 tmpl = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 0);
22194 args = TREE_OPERAND (TYPENAME_TYPE_FULLNAME (type), 1);
22195 /* Instantiate the template. */
22196 result = lookup_template_class (tmpl, args, NULL_TREE, NULL_TREE,
22197 /*entering_scope=*/0,
22198 tf_error | tf_user);
22199 if (result == error_mark_node)
22200 result = NULL_TREE;
22203 /* Leave the SCOPE. */
22205 pop_scope (pushed_scope);
22207 /* If we failed to resolve it, return the original typename. */
22211 /* If lookup found a typename type, resolve that too. */
22212 if (TREE_CODE (result) == TYPENAME_TYPE && !TYPENAME_IS_RESOLVING_P (result))
22214 /* Ill-formed programs can cause infinite recursion here, so we
22215 must catch that. */
22216 TYPENAME_IS_RESOLVING_P (result) = 1;
22217 result = resolve_typename_type (result, only_current_p);
22218 TYPENAME_IS_RESOLVING_P (result) = 0;
22221 /* Qualify the resulting type. */
22222 quals = cp_type_quals (type);
22224 result = cp_build_qualified_type (result, cp_type_quals (result) | quals);
22229 /* EXPR is an expression which is not type-dependent. Return a proxy
22230 for EXPR that can be used to compute the types of larger
22231 expressions containing EXPR. */
22234 build_non_dependent_expr (tree expr)
22238 #ifdef ENABLE_CHECKING
22239 /* Try to get a constant value for all non-dependent expressions in
22240 order to expose bugs in *_dependent_expression_p and constexpr. */
22241 if (cxx_dialect >= cxx11)
22242 fold_non_dependent_expr (expr);
22245 /* Preserve OVERLOADs; the functions must be available to resolve
22248 if (TREE_CODE (inner_expr) == STMT_EXPR)
22249 inner_expr = stmt_expr_value_expr (inner_expr);
22250 if (TREE_CODE (inner_expr) == ADDR_EXPR)
22251 inner_expr = TREE_OPERAND (inner_expr, 0);
22252 if (TREE_CODE (inner_expr) == COMPONENT_REF)
22253 inner_expr = TREE_OPERAND (inner_expr, 1);
22254 if (is_overloaded_fn (inner_expr)
22255 || TREE_CODE (inner_expr) == OFFSET_REF)
22257 /* There is no need to return a proxy for a variable. */
22260 /* Preserve string constants; conversions from string constants to
22261 "char *" are allowed, even though normally a "const char *"
22262 cannot be used to initialize a "char *". */
22263 if (TREE_CODE (expr) == STRING_CST)
22265 /* Preserve void and arithmetic constants, as an optimization -- there is no
22266 reason to create a new node. */
22267 if (TREE_CODE (expr) == VOID_CST
22268 || TREE_CODE (expr) == INTEGER_CST
22269 || TREE_CODE (expr) == REAL_CST)
22271 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
22272 There is at least one place where we want to know that a
22273 particular expression is a throw-expression: when checking a ?:
22274 expression, there are special rules if the second or third
22275 argument is a throw-expression. */
22276 if (TREE_CODE (expr) == THROW_EXPR)
22279 /* Don't wrap an initializer list, we need to be able to look inside. */
22280 if (BRACE_ENCLOSED_INITIALIZER_P (expr))
22283 /* Don't wrap a dummy object, we need to be able to test for it. */
22284 if (is_dummy_object (expr))
22287 if (TREE_CODE (expr) == COND_EXPR)
22288 return build3 (COND_EXPR,
22290 TREE_OPERAND (expr, 0),
22291 (TREE_OPERAND (expr, 1)
22292 ? build_non_dependent_expr (TREE_OPERAND (expr, 1))
22293 : build_non_dependent_expr (TREE_OPERAND (expr, 0))),
22294 build_non_dependent_expr (TREE_OPERAND (expr, 2)));
22295 if (TREE_CODE (expr) == COMPOUND_EXPR
22296 && !COMPOUND_EXPR_OVERLOADED (expr))
22297 return build2 (COMPOUND_EXPR,
22299 TREE_OPERAND (expr, 0),
22300 build_non_dependent_expr (TREE_OPERAND (expr, 1)));
22302 /* If the type is unknown, it can't really be non-dependent */
22303 gcc_assert (TREE_TYPE (expr) != unknown_type_node);
22305 /* Otherwise, build a NON_DEPENDENT_EXPR. */
22306 return build1 (NON_DEPENDENT_EXPR, TREE_TYPE (expr), expr);
22309 /* ARGS is a vector of expressions as arguments to a function call.
22310 Replace the arguments with equivalent non-dependent expressions.
22311 This modifies ARGS in place. */
22314 make_args_non_dependent (vec<tree, va_gc> *args)
22319 FOR_EACH_VEC_SAFE_ELT (args, ix, arg)
22321 tree newarg = build_non_dependent_expr (arg);
22323 (*args)[ix] = newarg;
22327 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
22328 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
22332 make_auto_1 (tree name)
22334 tree au = cxx_make_type (TEMPLATE_TYPE_PARM);
22335 TYPE_NAME (au) = build_decl (input_location,
22336 TYPE_DECL, name, au);
22337 TYPE_STUB_DECL (au) = TYPE_NAME (au);
22338 TEMPLATE_TYPE_PARM_INDEX (au) = build_template_parm_index
22339 (0, processing_template_decl + 1, processing_template_decl + 1,
22340 TYPE_NAME (au), NULL_TREE);
22341 TYPE_CANONICAL (au) = canonical_type_parameter (au);
22342 DECL_ARTIFICIAL (TYPE_NAME (au)) = 1;
22343 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au));
22349 make_decltype_auto (void)
22351 return make_auto_1 (get_identifier ("decltype(auto)"));
22357 return make_auto_1 (get_identifier ("auto"));
22360 /* Given type ARG, return std::initializer_list<ARG>. */
22365 tree std_init_list = namespace_binding
22366 (get_identifier ("initializer_list"), std_node);
22368 if (!std_init_list || !DECL_CLASS_TEMPLATE_P (std_init_list))
22370 error ("deducing from brace-enclosed initializer list requires "
22371 "#include <initializer_list>");
22372 return error_mark_node;
22374 argvec = make_tree_vec (1);
22375 TREE_VEC_ELT (argvec, 0) = arg;
22376 return lookup_template_class (std_init_list, argvec, NULL_TREE,
22377 NULL_TREE, 0, tf_warning_or_error);
22380 /* Replace auto in TYPE with std::initializer_list<auto>. */
22383 listify_autos (tree type, tree auto_node)
22385 tree init_auto = listify (auto_node);
22386 tree argvec = make_tree_vec (1);
22387 TREE_VEC_ELT (argvec, 0) = init_auto;
22388 if (processing_template_decl)
22389 argvec = add_to_template_args (current_template_args (), argvec);
22390 return tsubst (type, argvec, tf_warning_or_error, NULL_TREE);
22393 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
22394 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
22397 do_auto_deduction (tree type, tree init, tree auto_node)
22401 if (init == error_mark_node)
22402 return error_mark_node;
22404 if (type_dependent_expression_p (init))
22405 /* Defining a subset of type-dependent expressions that we can deduce
22406 from ahead of time isn't worth the trouble. */
22409 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
22410 with either a new invented type template parameter U or, if the
22411 initializer is a braced-init-list (8.5.4), with
22412 std::initializer_list<U>. */
22413 if (BRACE_ENCLOSED_INITIALIZER_P (init))
22415 if (!DIRECT_LIST_INIT_P (init))
22416 type = listify_autos (type, auto_node);
22417 else if (CONSTRUCTOR_NELTS (init) == 1)
22418 init = CONSTRUCTOR_ELT (init, 0)->value;
22421 if (permerror (input_location, "direct-list-initialization of "
22422 "%<auto%> requires exactly one element"))
22423 inform (input_location,
22424 "for deduction to %<std::initializer_list%>, use copy-"
22425 "list-initialization (i.e. add %<=%> before the %<{%>)");
22426 type = listify_autos (type, auto_node);
22430 init = resolve_nondeduced_context (init, tf_warning_or_error);
22432 targs = make_tree_vec (1);
22433 if (AUTO_IS_DECLTYPE (auto_node))
22435 bool id = (DECL_P (init) || (TREE_CODE (init) == COMPONENT_REF
22436 && !REF_PARENTHESIZED_P (init)));
22437 TREE_VEC_ELT (targs, 0)
22438 = finish_decltype_type (init, id, tf_warning_or_error);
22439 if (type != auto_node)
22441 error ("%qT as type rather than plain %<decltype(auto)%>", type);
22442 return error_mark_node;
22447 tree parms = build_tree_list (NULL_TREE, type);
22448 tree tparms = make_tree_vec (1);
22451 TREE_VEC_ELT (tparms, 0)
22452 = build_tree_list (NULL_TREE, TYPE_NAME (auto_node));
22453 val = type_unification_real (tparms, targs, parms, &init, 1, 0,
22454 DEDUCE_CALL, LOOKUP_NORMAL,
22455 NULL, /*explain_p=*/false);
22458 if (processing_template_decl)
22459 /* Try again at instantiation time. */
22461 if (type && type != error_mark_node)
22462 /* If type is error_mark_node a diagnostic must have been
22463 emitted by now. Also, having a mention to '<type error>'
22464 in the diagnostic is not really useful to the user. */
22466 if (cfun && auto_node == current_function_auto_return_pattern
22467 && LAMBDA_FUNCTION_P (current_function_decl))
22468 error ("unable to deduce lambda return type from %qE", init);
22470 error ("unable to deduce %qT from %qE", type, init);
22472 return error_mark_node;
22476 /* If the list of declarators contains more than one declarator, the type
22477 of each declared variable is determined as described above. If the
22478 type deduced for the template parameter U is not the same in each
22479 deduction, the program is ill-formed. */
22480 if (TREE_TYPE (auto_node)
22481 && !same_type_p (TREE_TYPE (auto_node), TREE_VEC_ELT (targs, 0)))
22483 if (cfun && auto_node == current_function_auto_return_pattern
22484 && LAMBDA_FUNCTION_P (current_function_decl))
22485 error ("inconsistent types %qT and %qT deduced for "
22486 "lambda return type", TREE_TYPE (auto_node),
22487 TREE_VEC_ELT (targs, 0));
22489 error ("inconsistent deduction for %qT: %qT and then %qT",
22490 auto_node, TREE_TYPE (auto_node), TREE_VEC_ELT (targs, 0));
22491 return error_mark_node;
22493 TREE_TYPE (auto_node) = TREE_VEC_ELT (targs, 0);
22495 if (processing_template_decl)
22496 targs = add_to_template_args (current_template_args (), targs);
22497 return tsubst (type, targs, tf_warning_or_error, NULL_TREE);
22500 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
22504 splice_late_return_type (tree type, tree late_return_type)
22508 if (late_return_type == NULL_TREE)
22510 argvec = make_tree_vec (1);
22511 TREE_VEC_ELT (argvec, 0) = late_return_type;
22512 if (processing_template_parmlist)
22513 /* For a late-specified return type in a template type-parameter, we
22514 need to add a dummy argument level for its parmlist. */
22515 argvec = add_to_template_args
22516 (make_tree_vec (processing_template_parmlist), argvec);
22517 if (current_template_parms)
22518 argvec = add_to_template_args (current_template_args (), argvec);
22519 return tsubst (type, argvec, tf_warning_or_error, NULL_TREE);
22522 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
22523 'decltype(auto)'. */
22526 is_auto (const_tree type)
22528 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
22529 && (TYPE_IDENTIFIER (type) == get_identifier ("auto")
22530 || TYPE_IDENTIFIER (type) == get_identifier ("decltype(auto)")))
22536 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
22537 a use of `auto'. Returns NULL_TREE otherwise. */
22540 type_uses_auto (tree type)
22542 return find_type_usage (type, is_auto);
22545 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto',
22546 'decltype(auto)' or a concept. */
22549 is_auto_or_concept (const_tree type)
22551 return is_auto (type); // or concept
22554 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing a generic type (`auto' or
22555 a concept identifier) iff TYPE contains a use of a generic type. Returns
22556 NULL_TREE otherwise. */
22559 type_uses_auto_or_concept (tree type)
22561 return find_type_usage (type, is_auto_or_concept);
22565 /* For a given template T, return the vector of typedefs referenced
22566 in T for which access check is needed at T instantiation time.
22567 T is either a FUNCTION_DECL or a RECORD_TYPE.
22568 Those typedefs were added to T by the function
22569 append_type_to_template_for_access_check. */
22571 vec<qualified_typedef_usage_t, va_gc> *
22572 get_types_needing_access_check (tree t)
22575 vec<qualified_typedef_usage_t, va_gc> *result = NULL;
22577 if (!t || t == error_mark_node)
22580 if (!(ti = get_template_info (t)))
22583 if (CLASS_TYPE_P (t)
22584 || TREE_CODE (t) == FUNCTION_DECL)
22586 if (!TI_TEMPLATE (ti))
22589 result = TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti);
22595 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
22596 tied to T. That list of typedefs will be access checked at
22597 T instantiation time.
22598 T is either a FUNCTION_DECL or a RECORD_TYPE.
22599 TYPE_DECL is a TYPE_DECL node representing a typedef.
22600 SCOPE is the scope through which TYPE_DECL is accessed.
22601 LOCATION is the location of the usage point of TYPE_DECL.
22603 This function is a subroutine of
22604 append_type_to_template_for_access_check. */
22607 append_type_to_template_for_access_check_1 (tree t,
22610 location_t location)
22612 qualified_typedef_usage_t typedef_usage;
22615 if (!t || t == error_mark_node)
22618 gcc_assert ((TREE_CODE (t) == FUNCTION_DECL
22619 || CLASS_TYPE_P (t))
22621 && TREE_CODE (type_decl) == TYPE_DECL
22624 if (!(ti = get_template_info (t)))
22627 gcc_assert (TI_TEMPLATE (ti));
22629 typedef_usage.typedef_decl = type_decl;
22630 typedef_usage.context = scope;
22631 typedef_usage.locus = location;
22633 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti), typedef_usage);
22636 /* Append TYPE_DECL to the template TEMPL.
22637 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
22638 At TEMPL instanciation time, TYPE_DECL will be checked to see
22639 if it can be accessed through SCOPE.
22640 LOCATION is the location of the usage point of TYPE_DECL.
22642 e.g. consider the following code snippet:
22649 template<class U> struct S
22651 C::myint mi; // <-- usage point of the typedef C::myint
22656 At S<char> instantiation time, we need to check the access of C::myint
22657 In other words, we need to check the access of the myint typedef through
22658 the C scope. For that purpose, this function will add the myint typedef
22659 and the scope C through which its being accessed to a list of typedefs
22660 tied to the template S. That list will be walked at template instantiation
22661 time and access check performed on each typedefs it contains.
22662 Note that this particular code snippet should yield an error because
22663 myint is private to C. */
22666 append_type_to_template_for_access_check (tree templ,
22669 location_t location)
22671 qualified_typedef_usage_t *iter;
22674 gcc_assert (type_decl && (TREE_CODE (type_decl) == TYPE_DECL));
22676 /* Make sure we don't append the type to the template twice. */
22677 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ), i, iter)
22678 if (iter->typedef_decl == type_decl && scope == iter->context)
22681 append_type_to_template_for_access_check_1 (templ, type_decl,
22685 /* Convert the generic type parameters in PARM that match the types given in the
22686 range [START_IDX, END_IDX) from the current_template_parms into generic type
22690 convert_generic_types_to_packs (tree parm, int start_idx, int end_idx)
22692 tree current = current_template_parms;
22693 int depth = TMPL_PARMS_DEPTH (current);
22694 current = INNERMOST_TEMPLATE_PARMS (current);
22695 tree replacement = make_tree_vec (TREE_VEC_LENGTH (current));
22697 for (int i = 0; i < start_idx; ++i)
22698 TREE_VEC_ELT (replacement, i)
22699 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current, i)));
22701 for (int i = start_idx; i < end_idx; ++i)
22703 /* Create a distinct parameter pack type from the current parm and add it
22704 to the replacement args to tsubst below into the generic function
22707 tree o = TREE_TYPE (TREE_VALUE
22708 (TREE_VEC_ELT (current, i)));
22709 tree t = copy_type (o);
22710 TEMPLATE_TYPE_PARM_INDEX (t)
22711 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o),
22713 TREE_TYPE (TEMPLATE_TYPE_DECL (t)) = t;
22714 TYPE_STUB_DECL (t) = TYPE_NAME (t) = TEMPLATE_TYPE_DECL (t);
22715 TYPE_MAIN_VARIANT (t) = t;
22716 TEMPLATE_TYPE_PARAMETER_PACK (t) = true;
22717 TYPE_CANONICAL (t) = canonical_type_parameter (t);
22718 TREE_VEC_ELT (replacement, i) = t;
22719 TREE_VALUE (TREE_VEC_ELT (current, i)) = TREE_CHAIN (t);
22722 for (int i = end_idx, e = TREE_VEC_LENGTH (current); i < e; ++i)
22723 TREE_VEC_ELT (replacement, i)
22724 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current, i)));
22726 /* If there are more levels then build up the replacement with the outer
22729 replacement = add_to_template_args (template_parms_to_args
22730 (TREE_CHAIN (current_template_parms)),
22733 return tsubst (parm, replacement, tf_none, NULL_TREE);
22737 /* Set up the hash tables for template instantiations. */
22740 init_template_processing (void)
22742 decl_specializations = hash_table<spec_hasher>::create_ggc (37);
22743 type_specializations = hash_table<spec_hasher>::create_ggc (37);
22746 /* Print stats about the template hash tables for -fstats. */
22749 print_template_statistics (void)
22751 fprintf (stderr, "decl_specializations: size %ld, %ld elements, "
22752 "%f collisions\n", (long) decl_specializations->size (),
22753 (long) decl_specializations->elements (),
22754 decl_specializations->collisions ());
22755 fprintf (stderr, "type_specializations: size %ld, %ld elements, "
22756 "%f collisions\n", (long) type_specializations->size (),
22757 (long) type_specializations->elements (),
22758 type_specializations->collisions ());
22761 #include "gt-cp-pt.h"