1 /* Handle parameterized types (templates) for GNU -*- C++ -*-.
2 Copyright (C) 1992-2017 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"
32 #include "stringpool.h"
35 #include "stor-layout.h"
37 #include "c-family/c-objc.h"
38 #include "cp-objcp-common.h"
40 #include "tree-iterator.h"
41 #include "type-utils.h"
43 #include "gcc-rich-location.h"
45 /* The type of functions taking a tree, and some additional data, and
47 typedef int (*tree_fn_t
) (tree
, void*);
49 /* The PENDING_TEMPLATES is a TREE_LIST of templates whose
50 instantiations have been deferred, either because their definitions
51 were not yet available, or because we were putting off doing the work. */
52 struct GTY ((chain_next ("%h.next"))) pending_template
{
53 struct pending_template
*next
;
54 struct tinst_level
*tinst
;
57 static GTY(()) struct pending_template
*pending_templates
;
58 static GTY(()) struct pending_template
*last_pending_template
;
60 int processing_template_parmlist
;
61 static int template_header_count
;
63 static GTY(()) tree saved_trees
;
64 static vec
<int> inline_parm_levels
;
66 static GTY(()) struct tinst_level
*current_tinst_level
;
68 static GTY(()) tree saved_access_scope
;
70 /* Live only within one (recursive) call to tsubst_expr. We use
71 this to pass the statement expression node from the STMT_EXPR
72 to the EXPR_STMT that is its result. */
73 static tree cur_stmt_expr
;
75 // -------------------------------------------------------------------------- //
76 // Local Specialization Stack
78 // Implementation of the RAII helper for creating new local
80 local_specialization_stack::local_specialization_stack (lss_policy policy
)
81 : saved (local_specializations
)
83 if (policy
== lss_blank
|| !saved
)
84 local_specializations
= new hash_map
<tree
, tree
>;
86 local_specializations
= new hash_map
<tree
, tree
>(*saved
);
89 local_specialization_stack::~local_specialization_stack ()
91 delete local_specializations
;
92 local_specializations
= saved
;
95 /* True if we've recursed into fn_type_unification too many times. */
96 static bool excessive_deduction_depth
;
98 struct GTY((for_user
)) spec_entry
105 struct spec_hasher
: ggc_ptr_hash
<spec_entry
>
107 static hashval_t
hash (spec_entry
*);
108 static bool equal (spec_entry
*, spec_entry
*);
111 static GTY (()) hash_table
<spec_hasher
> *decl_specializations
;
113 static GTY (()) hash_table
<spec_hasher
> *type_specializations
;
115 /* Contains canonical template parameter types. The vector is indexed by
116 the TEMPLATE_TYPE_IDX of the template parameter. Each element is a
117 TREE_LIST, whose TREE_VALUEs contain the canonical template
118 parameters of various types and levels. */
119 static GTY(()) vec
<tree
, va_gc
> *canonical_template_parms
;
121 #define UNIFY_ALLOW_NONE 0
122 #define UNIFY_ALLOW_MORE_CV_QUAL 1
123 #define UNIFY_ALLOW_LESS_CV_QUAL 2
124 #define UNIFY_ALLOW_DERIVED 4
125 #define UNIFY_ALLOW_INTEGER 8
126 #define UNIFY_ALLOW_OUTER_LEVEL 16
127 #define UNIFY_ALLOW_OUTER_MORE_CV_QUAL 32
128 #define UNIFY_ALLOW_OUTER_LESS_CV_QUAL 64
130 enum template_base_result
{
132 tbr_ambiguous_baseclass
,
136 static void push_access_scope (tree
);
137 static void pop_access_scope (tree
);
138 static bool resolve_overloaded_unification (tree
, tree
, tree
, tree
,
139 unification_kind_t
, int,
141 static int try_one_overload (tree
, tree
, tree
, tree
, tree
,
142 unification_kind_t
, int, bool, bool);
143 static int unify (tree
, tree
, tree
, tree
, int, bool);
144 static void add_pending_template (tree
);
145 static tree
reopen_tinst_level (struct tinst_level
*);
146 static tree
tsubst_initializer_list (tree
, tree
);
147 static tree
get_partial_spec_bindings (tree
, tree
, tree
);
148 static tree
coerce_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
150 static tree
coerce_innermost_template_parms (tree
, tree
, tree
, tsubst_flags_t
,
152 static void tsubst_enum (tree
, tree
, tree
);
153 static tree
add_to_template_args (tree
, tree
);
154 static tree
add_outermost_template_args (tree
, tree
);
155 static bool check_instantiated_args (tree
, tree
, tsubst_flags_t
);
156 static int maybe_adjust_types_for_deduction (unification_kind_t
, tree
*, tree
*,
158 static int type_unification_real (tree
, tree
, tree
, const tree
*,
159 unsigned int, int, unification_kind_t
, int,
160 vec
<deferred_access_check
, va_gc
> **,
162 static void note_template_header (int);
163 static tree
convert_nontype_argument_function (tree
, tree
, tsubst_flags_t
);
164 static tree
convert_nontype_argument (tree
, tree
, tsubst_flags_t
);
165 static tree
convert_template_argument (tree
, tree
, tree
,
166 tsubst_flags_t
, int, tree
);
167 static tree
for_each_template_parm (tree
, tree_fn_t
, void*,
168 hash_set
<tree
> *, bool, tree_fn_t
= NULL
);
169 static tree
expand_template_argument_pack (tree
);
170 static tree
build_template_parm_index (int, int, int, tree
, tree
);
171 static bool inline_needs_template_parms (tree
, bool);
172 static void push_inline_template_parms_recursive (tree
, int);
173 static tree
reduce_template_parm_level (tree
, tree
, int, tree
, tsubst_flags_t
);
174 static int mark_template_parm (tree
, void *);
175 static int template_parm_this_level_p (tree
, void *);
176 static tree
tsubst_friend_function (tree
, tree
);
177 static tree
tsubst_friend_class (tree
, tree
);
178 static int can_complete_type_without_circularity (tree
);
179 static tree
get_bindings (tree
, tree
, tree
, bool);
180 static int template_decl_level (tree
);
181 static int check_cv_quals_for_unify (int, tree
, tree
);
182 static void template_parm_level_and_index (tree
, int*, int*);
183 static int unify_pack_expansion (tree
, tree
, tree
,
184 tree
, unification_kind_t
, bool, bool);
185 static tree
copy_template_args (tree
);
186 static tree
tsubst_template_arg (tree
, tree
, tsubst_flags_t
, tree
);
187 static tree
tsubst_template_args (tree
, tree
, tsubst_flags_t
, tree
);
188 static tree
tsubst_template_parms (tree
, tree
, tsubst_flags_t
);
189 static tree
most_specialized_partial_spec (tree
, tsubst_flags_t
);
190 static tree
tsubst_aggr_type (tree
, tree
, tsubst_flags_t
, tree
, int);
191 static tree
tsubst_arg_types (tree
, tree
, tree
, tsubst_flags_t
, tree
);
192 static tree
tsubst_function_type (tree
, tree
, tsubst_flags_t
, tree
);
193 static bool check_specialization_scope (void);
194 static tree
process_partial_specialization (tree
);
195 static void set_current_access_from_decl (tree
);
196 static enum template_base_result
get_template_base (tree
, tree
, tree
, tree
,
198 static tree
try_class_unification (tree
, tree
, tree
, tree
, bool);
199 static int coerce_template_template_parms (tree
, tree
, tsubst_flags_t
,
201 static bool template_template_parm_bindings_ok_p (tree
, tree
);
202 static void tsubst_default_arguments (tree
, tsubst_flags_t
);
203 static tree
for_each_template_parm_r (tree
*, int *, void *);
204 static tree
copy_default_args_to_explicit_spec_1 (tree
, tree
);
205 static void copy_default_args_to_explicit_spec (tree
);
206 static bool invalid_nontype_parm_type_p (tree
, tsubst_flags_t
);
207 static bool dependent_template_arg_p (tree
);
208 static bool any_template_arguments_need_structural_equality_p (tree
);
209 static bool dependent_type_p_r (tree
);
210 static tree
tsubst_copy (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
tsubst_template_parm (tree
, tree
, tsubst_flags_t
);
218 static tree
instantiate_alias_template (tree
, tree
, tsubst_flags_t
);
219 static bool complex_alias_template_p (const_tree tmpl
);
220 static tree
tsubst_attributes (tree
, tree
, tsubst_flags_t
, tree
);
221 static tree
canonicalize_expr_argument (tree
, tsubst_flags_t
);
222 static tree
make_argument_pack (tree
);
223 static void register_parameter_specializations (tree
, tree
);
225 /* Make the current scope suitable for access checking when we are
226 processing T. T can be FUNCTION_DECL for instantiated function
227 template, VAR_DECL for static member variable, or TYPE_DECL for
228 alias template (needed by instantiate_decl). */
231 push_access_scope (tree t
)
233 gcc_assert (VAR_OR_FUNCTION_DECL_P (t
)
234 || TREE_CODE (t
) == TYPE_DECL
);
236 if (DECL_FRIEND_CONTEXT (t
))
237 push_nested_class (DECL_FRIEND_CONTEXT (t
));
238 else if (DECL_CLASS_SCOPE_P (t
))
239 push_nested_class (DECL_CONTEXT (t
));
241 push_to_top_level ();
243 if (TREE_CODE (t
) == FUNCTION_DECL
)
245 saved_access_scope
= tree_cons
246 (NULL_TREE
, current_function_decl
, saved_access_scope
);
247 current_function_decl
= t
;
251 /* Restore the scope set up by push_access_scope. T is the node we
255 pop_access_scope (tree t
)
257 if (TREE_CODE (t
) == FUNCTION_DECL
)
259 current_function_decl
= TREE_VALUE (saved_access_scope
);
260 saved_access_scope
= TREE_CHAIN (saved_access_scope
);
263 if (DECL_FRIEND_CONTEXT (t
) || DECL_CLASS_SCOPE_P (t
))
266 pop_from_top_level ();
269 /* Do any processing required when DECL (a member template
270 declaration) is finished. Returns the TEMPLATE_DECL corresponding
271 to DECL, unless it is a specialization, in which case the DECL
272 itself is returned. */
275 finish_member_template_decl (tree decl
)
277 if (decl
== error_mark_node
)
278 return error_mark_node
;
280 gcc_assert (DECL_P (decl
));
282 if (TREE_CODE (decl
) == TYPE_DECL
)
286 type
= TREE_TYPE (decl
);
287 if (type
== error_mark_node
)
288 return error_mark_node
;
289 if (MAYBE_CLASS_TYPE_P (type
)
290 && CLASSTYPE_TEMPLATE_INFO (type
)
291 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
293 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
294 check_member_template (tmpl
);
299 else if (TREE_CODE (decl
) == FIELD_DECL
)
300 error ("data member %qD cannot be a member template", decl
);
301 else if (DECL_TEMPLATE_INFO (decl
))
303 if (!DECL_TEMPLATE_SPECIALIZATION (decl
))
305 check_member_template (DECL_TI_TEMPLATE (decl
));
306 return DECL_TI_TEMPLATE (decl
);
312 error ("invalid member template declaration %qD", decl
);
314 return error_mark_node
;
317 /* Create a template info node. */
320 build_template_info (tree template_decl
, tree template_args
)
322 tree result
= make_node (TEMPLATE_INFO
);
323 TI_TEMPLATE (result
) = template_decl
;
324 TI_ARGS (result
) = template_args
;
328 /* Return the template info node corresponding to T, whatever T is. */
331 get_template_info (const_tree t
)
333 tree tinfo
= NULL_TREE
;
335 if (!t
|| t
== error_mark_node
)
338 if (TREE_CODE (t
) == NAMESPACE_DECL
339 || TREE_CODE (t
) == PARM_DECL
)
342 if (DECL_P (t
) && DECL_LANG_SPECIFIC (t
))
343 tinfo
= DECL_TEMPLATE_INFO (t
);
345 if (!tinfo
&& DECL_IMPLICIT_TYPEDEF_P (t
))
348 if (OVERLOAD_TYPE_P (t
))
349 tinfo
= TYPE_TEMPLATE_INFO (t
);
350 else if (TREE_CODE (t
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
351 tinfo
= TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t
);
356 /* Returns the template nesting level of the indicated class TYPE.
366 A<T>::B<U> has depth two, while A<T> has depth one.
367 Both A<T>::B<int> and A<int>::B<U> have depth one, if
368 they are instantiations, not specializations.
370 This function is guaranteed to return 0 if passed NULL_TREE so
371 that, for example, `template_class_depth (current_class_type)' is
375 template_class_depth (tree type
)
379 for (depth
= 0; type
&& TREE_CODE (type
) != NAMESPACE_DECL
; )
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
))))
388 type
= CP_DECL_CONTEXT (type
);
389 else if (LAMBDA_TYPE_P (type
))
390 type
= LAMBDA_TYPE_EXTRA_SCOPE (type
);
392 type
= CP_TYPE_CONTEXT (type
);
398 /* Subroutine of maybe_begin_member_template_processing.
399 Returns true if processing DECL needs us to push template parms. */
402 inline_needs_template_parms (tree decl
, bool nsdmi
)
404 if (!decl
|| (!nsdmi
&& ! DECL_TEMPLATE_INFO (decl
)))
407 return (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (most_general_template (decl
)))
408 > (processing_template_decl
+ DECL_TEMPLATE_SPECIALIZATION (decl
)));
411 /* Subroutine of maybe_begin_member_template_processing.
412 Push the template parms in PARMS, starting from LEVELS steps into the
413 chain, and ending at the beginning, since template parms are listed
417 push_inline_template_parms_recursive (tree parmlist
, int levels
)
419 tree parms
= TREE_VALUE (parmlist
);
423 push_inline_template_parms_recursive (TREE_CHAIN (parmlist
), levels
- 1);
425 ++processing_template_decl
;
426 current_template_parms
427 = tree_cons (size_int (processing_template_decl
),
428 parms
, current_template_parms
);
429 TEMPLATE_PARMS_FOR_INLINE (current_template_parms
) = 1;
431 begin_scope (TREE_VEC_LENGTH (parms
) ? sk_template_parms
: sk_template_spec
,
433 for (i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
435 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
437 if (error_operand_p (parm
))
440 gcc_assert (DECL_P (parm
));
442 switch (TREE_CODE (parm
))
450 /* Push the CONST_DECL. */
451 pushdecl (TEMPLATE_PARM_DECL (DECL_INITIAL (parm
)));
460 /* Restore the template parameter context for a member template, a
461 friend template defined in a class definition, or a non-template
462 member of template class. */
465 maybe_begin_member_template_processing (tree decl
)
469 bool nsdmi
= TREE_CODE (decl
) == FIELD_DECL
;
473 tree ctx
= DECL_CONTEXT (decl
);
474 decl
= (CLASSTYPE_TEMPLATE_INFO (ctx
)
475 /* Disregard full specializations (c++/60999). */
476 && uses_template_parms (ctx
)
477 ? CLASSTYPE_TI_TEMPLATE (ctx
) : NULL_TREE
);
480 if (inline_needs_template_parms (decl
, nsdmi
))
482 parms
= DECL_TEMPLATE_PARMS (most_general_template (decl
));
483 levels
= TMPL_PARMS_DEPTH (parms
) - processing_template_decl
;
485 if (DECL_TEMPLATE_SPECIALIZATION (decl
))
488 parms
= TREE_CHAIN (parms
);
491 push_inline_template_parms_recursive (parms
, levels
);
494 /* Remember how many levels of template parameters we pushed so that
495 we can pop them later. */
496 inline_parm_levels
.safe_push (levels
);
499 /* Undo the effects of maybe_begin_member_template_processing. */
502 maybe_end_member_template_processing (void)
507 if (inline_parm_levels
.length () == 0)
510 last
= inline_parm_levels
.pop ();
511 for (i
= 0; i
< last
; ++i
)
513 --processing_template_decl
;
514 current_template_parms
= TREE_CHAIN (current_template_parms
);
519 /* Return a new template argument vector which contains all of ARGS,
520 but has as its innermost set of arguments the EXTRA_ARGS. */
523 add_to_template_args (tree args
, tree extra_args
)
530 if (args
== NULL_TREE
|| extra_args
== error_mark_node
)
533 extra_depth
= TMPL_ARGS_DEPTH (extra_args
);
534 new_args
= make_tree_vec (TMPL_ARGS_DEPTH (args
) + extra_depth
);
536 for (i
= 1; i
<= TMPL_ARGS_DEPTH (args
); ++i
)
537 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (args
, i
));
539 for (j
= 1; j
<= extra_depth
; ++j
, ++i
)
540 SET_TMPL_ARGS_LEVEL (new_args
, i
, TMPL_ARGS_LEVEL (extra_args
, j
));
545 /* Like add_to_template_args, but only the outermost ARGS are added to
546 the EXTRA_ARGS. In particular, all but TMPL_ARGS_DEPTH
547 (EXTRA_ARGS) levels are added. This function is used to combine
548 the template arguments from a partial instantiation with the
549 template arguments used to attain the full instantiation from the
550 partial instantiation. */
553 add_outermost_template_args (tree args
, tree extra_args
)
557 /* If there are more levels of EXTRA_ARGS than there are ARGS,
558 something very fishy is going on. */
559 gcc_assert (TMPL_ARGS_DEPTH (args
) >= TMPL_ARGS_DEPTH (extra_args
));
561 /* If *all* the new arguments will be the EXTRA_ARGS, just return
563 if (TMPL_ARGS_DEPTH (args
) == TMPL_ARGS_DEPTH (extra_args
))
566 /* For the moment, we make ARGS look like it contains fewer levels. */
567 TREE_VEC_LENGTH (args
) -= TMPL_ARGS_DEPTH (extra_args
);
569 new_args
= add_to_template_args (args
, extra_args
);
571 /* Now, we restore ARGS to its full dimensions. */
572 TREE_VEC_LENGTH (args
) += TMPL_ARGS_DEPTH (extra_args
);
577 /* Return the N levels of innermost template arguments from the ARGS. */
580 get_innermost_template_args (tree args
, int n
)
588 /* If N is 1, just return the innermost set of template arguments. */
590 return TMPL_ARGS_LEVEL (args
, TMPL_ARGS_DEPTH (args
));
592 /* If we're not removing anything, just return the arguments we were
594 extra_levels
= TMPL_ARGS_DEPTH (args
) - n
;
595 gcc_assert (extra_levels
>= 0);
596 if (extra_levels
== 0)
599 /* Make a new set of arguments, not containing the outer arguments. */
600 new_args
= make_tree_vec (n
);
601 for (i
= 1; i
<= n
; ++i
)
602 SET_TMPL_ARGS_LEVEL (new_args
, i
,
603 TMPL_ARGS_LEVEL (args
, i
+ extra_levels
));
608 /* The inverse of get_innermost_template_args: Return all but the innermost
609 EXTRA_LEVELS levels of template arguments from the ARGS. */
612 strip_innermost_template_args (tree args
, int extra_levels
)
615 int n
= TMPL_ARGS_DEPTH (args
) - extra_levels
;
620 /* If N is 1, just return the outermost set of template arguments. */
622 return TMPL_ARGS_LEVEL (args
, 1);
624 /* If we're not removing anything, just return the arguments we were
626 gcc_assert (extra_levels
>= 0);
627 if (extra_levels
== 0)
630 /* Make a new set of arguments, not containing the inner arguments. */
631 new_args
= make_tree_vec (n
);
632 for (i
= 1; i
<= n
; ++i
)
633 SET_TMPL_ARGS_LEVEL (new_args
, i
,
634 TMPL_ARGS_LEVEL (args
, i
));
639 /* We've got a template header coming up; push to a new level for storing
643 begin_template_parm_list (void)
645 /* We use a non-tag-transparent scope here, which causes pushtag to
646 put tags in this scope, rather than in the enclosing class or
647 namespace scope. This is the right thing, since we want
648 TEMPLATE_DECLS, and not TYPE_DECLS for template classes. For a
649 global template class, push_template_decl handles putting the
650 TEMPLATE_DECL into top-level scope. For a nested template class,
653 template <class T> struct S1 {
654 template <class T> struct S2 {};
657 pushtag contains special code to insert the TEMPLATE_DECL for S2
658 at the right scope. */
659 begin_scope (sk_template_parms
, NULL
);
660 ++processing_template_decl
;
661 ++processing_template_parmlist
;
662 note_template_header (0);
664 /* Add a dummy parameter level while we process the parameter list. */
665 current_template_parms
666 = tree_cons (size_int (processing_template_decl
),
668 current_template_parms
);
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 a namespace enclosing the
782 specialized template. An explicit specialization whose declarator-id is
783 not qualified shall be declared in the nearest enclosing namespace of the
784 template, or, if the namespace is inline (7.3.1), any namespace from its
785 enclosing namespace set. */
786 if (current_scope() != DECL_CONTEXT (tmpl
)
787 && !at_namespace_scope_p ())
789 error ("specialization of %qD must appear at namespace scope", tmpl
);
793 if (is_nested_namespace (current_namespace
, tpl_ns
, cxx_dialect
< cxx11
))
794 /* Same or enclosing namespace. */
798 permerror (input_location
,
799 "specialization of %qD in different namespace", tmpl
);
800 inform (DECL_SOURCE_LOCATION (tmpl
),
801 " from definition of %q#D", tmpl
);
806 /* SPEC is an explicit instantiation. Check that it is valid to
807 perform this explicit instantiation in the current namespace. */
810 check_explicit_instantiation_namespace (tree spec
)
814 /* DR 275: An explicit instantiation shall appear in an enclosing
815 namespace of its template. */
816 ns
= decl_namespace_context (spec
);
817 if (!is_nested_namespace (current_namespace
, ns
))
818 permerror (input_location
, "explicit instantiation of %qD in namespace %qD "
819 "(which does not enclose namespace %qD)",
820 spec
, current_namespace
, ns
);
823 // Returns the type of a template specialization only if that
824 // specialization needs to be defined. Otherwise (e.g., if the type has
825 // already been defined), the function returns NULL_TREE.
827 maybe_new_partial_specialization (tree type
)
829 // An implicit instantiation of an incomplete type implies
830 // the definition of a new class template.
832 // template<typename T>
835 // template<typename T>
838 // Here, S<T*> is an implicit instantiation of S whose type
840 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type
) && !COMPLETE_TYPE_P (type
))
843 // It can also be the case that TYPE is a completed specialization.
844 // Continuing the previous example, suppose we also declare:
846 // template<typename T>
847 // requires Integral<T>
850 // Here, S<T*> refers to the specialization S<T*> defined
851 // above. However, we need to differentiate definitions because
852 // we intend to define a new partial specialization. In this case,
853 // we rely on the fact that the constraints are different for
854 // this declaration than that above.
856 // Note that we also get here for injected class names and
857 // late-parsed template definitions. We must ensure that we
858 // do not create new type declarations for those cases.
859 if (flag_concepts
&& CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
861 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
862 tree args
= CLASSTYPE_TI_ARGS (type
);
864 // If there are no template parameters, this cannot be a new
865 // partial template specializtion?
866 if (!current_template_parms
)
869 // The injected-class-name is not a new partial specialization.
870 if (DECL_SELF_REFERENCE_P (TYPE_NAME (type
)))
873 // If the constraints are not the same as those of the primary
874 // then, we can probably create a new specialization.
875 tree type_constr
= current_template_constraints ();
877 if (type
== TREE_TYPE (tmpl
))
879 tree main_constr
= get_constraints (tmpl
);
880 if (equivalent_constraints (type_constr
, main_constr
))
884 // Also, if there's a pre-existing specialization with matching
885 // constraints, then this also isn't new.
886 tree specs
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
889 tree spec_tmpl
= TREE_VALUE (specs
);
890 tree spec_args
= TREE_PURPOSE (specs
);
891 tree spec_constr
= get_constraints (spec_tmpl
);
892 if (comp_template_args (args
, spec_args
)
893 && equivalent_constraints (type_constr
, spec_constr
))
895 specs
= TREE_CHAIN (specs
);
898 // Create a new type node (and corresponding type decl)
899 // for the newly declared specialization.
900 tree t
= make_class_type (TREE_CODE (type
));
901 CLASSTYPE_DECLARED_CLASS (t
) = CLASSTYPE_DECLARED_CLASS (type
);
902 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (tmpl
, args
));
904 /* We only need a separate type node for storing the definition of this
905 partial specialization; uses of S<T*> are unconstrained, so all are
906 equivalent. So keep TYPE_CANONICAL the same. */
907 TYPE_CANONICAL (t
) = TYPE_CANONICAL (type
);
909 // Build the corresponding type decl.
910 tree d
= create_implicit_typedef (DECL_NAME (tmpl
), t
);
911 DECL_CONTEXT (d
) = TYPE_CONTEXT (t
);
912 DECL_SOURCE_LOCATION (d
) = input_location
;
920 /* The TYPE is being declared. If it is a template type, that means it
921 is a partial specialization. Do appropriate error-checking. */
924 maybe_process_partial_specialization (tree type
)
928 if (type
== error_mark_node
)
929 return error_mark_node
;
931 /* A lambda that appears in specialization context is not itself a
933 if (CLASS_TYPE_P (type
) && CLASSTYPE_LAMBDA_EXPR (type
))
936 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
938 error ("name of class shadows template template parameter %qD",
940 return error_mark_node
;
943 context
= TYPE_CONTEXT (type
);
945 if (TYPE_ALIAS_P (type
))
947 tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (type
);
949 if (tinfo
&& DECL_ALIAS_TEMPLATE_P (TI_TEMPLATE (tinfo
)))
950 error ("specialization of alias template %qD",
951 TI_TEMPLATE (tinfo
));
953 error ("explicit specialization of non-template %qT", type
);
954 return error_mark_node
;
956 else if (CLASS_TYPE_P (type
) && CLASSTYPE_USE_TEMPLATE (type
))
958 /* This is for ordinary explicit specialization and partial
959 specialization of a template class such as:
961 template <> class C<int>;
965 template <class T> class C<T*>;
967 Make sure that `C<int>' and `C<T*>' are implicit instantiations. */
969 if (tree t
= maybe_new_partial_specialization (type
))
971 if (!check_specialization_namespace (CLASSTYPE_TI_TEMPLATE (t
))
972 && !at_namespace_scope_p ())
973 return error_mark_node
;
974 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (t
);
975 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (t
)) = input_location
;
976 if (processing_template_decl
)
978 tree decl
= push_template_decl (TYPE_MAIN_DECL (t
));
979 if (decl
== error_mark_node
)
980 return error_mark_node
;
981 return TREE_TYPE (decl
);
984 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type
))
985 error ("specialization of %qT after instantiation", type
);
986 else if (errorcount
&& !processing_specialization
987 && CLASSTYPE_TEMPLATE_SPECIALIZATION (type
)
988 && !uses_template_parms (CLASSTYPE_TI_ARGS (type
)))
989 /* Trying to define a specialization either without a template<> header
990 or in an inappropriate place. We've already given an error, so just
991 bail now so we don't actually define the specialization. */
992 return error_mark_node
;
994 else if (CLASS_TYPE_P (type
)
995 && !CLASSTYPE_USE_TEMPLATE (type
)
996 && CLASSTYPE_TEMPLATE_INFO (type
)
997 && context
&& CLASS_TYPE_P (context
)
998 && CLASSTYPE_TEMPLATE_INFO (context
))
1000 /* This is for an explicit specialization of member class
1001 template according to [temp.expl.spec/18]:
1003 template <> template <class U> class C<int>::D;
1005 The context `C<int>' must be an implicit instantiation.
1006 Otherwise this is just a member class template declared
1009 template <> class C<int> { template <class U> class D; };
1010 template <> template <class U> class C<int>::D;
1012 In the first case, `C<int>::D' is a specialization of `C<T>::D'
1013 while in the second case, `C<int>::D' is a primary template
1014 and `C<T>::D' may not exist. */
1016 if (CLASSTYPE_IMPLICIT_INSTANTIATION (context
)
1017 && !COMPLETE_TYPE_P (type
))
1020 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
1022 if (current_namespace
1023 != decl_namespace_context (tmpl
))
1025 permerror (input_location
,
1026 "specializing %q#T in different namespace", type
);
1027 permerror (DECL_SOURCE_LOCATION (tmpl
),
1028 " from definition of %q#D", tmpl
);
1031 /* Check for invalid specialization after instantiation:
1033 template <> template <> class C<int>::D<int>;
1034 template <> template <class U> class C<int>::D; */
1036 for (t
= DECL_TEMPLATE_INSTANTIATIONS (tmpl
);
1037 t
; t
= TREE_CHAIN (t
))
1039 tree inst
= TREE_VALUE (t
);
1040 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (inst
)
1041 || !COMPLETE_OR_OPEN_TYPE_P (inst
))
1043 /* We already have a full specialization of this partial
1044 instantiation, or a full specialization has been
1045 looked up but not instantiated. Reassign it to the
1046 new member specialization template. */
1050 elt
.tmpl
= most_general_template (tmpl
);
1051 elt
.args
= CLASSTYPE_TI_ARGS (inst
);
1054 type_specializations
->remove_elt (&elt
);
1057 elt
.args
= INNERMOST_TEMPLATE_ARGS (elt
.args
);
1060 = type_specializations
->find_slot (&elt
, INSERT
);
1061 entry
= ggc_alloc
<spec_entry
> ();
1066 /* But if we've had an implicit instantiation, that's a
1067 problem ([temp.expl.spec]/6). */
1068 error ("specialization %qT after instantiation %qT",
1072 /* Mark TYPE as a specialization. And as a result, we only
1073 have one level of template argument for the innermost
1075 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (type
);
1076 DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)) = input_location
;
1077 CLASSTYPE_TI_ARGS (type
)
1078 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
));
1081 else if (processing_specialization
)
1083 /* Someday C++0x may allow for enum template specialization. */
1084 if (cxx_dialect
> cxx98
&& TREE_CODE (type
) == ENUMERAL_TYPE
1085 && CLASS_TYPE_P (context
) && CLASSTYPE_USE_TEMPLATE (context
))
1086 pedwarn (input_location
, OPT_Wpedantic
, "template specialization "
1087 "of %qD not allowed by ISO C++", type
);
1090 error ("explicit specialization of non-template %qT", type
);
1091 return error_mark_node
;
1098 /* Returns nonzero if we can optimize the retrieval of specializations
1099 for TMPL, a TEMPLATE_DECL. In particular, for such a template, we
1100 do not use DECL_TEMPLATE_SPECIALIZATIONS at all. */
1103 optimize_specialization_lookup_p (tree tmpl
)
1105 return (DECL_FUNCTION_TEMPLATE_P (tmpl
)
1106 && DECL_CLASS_SCOPE_P (tmpl
)
1107 /* DECL_CLASS_SCOPE_P holds of T::f even if T is a template
1109 && CLASS_TYPE_P (DECL_CONTEXT (tmpl
))
1110 /* The optimized lookup depends on the fact that the
1111 template arguments for the member function template apply
1112 purely to the containing class, which is not true if the
1113 containing class is an explicit or partial
1115 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (tmpl
))
1116 && !DECL_MEMBER_TEMPLATE_P (tmpl
)
1117 && !DECL_CONV_FN_P (tmpl
)
1118 /* It is possible to have a template that is not a member
1119 template and is not a member of a template class:
1121 template <typename T>
1122 struct S { friend A::f(); };
1124 Here, the friend function is a template, but the context does
1125 not have template information. The optimized lookup relies
1126 on having ARGS be the template arguments for both the class
1127 and the function template. */
1128 && !DECL_FRIEND_P (DECL_TEMPLATE_RESULT (tmpl
)));
1131 /* Make sure ARGS doesn't use any inappropriate typedefs; we should have
1132 gone through coerce_template_parms by now. */
1135 verify_unstripped_args (tree args
)
1137 ++processing_template_decl
;
1138 if (!any_dependent_template_arguments_p (args
))
1140 tree inner
= INNERMOST_TEMPLATE_ARGS (args
);
1141 for (int i
= 0; i
< TREE_VEC_LENGTH (inner
); ++i
)
1143 tree arg
= TREE_VEC_ELT (inner
, i
);
1144 if (TREE_CODE (arg
) == TEMPLATE_DECL
)
1146 else if (TYPE_P (arg
))
1147 gcc_assert (strip_typedefs (arg
, NULL
) == arg
);
1148 else if (strip_typedefs (TREE_TYPE (arg
), NULL
) != TREE_TYPE (arg
))
1149 /* Allow typedefs on the type of a non-type argument, since a
1150 parameter can have them. */;
1152 gcc_assert (strip_typedefs_expr (arg
, NULL
) == arg
);
1155 --processing_template_decl
;
1158 /* Retrieve the specialization (in the sense of [temp.spec] - a
1159 specialization is either an instantiation or an explicit
1160 specialization) of TMPL for the given template ARGS. If there is
1161 no such specialization, return NULL_TREE. The ARGS are a vector of
1162 arguments, or a vector of vectors of arguments, in the case of
1163 templates with more than one level of parameters.
1165 If TMPL is a type template and CLASS_SPECIALIZATIONS_P is true,
1166 then we search for a partial specialization matching ARGS. This
1167 parameter is ignored if TMPL is not a class template.
1169 We can also look up a FIELD_DECL, if it is a lambda capture pack; the
1170 result is a NONTYPE_ARGUMENT_PACK. */
1173 retrieve_specialization (tree tmpl
, tree args
, hashval_t hash
)
1175 if (tmpl
== NULL_TREE
)
1178 if (args
== error_mark_node
)
1181 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
1182 || TREE_CODE (tmpl
) == FIELD_DECL
);
1184 /* There should be as many levels of arguments as there are
1185 levels of parameters. */
1186 gcc_assert (TMPL_ARGS_DEPTH (args
)
1187 == (TREE_CODE (tmpl
) == TEMPLATE_DECL
1188 ? TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
))
1189 : template_class_depth (DECL_CONTEXT (tmpl
))));
1192 verify_unstripped_args (args
);
1194 /* Lambda functions in templates aren't instantiated normally, but through
1195 tsubst_lambda_expr. */
1196 if (lambda_fn_in_template_p (tmpl
))
1199 if (optimize_specialization_lookup_p (tmpl
))
1201 /* The template arguments actually apply to the containing
1202 class. Find the class specialization with those
1204 tree class_template
= CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (tmpl
));
1205 tree class_specialization
1206 = retrieve_specialization (class_template
, args
, 0);
1207 if (!class_specialization
)
1210 /* Find the instance of TMPL. */
1211 tree fns
= get_class_binding (class_specialization
, DECL_NAME (tmpl
));
1212 for (ovl_iterator
iter (fns
); iter
; ++iter
)
1215 if (DECL_TEMPLATE_INFO (fn
) && DECL_TI_TEMPLATE (fn
) == tmpl
1216 /* using-declarations can add base methods to the method vec,
1217 and we don't want those here. */
1218 && DECL_CONTEXT (fn
) == class_specialization
)
1227 hash_table
<spec_hasher
> *specializations
;
1231 elt
.spec
= NULL_TREE
;
1233 if (DECL_CLASS_TEMPLATE_P (tmpl
))
1234 specializations
= type_specializations
;
1236 specializations
= decl_specializations
;
1239 hash
= spec_hasher::hash (&elt
);
1240 found
= specializations
->find_with_hash (&elt
, hash
);
1248 /* Like retrieve_specialization, but for local declarations. */
1251 retrieve_local_specialization (tree tmpl
)
1253 if (local_specializations
== NULL
)
1256 tree
*slot
= local_specializations
->get (tmpl
);
1257 return slot
? *slot
: NULL_TREE
;
1260 /* Returns nonzero iff DECL is a specialization of TMPL. */
1263 is_specialization_of (tree decl
, tree tmpl
)
1267 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1271 t
= DECL_TEMPLATE_INFO (t
) ? DECL_TI_TEMPLATE (t
) : NULL_TREE
)
1277 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
1279 for (t
= TREE_TYPE (decl
);
1281 t
= CLASSTYPE_USE_TEMPLATE (t
)
1282 ? TREE_TYPE (CLASSTYPE_TI_TEMPLATE (t
)) : NULL_TREE
)
1283 if (same_type_ignoring_top_level_qualifiers_p (t
, TREE_TYPE (tmpl
)))
1290 /* Returns nonzero iff DECL is a specialization of friend declaration
1291 FRIEND_DECL according to [temp.friend]. */
1294 is_specialization_of_friend (tree decl
, tree friend_decl
)
1296 bool need_template
= true;
1299 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
1300 || TREE_CODE (decl
) == TYPE_DECL
);
1302 /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
1303 of a template class, we want to check if DECL is a specialization
1305 if (TREE_CODE (friend_decl
) == FUNCTION_DECL
1306 && DECL_TEMPLATE_INFO (friend_decl
)
1307 && !DECL_USE_TEMPLATE (friend_decl
))
1309 /* We want a TEMPLATE_DECL for `is_specialization_of'. */
1310 friend_decl
= DECL_TI_TEMPLATE (friend_decl
);
1311 need_template
= false;
1313 else if (TREE_CODE (friend_decl
) == TEMPLATE_DECL
1314 && !PRIMARY_TEMPLATE_P (friend_decl
))
1315 need_template
= false;
1317 /* There is nothing to do if this is not a template friend. */
1318 if (TREE_CODE (friend_decl
) != TEMPLATE_DECL
)
1321 if (is_specialization_of (decl
, friend_decl
))
1325 A member of a class template may be declared to be a friend of a
1326 non-template class. In this case, the corresponding member of
1327 every specialization of the class template is a friend of the
1328 class granting friendship.
1330 For example, given a template friend declaration
1332 template <class T> friend void A<T>::f();
1334 the member function below is considered a friend
1336 template <> struct A<int> {
1340 For this type of template friend, TEMPLATE_DEPTH below will be
1341 nonzero. To determine if DECL is a friend of FRIEND, we first
1342 check if the enclosing class is a specialization of another. */
1344 template_depth
= template_class_depth (CP_DECL_CONTEXT (friend_decl
));
1346 && DECL_CLASS_SCOPE_P (decl
)
1347 && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl
)),
1348 CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl
))))
1350 /* Next, we check the members themselves. In order to handle
1351 a few tricky cases, such as when FRIEND_DECL's are
1353 template <class T> friend void A<T>::g(T t);
1354 template <class T> template <T t> friend void A<T>::h();
1358 void A<int>::g(int);
1359 template <int> void A<int>::h();
1361 we need to figure out ARGS, the template arguments from
1362 the context of DECL. This is required for template substitution
1363 of `T' in the function parameter of `g' and template parameter
1364 of `h' in the above examples. Here ARGS corresponds to `int'. */
1366 tree context
= DECL_CONTEXT (decl
);
1367 tree args
= NULL_TREE
;
1368 int current_depth
= 0;
1370 while (current_depth
< template_depth
)
1372 if (CLASSTYPE_TEMPLATE_INFO (context
))
1374 if (current_depth
== 0)
1375 args
= TYPE_TI_ARGS (context
);
1377 args
= add_to_template_args (TYPE_TI_ARGS (context
), args
);
1380 context
= TYPE_CONTEXT (context
);
1383 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1388 tree friend_args_type
;
1389 tree decl_args_type
;
1391 /* Make sure that both DECL and FRIEND_DECL are templates or
1393 is_template
= DECL_TEMPLATE_INFO (decl
)
1394 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
));
1395 if (need_template
^ is_template
)
1397 else if (is_template
)
1399 /* If both are templates, check template parameter list. */
1401 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1403 if (!comp_template_parms
1404 (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl
)),
1408 decl_type
= TREE_TYPE (DECL_TI_TEMPLATE (decl
));
1411 decl_type
= TREE_TYPE (decl
);
1413 friend_type
= tsubst_function_type (TREE_TYPE (friend_decl
), args
,
1414 tf_none
, NULL_TREE
);
1415 if (friend_type
== error_mark_node
)
1418 /* Check if return types match. */
1419 if (!same_type_p (TREE_TYPE (decl_type
), TREE_TYPE (friend_type
)))
1422 /* Check if function parameter types match, ignoring the
1423 `this' parameter. */
1424 friend_args_type
= TYPE_ARG_TYPES (friend_type
);
1425 decl_args_type
= TYPE_ARG_TYPES (decl_type
);
1426 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl
))
1427 friend_args_type
= TREE_CHAIN (friend_args_type
);
1428 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1429 decl_args_type
= TREE_CHAIN (decl_args_type
);
1431 return compparms (decl_args_type
, friend_args_type
);
1435 /* DECL is a TYPE_DECL */
1437 tree decl_type
= TREE_TYPE (decl
);
1439 /* Make sure that both DECL and FRIEND_DECL are templates or
1442 = CLASSTYPE_TEMPLATE_INFO (decl_type
)
1443 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (decl_type
));
1445 if (need_template
^ is_template
)
1447 else if (is_template
)
1450 /* If both are templates, check the name of the two
1451 TEMPLATE_DECL's first because is_friend didn't. */
1452 if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type
))
1453 != DECL_NAME (friend_decl
))
1456 /* Now check template parameter list. */
1458 = tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl
),
1460 return comp_template_parms
1461 (DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type
)),
1465 return (DECL_NAME (decl
)
1466 == DECL_NAME (friend_decl
));
1472 /* Register the specialization SPEC as a specialization of TMPL with
1473 the indicated ARGS. IS_FRIEND indicates whether the specialization
1474 is actually just a friend declaration. Returns SPEC, or an
1475 equivalent prior declaration, if available.
1477 We also store instantiations of field packs in the hash table, even
1478 though they are not themselves templates, to make lookup easier. */
1481 register_specialization (tree spec
, tree tmpl
, tree args
, bool is_friend
,
1485 spec_entry
**slot
= NULL
;
1488 gcc_assert ((TREE_CODE (tmpl
) == TEMPLATE_DECL
&& DECL_P (spec
))
1489 || (TREE_CODE (tmpl
) == FIELD_DECL
1490 && TREE_CODE (spec
) == NONTYPE_ARGUMENT_PACK
));
1492 if (TREE_CODE (spec
) == FUNCTION_DECL
1493 && uses_template_parms (DECL_TI_ARGS (spec
)))
1494 /* This is the FUNCTION_DECL for a partial instantiation. Don't
1495 register it; we want the corresponding TEMPLATE_DECL instead.
1496 We use `uses_template_parms (DECL_TI_ARGS (spec))' rather than
1497 the more obvious `uses_template_parms (spec)' to avoid problems
1498 with default function arguments. In particular, given
1499 something like this:
1501 template <class T> void f(T t1, T t = T())
1503 the default argument expression is not substituted for in an
1504 instantiation unless and until it is actually needed. */
1507 if (optimize_specialization_lookup_p (tmpl
))
1508 /* We don't put these specializations in the hash table, but we might
1509 want to give an error about a mismatch. */
1510 fn
= retrieve_specialization (tmpl
, args
, 0);
1518 hash
= spec_hasher::hash (&elt
);
1521 decl_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
1523 fn
= ((spec_entry
*) *slot
)->spec
;
1528 /* We can sometimes try to re-register a specialization that we've
1529 already got. In particular, regenerate_decl_from_template calls
1530 duplicate_decls which will update the specialization list. But,
1531 we'll still get called again here anyhow. It's more convenient
1532 to simply allow this than to try to prevent it. */
1535 else if (fn
&& DECL_TEMPLATE_SPECIALIZATION (spec
))
1537 if (DECL_TEMPLATE_INSTANTIATION (fn
))
1539 if (DECL_ODR_USED (fn
)
1540 || DECL_EXPLICIT_INSTANTIATION (fn
))
1542 error ("specialization of %qD after instantiation",
1544 return error_mark_node
;
1549 /* This situation should occur only if the first
1550 specialization is an implicit instantiation, the
1551 second is an explicit specialization, and the
1552 implicit instantiation has not yet been used. That
1553 situation can occur if we have implicitly
1554 instantiated a member function and then specialized
1557 We can also wind up here if a friend declaration that
1558 looked like an instantiation turns out to be a
1561 template <class T> void foo(T);
1562 class S { friend void foo<>(int) };
1563 template <> void foo(int);
1565 We transform the existing DECL in place so that any
1566 pointers to it become pointers to the updated
1569 If there was a definition for the template, but not
1570 for the specialization, we want this to look as if
1571 there were no definition, and vice versa. */
1572 DECL_INITIAL (fn
) = NULL_TREE
;
1573 duplicate_decls (spec
, fn
, is_friend
);
1574 /* The call to duplicate_decls will have applied
1577 An explicit specialization of a function template
1578 is inline only if it is explicitly declared to be,
1579 and independently of whether its function template
1582 to the primary function; now copy the inline bits to
1583 the various clones. */
1584 FOR_EACH_CLONE (clone
, fn
)
1586 DECL_DECLARED_INLINE_P (clone
)
1587 = DECL_DECLARED_INLINE_P (fn
);
1588 DECL_SOURCE_LOCATION (clone
)
1589 = DECL_SOURCE_LOCATION (fn
);
1590 DECL_DELETED_FN (clone
)
1591 = DECL_DELETED_FN (fn
);
1593 check_specialization_namespace (tmpl
);
1598 else if (DECL_TEMPLATE_SPECIALIZATION (fn
))
1600 tree dd
= duplicate_decls (spec
, fn
, is_friend
);
1601 if (dd
== error_mark_node
)
1602 /* We've already complained in duplicate_decls. */
1603 return error_mark_node
;
1605 if (dd
== NULL_TREE
&& DECL_INITIAL (spec
))
1606 /* Dup decl failed, but this is a new definition. Set the
1607 line number so any errors match this new
1609 DECL_SOURCE_LOCATION (fn
) = DECL_SOURCE_LOCATION (spec
);
1615 return duplicate_decls (spec
, fn
, is_friend
);
1617 /* A specialization must be declared in the same namespace as the
1618 template it is specializing. */
1619 if (DECL_P (spec
) && DECL_TEMPLATE_SPECIALIZATION (spec
)
1620 && !check_specialization_namespace (tmpl
))
1621 DECL_CONTEXT (spec
) = DECL_CONTEXT (tmpl
);
1623 if (slot
!= NULL
/* !optimize_specialization_lookup_p (tmpl) */)
1625 spec_entry
*entry
= ggc_alloc
<spec_entry
> ();
1626 gcc_assert (tmpl
&& args
&& spec
);
1629 if ((TREE_CODE (spec
) == FUNCTION_DECL
&& DECL_NAMESPACE_SCOPE_P (spec
)
1630 && PRIMARY_TEMPLATE_P (tmpl
)
1631 && DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (tmpl
)) == NULL_TREE
)
1632 || variable_template_p (tmpl
))
1633 /* If TMPL is a forward declaration of a template function, keep a list
1634 of all specializations in case we need to reassign them to a friend
1635 template later in tsubst_friend_function.
1637 Also keep a list of all variable template instantiations so that
1638 process_partial_specialization can check whether a later partial
1639 specialization would have used it. */
1640 DECL_TEMPLATE_INSTANTIATIONS (tmpl
)
1641 = tree_cons (args
, spec
, DECL_TEMPLATE_INSTANTIATIONS (tmpl
));
1647 /* Returns true iff two spec_entry nodes are equivalent. */
1649 int comparing_specializations
;
1652 spec_hasher::equal (spec_entry
*e1
, spec_entry
*e2
)
1656 ++comparing_specializations
;
1657 equal
= (e1
->tmpl
== e2
->tmpl
1658 && comp_template_args (e1
->args
, e2
->args
));
1659 if (equal
&& flag_concepts
1660 /* tmpl could be a FIELD_DECL for a capture pack. */
1661 && TREE_CODE (e1
->tmpl
) == TEMPLATE_DECL
1662 && VAR_P (DECL_TEMPLATE_RESULT (e1
->tmpl
))
1663 && uses_template_parms (e1
->args
))
1665 /* Partial specializations of a variable template can be distinguished by
1667 tree c1
= e1
->spec
? get_constraints (e1
->spec
) : NULL_TREE
;
1668 tree c2
= e2
->spec
? get_constraints (e2
->spec
) : NULL_TREE
;
1669 equal
= equivalent_constraints (c1
, c2
);
1671 --comparing_specializations
;
1676 /* Returns a hash for a template TMPL and template arguments ARGS. */
1679 hash_tmpl_and_args (tree tmpl
, tree args
)
1681 hashval_t val
= iterative_hash_object (DECL_UID (tmpl
), 0);
1682 return iterative_hash_template_arg (args
, val
);
1685 /* Returns a hash for a spec_entry node based on the TMPL and ARGS members,
1689 spec_hasher::hash (spec_entry
*e
)
1691 return hash_tmpl_and_args (e
->tmpl
, e
->args
);
1694 /* Recursively calculate a hash value for a template argument ARG, for use
1695 in the hash tables of template specializations. */
1698 iterative_hash_template_arg (tree arg
, hashval_t val
)
1700 unsigned HOST_WIDE_INT i
;
1701 enum tree_code code
;
1704 if (arg
== NULL_TREE
)
1705 return iterative_hash_object (arg
, val
);
1710 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
1713 code
= TREE_CODE (arg
);
1714 tclass
= TREE_CODE_CLASS (code
);
1716 val
= iterative_hash_object (code
, val
);
1723 case IDENTIFIER_NODE
:
1724 return iterative_hash_object (IDENTIFIER_HASH_VALUE (arg
), val
);
1728 int i
, len
= TREE_VEC_LENGTH (arg
);
1729 for (i
= 0; i
< len
; ++i
)
1730 val
= iterative_hash_template_arg (TREE_VEC_ELT (arg
, i
), val
);
1734 case TYPE_PACK_EXPANSION
:
1735 case EXPR_PACK_EXPANSION
:
1736 val
= iterative_hash_template_arg (PACK_EXPANSION_PATTERN (arg
), val
);
1737 return iterative_hash_template_arg (PACK_EXPANSION_EXTRA_ARGS (arg
), val
);
1739 case TYPE_ARGUMENT_PACK
:
1740 case NONTYPE_ARGUMENT_PACK
:
1741 return iterative_hash_template_arg (ARGUMENT_PACK_ARGS (arg
), val
);
1744 for (; arg
; arg
= TREE_CHAIN (arg
))
1745 val
= iterative_hash_template_arg (TREE_VALUE (arg
), val
);
1749 for (lkp_iterator
iter (arg
); iter
; ++iter
)
1750 val
= iterative_hash_template_arg (*iter
, val
);
1756 iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1757 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg
), i
, field
, value
)
1759 val
= iterative_hash_template_arg (field
, val
);
1760 val
= iterative_hash_template_arg (value
, val
);
1766 if (!DECL_ARTIFICIAL (arg
))
1768 val
= iterative_hash_object (DECL_PARM_INDEX (arg
), val
);
1769 val
= iterative_hash_object (DECL_PARM_LEVEL (arg
), val
);
1771 return iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1774 return iterative_hash_template_arg (TARGET_EXPR_INITIAL (arg
), val
);
1777 val
= iterative_hash_template_arg (PTRMEM_CST_CLASS (arg
), val
);
1778 return iterative_hash_template_arg (PTRMEM_CST_MEMBER (arg
), val
);
1780 case TEMPLATE_PARM_INDEX
:
1781 val
= iterative_hash_template_arg
1782 (TREE_TYPE (TEMPLATE_PARM_DECL (arg
)), val
);
1783 val
= iterative_hash_object (TEMPLATE_PARM_LEVEL (arg
), val
);
1784 return iterative_hash_object (TEMPLATE_PARM_IDX (arg
), val
);
1787 val
= iterative_hash_object (TRAIT_EXPR_KIND (arg
), val
);
1788 val
= iterative_hash_template_arg (TRAIT_EXPR_TYPE1 (arg
), val
);
1789 return iterative_hash_template_arg (TRAIT_EXPR_TYPE2 (arg
), val
);
1792 val
= iterative_hash_template_arg (BINFO_TYPE (BASELINK_BINFO (arg
)),
1794 return iterative_hash_template_arg (DECL_NAME (get_first_fn (arg
)),
1798 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, 0), val
);
1799 code
= TREE_CODE (TREE_OPERAND (arg
, 1));
1800 val
= iterative_hash_object (code
, val
);
1801 return iterative_hash_template_arg (TREE_OPERAND (arg
, 2), val
);
1804 /* A lambda can't appear in a template arg, but don't crash on
1806 gcc_assert (seen_error ());
1810 case IMPLICIT_CONV_EXPR
:
1811 case STATIC_CAST_EXPR
:
1812 case REINTERPRET_CAST_EXPR
:
1813 case CONST_CAST_EXPR
:
1814 case DYNAMIC_CAST_EXPR
:
1816 val
= iterative_hash_template_arg (TREE_TYPE (arg
), val
);
1817 /* Now hash operands as usual. */
1827 if (alias_template_specialization_p (arg
))
1829 // We want an alias specialization that survived strip_typedefs
1830 // to hash differently from its TYPE_CANONICAL, to avoid hash
1831 // collisions that compare as different in template_args_equal.
1832 // These could be dependent specializations that strip_typedefs
1833 // left alone, or untouched specializations because
1834 // coerce_template_parms returns the unconverted template
1835 // arguments if it sees incomplete argument packs.
1836 tree ti
= TYPE_ALIAS_TEMPLATE_INFO (arg
);
1837 return hash_tmpl_and_args (TI_TEMPLATE (ti
), TI_ARGS (ti
));
1839 if (TYPE_CANONICAL (arg
))
1840 return iterative_hash_object (TYPE_HASH (TYPE_CANONICAL (arg
)),
1842 else if (TREE_CODE (arg
) == DECLTYPE_TYPE
)
1843 return iterative_hash_template_arg (DECLTYPE_TYPE_EXPR (arg
), val
);
1844 /* Otherwise just compare the types during lookup. */
1847 case tcc_declaration
:
1849 return iterative_hash_expr (arg
, val
);
1852 gcc_assert (IS_EXPR_CODE_CLASS (tclass
));
1854 unsigned n
= cp_tree_operand_length (arg
);
1855 for (i
= 0; i
< n
; ++i
)
1856 val
= iterative_hash_template_arg (TREE_OPERAND (arg
, i
), val
);
1864 /* Unregister the specialization SPEC as a specialization of TMPL.
1865 Replace it with NEW_SPEC, if NEW_SPEC is non-NULL. Returns true
1866 if the SPEC was listed as a specialization of TMPL.
1868 Note that SPEC has been ggc_freed, so we can't look inside it. */
1871 reregister_specialization (tree spec
, tree tinfo
, tree new_spec
)
1876 elt
.tmpl
= most_general_template (TI_TEMPLATE (tinfo
));
1877 elt
.args
= TI_ARGS (tinfo
);
1878 elt
.spec
= NULL_TREE
;
1880 entry
= decl_specializations
->find (&elt
);
1883 gcc_assert (entry
->spec
== spec
|| entry
->spec
== new_spec
);
1884 gcc_assert (new_spec
!= NULL_TREE
);
1885 entry
->spec
= new_spec
;
1892 /* Like register_specialization, but for local declarations. We are
1893 registering SPEC, an instantiation of TMPL. */
1896 register_local_specialization (tree spec
, tree tmpl
)
1898 gcc_assert (tmpl
!= spec
);
1899 local_specializations
->put (tmpl
, spec
);
1902 /* TYPE is a class type. Returns true if TYPE is an explicitly
1903 specialized class. */
1906 explicit_class_specialization_p (tree type
)
1908 if (!CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
1910 return !uses_template_parms (CLASSTYPE_TI_ARGS (type
));
1913 /* Print the list of functions at FNS, going through all the overloads
1914 for each element of the list. Alternatively, FNS can not be a
1915 TREE_LIST, in which case it will be printed together with all the
1918 MORE and *STR should respectively be FALSE and NULL when the function
1919 is called from the outside. They are used internally on recursive
1920 calls. print_candidates manages the two parameters and leaves NULL
1921 in *STR when it ends. */
1924 print_candidates_1 (tree fns
, char **str
, bool more
= false)
1926 if (TREE_CODE (fns
) == TREE_LIST
)
1927 for (; fns
; fns
= TREE_CHAIN (fns
))
1928 print_candidates_1 (TREE_VALUE (fns
), str
, more
|| TREE_CHAIN (fns
));
1930 for (lkp_iterator
iter (fns
); iter
;)
1935 const char *pfx
= *str
;
1939 pfx
= _("candidates are:");
1941 pfx
= _("candidate is:");
1942 *str
= get_spaces (pfx
);
1944 inform (DECL_SOURCE_LOCATION (cand
), "%s %#qD", pfx
, cand
);
1948 /* Print the list of candidate FNS in an error message. FNS can also
1949 be a TREE_LIST of non-functions in the case of an ambiguous lookup. */
1952 print_candidates (tree fns
)
1955 print_candidates_1 (fns
, &str
);
1959 /* Get a (possibly) constrained template declaration for the
1960 purpose of ordering candidates. */
1962 get_template_for_ordering (tree list
)
1964 gcc_assert (TREE_CODE (list
) == TREE_LIST
);
1965 tree f
= TREE_VALUE (list
);
1966 if (tree ti
= DECL_TEMPLATE_INFO (f
))
1967 return TI_TEMPLATE (ti
);
1971 /* Among candidates having the same signature, return the
1972 most constrained or NULL_TREE if there is no best candidate.
1973 If the signatures of candidates vary (e.g., template
1974 specialization vs. member function), then there can be no
1977 Note that we don't compare constraints on the functions
1978 themselves, but rather those of their templates. */
1980 most_constrained_function (tree candidates
)
1982 // Try to find the best candidate in a first pass.
1983 tree champ
= candidates
;
1984 for (tree c
= TREE_CHAIN (champ
); c
; c
= TREE_CHAIN (c
))
1986 int winner
= more_constrained (get_template_for_ordering (champ
),
1987 get_template_for_ordering (c
));
1989 champ
= c
; // The candidate is more constrained
1990 else if (winner
== 0)
1991 return NULL_TREE
; // Neither is more constrained
1994 // Verify that the champ is better than previous candidates.
1995 for (tree c
= candidates
; c
!= champ
; c
= TREE_CHAIN (c
)) {
1996 if (!more_constrained (get_template_for_ordering (champ
),
1997 get_template_for_ordering (c
)))
2005 /* Returns the template (one of the functions given by TEMPLATE_ID)
2006 which can be specialized to match the indicated DECL with the
2007 explicit template args given in TEMPLATE_ID. The DECL may be
2008 NULL_TREE if none is available. In that case, the functions in
2009 TEMPLATE_ID are non-members.
2011 If NEED_MEMBER_TEMPLATE is nonzero the function is known to be a
2012 specialization of a member template.
2014 The TEMPLATE_COUNT is the number of references to qualifying
2015 template classes that appeared in the name of the function. See
2016 check_explicit_specialization for a more accurate description.
2018 TSK indicates what kind of template declaration (if any) is being
2019 declared. TSK_TEMPLATE indicates that the declaration given by
2020 DECL, though a FUNCTION_DECL, has template parameters, and is
2021 therefore a template function.
2023 The template args (those explicitly specified and those deduced)
2024 are output in a newly created vector *TARGS_OUT.
2026 If it is impossible to determine the result, an error message is
2027 issued. The error_mark_node is returned to indicate failure. */
2030 determine_specialization (tree template_id
,
2033 int need_member_template
,
2039 tree explicit_targs
;
2040 tree candidates
= NULL_TREE
;
2042 /* A TREE_LIST of templates of which DECL may be a specialization.
2043 The TREE_VALUE of each node is a TEMPLATE_DECL. The
2044 corresponding TREE_PURPOSE is the set of template arguments that,
2045 when used to instantiate the template, would produce a function
2046 with the signature of DECL. */
2047 tree templates
= NULL_TREE
;
2049 cp_binding_level
*b
;
2051 *targs_out
= NULL_TREE
;
2053 if (template_id
== error_mark_node
|| decl
== error_mark_node
)
2054 return error_mark_node
;
2056 /* We shouldn't be specializing a member template of an
2057 unspecialized class template; we already gave an error in
2058 check_specialization_scope, now avoid crashing. */
2059 if (template_count
&& DECL_CLASS_SCOPE_P (decl
)
2060 && template_class_depth (DECL_CONTEXT (decl
)) > 0)
2062 gcc_assert (errorcount
);
2063 return error_mark_node
;
2066 fns
= TREE_OPERAND (template_id
, 0);
2067 explicit_targs
= TREE_OPERAND (template_id
, 1);
2069 if (fns
== error_mark_node
)
2070 return error_mark_node
;
2072 /* Check for baselinks. */
2073 if (BASELINK_P (fns
))
2074 fns
= BASELINK_FUNCTIONS (fns
);
2076 if (TREE_CODE (decl
) == FUNCTION_DECL
&& !is_overloaded_fn (fns
))
2078 error ("%qD is not a function template", fns
);
2079 return error_mark_node
;
2081 else if (VAR_P (decl
) && !variable_template_p (fns
))
2083 error ("%qD is not a variable template", fns
);
2084 return error_mark_node
;
2087 /* Count the number of template headers specified for this
2090 for (b
= current_binding_level
;
2091 b
->kind
== sk_template_parms
;
2095 tree orig_fns
= fns
;
2097 if (variable_template_p (fns
))
2099 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (fns
));
2100 targs
= coerce_template_parms (parms
, explicit_targs
, fns
,
2101 tf_warning_or_error
,
2102 /*req_all*/true, /*use_defarg*/true);
2103 if (targs
!= error_mark_node
)
2104 templates
= tree_cons (targs
, fns
, templates
);
2106 else for (lkp_iterator
iter (fns
); iter
; ++iter
)
2110 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2112 tree decl_arg_types
;
2116 /* In case of explicit specialization, we need to check if
2117 the number of template headers appearing in the specialization
2118 is correct. This is usually done in check_explicit_specialization,
2119 but the check done there cannot be exhaustive when specializing
2120 member functions. Consider the following code:
2122 template <> void A<int>::f(int);
2123 template <> template <> void A<int>::f(int);
2125 Assuming that A<int> is not itself an explicit specialization
2126 already, the first line specializes "f" which is a non-template
2127 member function, whilst the second line specializes "f" which
2128 is a template member function. So both lines are syntactically
2129 correct, and check_explicit_specialization does not reject
2132 Here, we can do better, as we are matching the specialization
2133 against the declarations. We count the number of template
2134 headers, and we check if they match TEMPLATE_COUNT + 1
2135 (TEMPLATE_COUNT is the number of qualifying template classes,
2136 plus there must be another header for the member template
2139 Notice that if header_count is zero, this is not a
2140 specialization but rather a template instantiation, so there
2141 is no check we can perform here. */
2142 if (header_count
&& header_count
!= template_count
+ 1)
2145 /* Check that the number of template arguments at the
2146 innermost level for DECL is the same as for FN. */
2147 if (current_binding_level
->kind
== sk_template_parms
2148 && !current_binding_level
->explicit_spec_p
2149 && (TREE_VEC_LENGTH (DECL_INNERMOST_TEMPLATE_PARMS (fn
))
2150 != TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
2151 (current_template_parms
))))
2154 /* DECL might be a specialization of FN. */
2155 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2156 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
2158 /* For a non-static member function, we need to make sure
2159 that the const qualification is the same. Since
2160 get_bindings does not try to merge the "this" parameter,
2161 we must do the comparison explicitly. */
2162 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
2163 && !same_type_p (TREE_VALUE (fn_arg_types
),
2164 TREE_VALUE (decl_arg_types
)))
2167 /* Skip the "this" parameter and, for constructors of
2168 classes with virtual bases, the VTT parameter. A
2169 full specialization of a constructor will have a VTT
2170 parameter, but a template never will. */
2172 = skip_artificial_parms_for (decl
, decl_arg_types
);
2174 = skip_artificial_parms_for (fn
, fn_arg_types
);
2176 /* Function templates cannot be specializations; there are
2177 no partial specializations of functions. Therefore, if
2178 the type of DECL does not match FN, there is no
2181 Note that it should never be the case that we have both
2182 candidates added here, and for regular member functions
2184 if (tsk
== tsk_template
)
2186 if (compparms (fn_arg_types
, decl_arg_types
))
2187 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2191 /* See whether this function might be a specialization of this
2192 template. Suppress access control because we might be trying
2193 to make this specialization a friend, and we have already done
2194 access control for the declaration of the specialization. */
2195 push_deferring_access_checks (dk_no_check
);
2196 targs
= get_bindings (fn
, decl
, explicit_targs
, /*check_ret=*/true);
2197 pop_deferring_access_checks ();
2200 /* We cannot deduce template arguments that when used to
2201 specialize TMPL will produce DECL. */
2204 /* Remove, from the set of candidates, all those functions
2205 whose constraints are not satisfied. */
2206 if (flag_concepts
&& !constraints_satisfied_p (fn
, targs
))
2209 // Then, try to form the new function type.
2210 insttype
= tsubst (TREE_TYPE (fn
), targs
, tf_fndecl_type
, NULL_TREE
);
2211 if (insttype
== error_mark_node
)
2214 = skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (insttype
));
2215 if (!compparms (fn_arg_types
, decl_arg_types
))
2218 /* Save this template, and the arguments deduced. */
2219 templates
= tree_cons (targs
, fn
, templates
);
2221 else if (need_member_template
)
2222 /* FN is an ordinary member function, and we need a
2223 specialization of a member template. */
2225 else if (TREE_CODE (fn
) != FUNCTION_DECL
)
2226 /* We can get IDENTIFIER_NODEs here in certain erroneous
2229 else if (!DECL_FUNCTION_MEMBER_P (fn
))
2230 /* This is just an ordinary non-member function. Nothing can
2231 be a specialization of that. */
2233 else if (DECL_ARTIFICIAL (fn
))
2234 /* Cannot specialize functions that are created implicitly. */
2238 tree decl_arg_types
;
2240 /* This is an ordinary member function. However, since
2241 we're here, we can assume its enclosing class is a
2242 template class. For example,
2244 template <typename T> struct S { void f(); };
2245 template <> void S<int>::f() {}
2247 Here, S<int>::f is a non-template, but S<int> is a
2248 template class. If FN has the same type as DECL, we
2249 might be in business. */
2251 if (!DECL_TEMPLATE_INFO (fn
))
2252 /* Its enclosing class is an explicit specialization
2253 of a template class. This is not a candidate. */
2256 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
2257 TREE_TYPE (TREE_TYPE (fn
))))
2258 /* The return types differ. */
2261 /* Adjust the type of DECL in case FN is a static member. */
2262 decl_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2263 if (DECL_STATIC_FUNCTION_P (fn
)
2264 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2265 decl_arg_types
= TREE_CHAIN (decl_arg_types
);
2267 if (!compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
2271 // If the deduced arguments do not satisfy the constraints,
2272 // this is not a candidate.
2273 if (flag_concepts
&& !constraints_satisfied_p (fn
))
2276 // Add the candidate.
2277 candidates
= tree_cons (NULL_TREE
, fn
, candidates
);
2281 if (templates
&& TREE_CHAIN (templates
))
2287 It is possible for a specialization with a given function
2288 signature to be instantiated from more than one function
2289 template. In such cases, explicit specification of the
2290 template arguments must be used to uniquely identify the
2291 function template specialization being specialized.
2293 Note that here, there's no suggestion that we're supposed to
2294 determine which of the candidate templates is most
2295 specialized. However, we, also have:
2299 Partial ordering of overloaded function template
2300 declarations is used in the following contexts to select
2301 the function template to which a function template
2302 specialization refers:
2304 -- when an explicit specialization refers to a function
2307 So, we do use the partial ordering rules, at least for now.
2308 This extension can only serve to make invalid programs valid,
2309 so it's safe. And, there is strong anecdotal evidence that
2310 the committee intended the partial ordering rules to apply;
2311 the EDG front end has that behavior, and John Spicer claims
2312 that the committee simply forgot to delete the wording in
2313 [temp.expl.spec]. */
2314 tree tmpl
= most_specialized_instantiation (templates
);
2315 if (tmpl
!= error_mark_node
)
2318 TREE_CHAIN (templates
) = NULL_TREE
;
2322 // Concepts allows multiple declarations of member functions
2323 // with the same signature. Like above, we need to rely on
2324 // on the partial ordering of those candidates to determine which
2326 if (flag_concepts
&& candidates
&& TREE_CHAIN (candidates
))
2328 if (tree cand
= most_constrained_function (candidates
))
2331 TREE_CHAIN (cand
) = NULL_TREE
;
2335 if (templates
== NULL_TREE
&& candidates
== NULL_TREE
)
2337 error ("template-id %qD for %q+D does not match any template "
2338 "declaration", template_id
, decl
);
2339 if (header_count
&& header_count
!= template_count
+ 1)
2340 inform (input_location
, "saw %d %<template<>%>, need %d for "
2341 "specializing a member function template",
2342 header_count
, template_count
+ 1);
2344 print_candidates (orig_fns
);
2345 return error_mark_node
;
2347 else if ((templates
&& TREE_CHAIN (templates
))
2348 || (candidates
&& TREE_CHAIN (candidates
))
2349 || (templates
&& candidates
))
2351 error ("ambiguous template specialization %qD for %q+D",
2353 candidates
= chainon (candidates
, templates
);
2354 print_candidates (candidates
);
2355 return error_mark_node
;
2358 /* We have one, and exactly one, match. */
2361 tree fn
= TREE_VALUE (candidates
);
2362 *targs_out
= copy_node (DECL_TI_ARGS (fn
));
2364 // Propagate the candidate's constraints to the declaration.
2365 set_constraints (decl
, get_constraints (fn
));
2367 /* DECL is a re-declaration or partial instantiation of a template
2369 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2371 /* It was a specialization of an ordinary member function in a
2373 return DECL_TI_TEMPLATE (fn
);
2376 /* It was a specialization of a template. */
2377 targs
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (TREE_VALUE (templates
)));
2378 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (targs
))
2380 *targs_out
= copy_node (targs
);
2381 SET_TMPL_ARGS_LEVEL (*targs_out
,
2382 TMPL_ARGS_DEPTH (*targs_out
),
2383 TREE_PURPOSE (templates
));
2386 *targs_out
= TREE_PURPOSE (templates
);
2387 return TREE_VALUE (templates
);
2390 /* Returns a chain of parameter types, exactly like the SPEC_TYPES,
2391 but with the default argument values filled in from those in the
2395 copy_default_args_to_explicit_spec_1 (tree spec_types
,
2398 tree new_spec_types
;
2403 if (spec_types
== void_list_node
)
2404 return void_list_node
;
2406 /* Substitute into the rest of the list. */
2408 copy_default_args_to_explicit_spec_1 (TREE_CHAIN (spec_types
),
2409 TREE_CHAIN (tmpl_types
));
2411 /* Add the default argument for this parameter. */
2412 return hash_tree_cons (TREE_PURPOSE (tmpl_types
),
2413 TREE_VALUE (spec_types
),
2417 /* DECL is an explicit specialization. Replicate default arguments
2418 from the template it specializes. (That way, code like:
2420 template <class T> void f(T = 3);
2421 template <> void f(double);
2424 works, as required.) An alternative approach would be to look up
2425 the correct default arguments at the call-site, but this approach
2426 is consistent with how implicit instantiations are handled. */
2429 copy_default_args_to_explicit_spec (tree decl
)
2434 tree new_spec_types
;
2438 tree object_type
= NULL_TREE
;
2439 tree in_charge
= NULL_TREE
;
2440 tree vtt
= NULL_TREE
;
2442 /* See if there's anything we need to do. */
2443 tmpl
= DECL_TI_TEMPLATE (decl
);
2444 tmpl_types
= TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (tmpl
)));
2445 for (t
= tmpl_types
; t
; t
= TREE_CHAIN (t
))
2446 if (TREE_PURPOSE (t
))
2451 old_type
= TREE_TYPE (decl
);
2452 spec_types
= TYPE_ARG_TYPES (old_type
);
2454 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2456 /* Remove the this pointer, but remember the object's type for
2458 object_type
= TREE_TYPE (TREE_VALUE (spec_types
));
2459 spec_types
= TREE_CHAIN (spec_types
);
2460 tmpl_types
= TREE_CHAIN (tmpl_types
);
2462 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
2464 /* DECL may contain more parameters than TMPL due to the extra
2465 in-charge parameter in constructors and destructors. */
2466 in_charge
= spec_types
;
2467 spec_types
= TREE_CHAIN (spec_types
);
2469 if (DECL_HAS_VTT_PARM_P (decl
))
2472 spec_types
= TREE_CHAIN (spec_types
);
2476 /* Compute the merged default arguments. */
2478 copy_default_args_to_explicit_spec_1 (spec_types
, tmpl_types
);
2480 /* Compute the new FUNCTION_TYPE. */
2484 new_spec_types
= hash_tree_cons (TREE_PURPOSE (vtt
),
2489 /* Put the in-charge parameter back. */
2490 new_spec_types
= hash_tree_cons (TREE_PURPOSE (in_charge
),
2491 TREE_VALUE (in_charge
),
2494 new_type
= build_method_type_directly (object_type
,
2495 TREE_TYPE (old_type
),
2499 new_type
= build_function_type (TREE_TYPE (old_type
),
2501 new_type
= cp_build_type_attribute_variant (new_type
,
2502 TYPE_ATTRIBUTES (old_type
));
2503 new_type
= build_exception_variant (new_type
,
2504 TYPE_RAISES_EXCEPTIONS (old_type
));
2506 if (TYPE_HAS_LATE_RETURN_TYPE (old_type
))
2507 TYPE_HAS_LATE_RETURN_TYPE (new_type
) = 1;
2509 TREE_TYPE (decl
) = new_type
;
2512 /* Return the number of template headers we expect to see for a definition
2513 or specialization of CTYPE or one of its non-template members. */
2516 num_template_headers_for_class (tree ctype
)
2518 int num_templates
= 0;
2520 while (ctype
&& CLASS_TYPE_P (ctype
))
2522 /* You're supposed to have one `template <...>' for every
2523 template class, but you don't need one for a full
2524 specialization. For example:
2526 template <class T> struct S{};
2527 template <> struct S<int> { void f(); };
2528 void S<int>::f () {}
2530 is correct; there shouldn't be a `template <>' for the
2531 definition of `S<int>::f'. */
2532 if (!CLASSTYPE_TEMPLATE_INFO (ctype
))
2533 /* If CTYPE does not have template information of any
2534 kind, then it is not a template, nor is it nested
2535 within a template. */
2537 if (explicit_class_specialization_p (ctype
))
2539 if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (ctype
)))
2542 ctype
= TYPE_CONTEXT (ctype
);
2545 return num_templates
;
2548 /* Do a simple sanity check on the template headers that precede the
2549 variable declaration DECL. */
2552 check_template_variable (tree decl
)
2554 tree ctx
= CP_DECL_CONTEXT (decl
);
2555 int wanted
= num_template_headers_for_class (ctx
);
2556 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)
2557 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
)))
2559 if (cxx_dialect
< cxx14
)
2560 pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2561 "variable templates only available with "
2562 "-std=c++14 or -std=gnu++14");
2564 // Namespace-scope variable templates should have a template header.
2567 if (template_header_count
> wanted
)
2569 bool warned
= pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2570 "too many template headers for %qD "
2573 if (warned
&& CLASS_TYPE_P (ctx
)
2574 && CLASSTYPE_TEMPLATE_SPECIALIZATION (ctx
))
2575 inform (DECL_SOURCE_LOCATION (decl
),
2576 "members of an explicitly specialized class are defined "
2577 "without a template header");
2581 /* An explicit specialization whose declarator-id or class-head-name is not
2582 qualified shall be declared in the nearest enclosing namespace of the
2583 template, or, if the namespace is inline (7.3.1), any namespace from its
2584 enclosing namespace set.
2586 If the name declared in the explicit instantiation is an unqualified name,
2587 the explicit instantiation shall appear in the namespace where its template
2588 is declared or, if that namespace is inline (7.3.1), any namespace from its
2589 enclosing namespace set. */
2592 check_unqualified_spec_or_inst (tree t
, location_t loc
)
2594 tree tmpl
= most_general_template (t
);
2595 if (DECL_NAMESPACE_SCOPE_P (tmpl
)
2596 && !is_nested_namespace (current_namespace
,
2597 CP_DECL_CONTEXT (tmpl
), true))
2599 if (processing_specialization
)
2600 permerror (loc
, "explicit specialization of %qD outside its "
2601 "namespace must use a nested-name-specifier", tmpl
);
2602 else if (processing_explicit_instantiation
2603 && cxx_dialect
>= cxx11
)
2604 /* This was allowed in C++98, so only pedwarn. */
2605 pedwarn (loc
, OPT_Wpedantic
, "explicit instantiation of %qD "
2606 "outside its namespace must use a nested-name-"
2611 /* Check to see if the function just declared, as indicated in
2612 DECLARATOR, and in DECL, is a specialization of a function
2613 template. We may also discover that the declaration is an explicit
2614 instantiation at this point.
2616 Returns DECL, or an equivalent declaration that should be used
2617 instead if all goes well. Issues an error message if something is
2618 amiss. Returns error_mark_node if the error is not easily
2621 FLAGS is a bitmask consisting of the following flags:
2623 2: The function has a definition.
2624 4: The function is a friend.
2626 The TEMPLATE_COUNT is the number of references to qualifying
2627 template classes that appeared in the name of the function. For
2630 template <class T> struct S { void f(); };
2633 the TEMPLATE_COUNT would be 1. However, explicitly specialized
2634 classes are not counted in the TEMPLATE_COUNT, so that in
2636 template <class T> struct S {};
2637 template <> struct S<int> { void f(); }
2638 template <> void S<int>::f();
2640 the TEMPLATE_COUNT would be 0. (Note that this declaration is
2641 invalid; there should be no template <>.)
2643 If the function is a specialization, it is marked as such via
2644 DECL_TEMPLATE_SPECIALIZATION. Furthermore, its DECL_TEMPLATE_INFO
2645 is set up correctly, and it is added to the list of specializations
2646 for that template. */
2649 check_explicit_specialization (tree declarator
,
2654 int have_def
= flags
& 2;
2655 int is_friend
= flags
& 4;
2656 bool is_concept
= flags
& 8;
2657 int specialization
= 0;
2658 int explicit_instantiation
= 0;
2659 int member_specialization
= 0;
2660 tree ctype
= DECL_CLASS_CONTEXT (decl
);
2661 tree dname
= DECL_NAME (decl
);
2666 if (!processing_specialization
)
2669 tsk
= tsk_excessive_parms
;
2672 tsk
= current_tmpl_spec_kind (template_count
);
2677 if (processing_specialization
&& !VAR_P (decl
))
2680 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2682 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2685 /* This could be something like:
2687 template <class T> void f(T);
2688 class S { friend void f<>(int); } */
2692 /* This case handles bogus declarations like template <>
2693 template <class T> void f<int>(); */
2695 error ("template-id %qD in declaration of primary template",
2702 case tsk_invalid_member_spec
:
2703 /* The error has already been reported in
2704 check_specialization_scope. */
2705 return error_mark_node
;
2707 case tsk_invalid_expl_inst
:
2708 error ("template parameter list used in explicit instantiation");
2714 error ("definition provided for explicit instantiation");
2716 explicit_instantiation
= 1;
2719 case tsk_excessive_parms
:
2720 case tsk_insufficient_parms
:
2721 if (tsk
== tsk_excessive_parms
)
2722 error ("too many template parameter lists in declaration of %qD",
2724 else if (template_header_count
)
2725 error("too few template parameter lists in declaration of %qD", decl
);
2727 error("explicit specialization of %qD must be introduced by "
2728 "%<template <>%>", decl
);
2733 error ("explicit specialization declared %<concept%>");
2735 if (VAR_P (decl
) && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
2736 /* In cases like template<> constexpr bool v = true;
2737 We'll give an error in check_template_variable. */
2740 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2742 member_specialization
= 1;
2748 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
2750 /* This case handles bogus declarations like template <>
2751 template <class T> void f<int>(); */
2753 if (!uses_template_parms (declarator
))
2754 error ("template-id %qD in declaration of primary template",
2756 else if (variable_template_p (TREE_OPERAND (declarator
, 0)))
2758 /* Partial specialization of variable template. */
2759 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
2763 else if (cxx_dialect
< cxx14
)
2764 error ("non-type partial specialization %qD "
2765 "is not allowed", declarator
);
2767 error ("non-class, non-variable partial specialization %qD "
2768 "is not allowed", declarator
);
2773 if (ctype
&& CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
))
2774 /* This is a specialization of a member template, without
2775 specialization the containing class. Something like:
2777 template <class T> struct S {
2778 template <class U> void f (U);
2780 template <> template <class U> void S<int>::f(U) {}
2782 That's a specialization -- but of the entire template. */
2790 if ((specialization
|| member_specialization
)
2791 /* This doesn't apply to variable templates. */
2792 && (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
2793 || TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
))
2795 tree t
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
2796 for (; t
; t
= TREE_CHAIN (t
))
2797 if (TREE_PURPOSE (t
))
2799 permerror (input_location
,
2800 "default argument specified in explicit specialization");
2805 if (specialization
|| member_specialization
|| explicit_instantiation
)
2807 tree tmpl
= NULL_TREE
;
2808 tree targs
= NULL_TREE
;
2809 bool was_template_id
= (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
);
2811 /* Make sure that the declarator is a TEMPLATE_ID_EXPR. */
2812 if (!was_template_id
)
2816 gcc_assert (identifier_p (declarator
));
2821 /* If there is no class context, the explicit instantiation
2822 must be at namespace scope. */
2823 gcc_assert (DECL_NAMESPACE_SCOPE_P (decl
));
2825 /* Find the namespace binding, using the declaration
2827 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
2829 if (fns
== error_mark_node
)
2830 /* If lookup fails, look for a friend declaration so we can
2831 give a better diagnostic. */
2832 fns
= lookup_qualified_name (CP_DECL_CONTEXT (decl
), dname
,
2833 /*type*/false, /*complain*/true,
2836 if (fns
== error_mark_node
|| !is_overloaded_fn (fns
))
2838 error ("%qD is not a template function", dname
);
2839 fns
= error_mark_node
;
2843 declarator
= lookup_template_function (fns
, NULL_TREE
);
2846 if (declarator
== error_mark_node
)
2847 return error_mark_node
;
2849 if (ctype
!= NULL_TREE
&& TYPE_BEING_DEFINED (ctype
))
2851 if (!explicit_instantiation
)
2852 /* A specialization in class scope. This is invalid,
2853 but the error will already have been flagged by
2854 check_specialization_scope. */
2855 return error_mark_node
;
2858 /* It's not valid to write an explicit instantiation in
2861 class C { template void f(); }
2863 This case is caught by the parser. However, on
2866 template class C { void f(); };
2868 (which is invalid) we can get here. The error will be
2875 else if (ctype
!= NULL_TREE
2876 && (identifier_p (TREE_OPERAND (declarator
, 0))))
2878 // We'll match variable templates in start_decl.
2882 /* Find the list of functions in ctype that have the same
2883 name as the declared function. */
2884 tree name
= TREE_OPERAND (declarator
, 0);
2886 if (constructor_name_p (name
, ctype
))
2888 if (DECL_CONSTRUCTOR_P (decl
)
2889 ? !TYPE_HAS_USER_CONSTRUCTOR (ctype
)
2890 : !CLASSTYPE_DESTRUCTOR (ctype
))
2892 /* From [temp.expl.spec]:
2894 If such an explicit specialization for the member
2895 of a class template names an implicitly-declared
2896 special member function (clause _special_), the
2897 program is ill-formed.
2899 Similar language is found in [temp.explicit]. */
2900 error ("specialization of implicitly-declared special member function");
2901 return error_mark_node
;
2904 name
= DECL_NAME (decl
);
2907 /* For a type-conversion operator, We might be looking for
2908 `operator int' which will be a specialization of
2909 `operator T'. Grab all the conversion operators, and
2910 then select from them. */
2911 tree fns
= get_class_binding (ctype
, IDENTIFIER_CONV_OP_P (name
)
2912 ? conv_op_identifier
: name
);
2914 if (fns
== NULL_TREE
)
2916 error ("no member function %qD declared in %qT", name
, ctype
);
2917 return error_mark_node
;
2920 TREE_OPERAND (declarator
, 0) = fns
;
2923 /* Figure out what exactly is being specialized at this point.
2924 Note that for an explicit instantiation, even one for a
2925 member function, we cannot tell a priori whether the
2926 instantiation is for a member template, or just a member
2927 function of a template class. Even if a member template is
2928 being instantiated, the member template arguments may be
2929 elided if they can be deduced from the rest of the
2931 tmpl
= determine_specialization (declarator
, decl
,
2933 member_specialization
,
2937 if (!tmpl
|| tmpl
== error_mark_node
)
2938 /* We couldn't figure out what this declaration was
2940 return error_mark_node
;
2943 if (TREE_CODE (decl
) == FUNCTION_DECL
2944 && DECL_HIDDEN_FRIEND_P (tmpl
))
2946 if (pedwarn (DECL_SOURCE_LOCATION (decl
), 0,
2947 "friend declaration %qD is not visible to "
2948 "explicit specialization", tmpl
))
2949 inform (DECL_SOURCE_LOCATION (tmpl
),
2950 "friend declaration here");
2952 else if (!ctype
&& !is_friend
2953 && CP_DECL_CONTEXT (decl
) == current_namespace
)
2954 check_unqualified_spec_or_inst (tmpl
, DECL_SOURCE_LOCATION (decl
));
2956 tree gen_tmpl
= most_general_template (tmpl
);
2958 if (explicit_instantiation
)
2960 /* We don't set DECL_EXPLICIT_INSTANTIATION here; that
2961 is done by do_decl_instantiation later. */
2963 int arg_depth
= TMPL_ARGS_DEPTH (targs
);
2964 int parm_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
2966 if (arg_depth
> parm_depth
)
2968 /* If TMPL is not the most general template (for
2969 example, if TMPL is a friend template that is
2970 injected into namespace scope), then there will
2971 be too many levels of TARGS. Remove some of them
2976 new_targs
= make_tree_vec (parm_depth
);
2977 for (i
= arg_depth
- parm_depth
; i
< arg_depth
; ++i
)
2978 TREE_VEC_ELT (new_targs
, i
- (arg_depth
- parm_depth
))
2979 = TREE_VEC_ELT (targs
, i
);
2983 return instantiate_template (tmpl
, targs
, tf_error
);
2986 /* If we thought that the DECL was a member function, but it
2987 turns out to be specializing a static member function,
2988 make DECL a static member function as well. */
2989 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
2990 && DECL_STATIC_FUNCTION_P (tmpl
)
2991 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
2992 revert_static_member_fn (decl
);
2994 /* If this is a specialization of a member template of a
2995 template class, we want to return the TEMPLATE_DECL, not
2996 the specialization of it. */
2997 if (tsk
== tsk_template
&& !was_template_id
)
2999 tree result
= DECL_TEMPLATE_RESULT (tmpl
);
3000 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
3001 DECL_INITIAL (result
) = NULL_TREE
;
3005 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
3006 DECL_SOURCE_LOCATION (result
)
3007 = DECL_SOURCE_LOCATION (decl
);
3008 /* We want to use the argument list specified in the
3009 definition, not in the original declaration. */
3010 DECL_ARGUMENTS (result
) = DECL_ARGUMENTS (decl
);
3011 for (parm
= DECL_ARGUMENTS (result
); parm
;
3012 parm
= DECL_CHAIN (parm
))
3013 DECL_CONTEXT (parm
) = result
;
3015 return register_specialization (tmpl
, gen_tmpl
, targs
,
3019 /* Set up the DECL_TEMPLATE_INFO for DECL. */
3020 DECL_TEMPLATE_INFO (decl
) = build_template_info (tmpl
, targs
);
3022 if (was_template_id
)
3023 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl
)) = true;
3025 /* Inherit default function arguments from the template
3026 DECL is specializing. */
3027 if (DECL_FUNCTION_TEMPLATE_P (tmpl
))
3028 copy_default_args_to_explicit_spec (decl
);
3030 /* This specialization has the same protection as the
3031 template it specializes. */
3032 TREE_PRIVATE (decl
) = TREE_PRIVATE (gen_tmpl
);
3033 TREE_PROTECTED (decl
) = TREE_PROTECTED (gen_tmpl
);
3035 /* 7.1.1-1 [dcl.stc]
3037 A storage-class-specifier shall not be specified in an
3038 explicit specialization...
3040 The parser rejects these, so unless action is taken here,
3041 explicit function specializations will always appear with
3044 The action recommended by the C++ CWG in response to C++
3045 defect report 605 is to make the storage class and linkage
3046 of the explicit specialization match the templated function:
3048 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#605
3050 if (tsk
== tsk_expl_spec
&& DECL_FUNCTION_TEMPLATE_P (gen_tmpl
))
3052 tree tmpl_func
= DECL_TEMPLATE_RESULT (gen_tmpl
);
3053 gcc_assert (TREE_CODE (tmpl_func
) == FUNCTION_DECL
);
3055 /* A concept cannot be specialized. */
3056 if (DECL_DECLARED_CONCEPT_P (tmpl_func
))
3058 error ("explicit specialization of function concept %qD",
3060 return error_mark_node
;
3063 /* This specialization has the same linkage and visibility as
3064 the function template it specializes. */
3065 TREE_PUBLIC (decl
) = TREE_PUBLIC (tmpl_func
);
3066 if (! TREE_PUBLIC (decl
))
3068 DECL_INTERFACE_KNOWN (decl
) = 1;
3069 DECL_NOT_REALLY_EXTERN (decl
) = 1;
3071 DECL_THIS_STATIC (decl
) = DECL_THIS_STATIC (tmpl_func
);
3072 if (DECL_VISIBILITY_SPECIFIED (tmpl_func
))
3074 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
3075 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (tmpl_func
);
3079 /* If DECL is a friend declaration, declared using an
3080 unqualified name, the namespace associated with DECL may
3081 have been set incorrectly. For example, in:
3083 template <typename T> void f(T);
3085 struct S { friend void f<int>(int); }
3088 we will have set the DECL_CONTEXT for the friend
3089 declaration to N, rather than to the global namespace. */
3090 if (DECL_NAMESPACE_SCOPE_P (decl
))
3091 DECL_CONTEXT (decl
) = DECL_CONTEXT (tmpl
);
3093 if (is_friend
&& !have_def
)
3094 /* This is not really a declaration of a specialization.
3095 It's just the name of an instantiation. But, it's not
3096 a request for an instantiation, either. */
3097 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
3098 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
3099 /* A specialization is not necessarily COMDAT. */
3100 DECL_COMDAT (decl
) = (TREE_PUBLIC (decl
)
3101 && DECL_DECLARED_INLINE_P (decl
));
3102 else if (VAR_P (decl
))
3103 DECL_COMDAT (decl
) = false;
3105 /* If this is a full specialization, register it so that we can find
3106 it again. Partial specializations will be registered in
3107 process_partial_specialization. */
3108 if (!processing_template_decl
)
3109 decl
= register_specialization (decl
, gen_tmpl
, targs
,
3112 /* A 'structor should already have clones. */
3113 gcc_assert (decl
== error_mark_node
3114 || variable_template_p (tmpl
)
3115 || !(DECL_CONSTRUCTOR_P (decl
)
3116 || DECL_DESTRUCTOR_P (decl
))
3117 || DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)));
3124 /* Returns 1 iff PARMS1 and PARMS2 are identical sets of template
3125 parameters. These are represented in the same format used for
3126 DECL_TEMPLATE_PARMS. */
3129 comp_template_parms (const_tree parms1
, const_tree parms2
)
3134 if (parms1
== parms2
)
3137 for (p1
= parms1
, p2
= parms2
;
3138 p1
!= NULL_TREE
&& p2
!= NULL_TREE
;
3139 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
))
3141 tree t1
= TREE_VALUE (p1
);
3142 tree t2
= TREE_VALUE (p2
);
3145 gcc_assert (TREE_CODE (t1
) == TREE_VEC
);
3146 gcc_assert (TREE_CODE (t2
) == TREE_VEC
);
3148 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
3151 for (i
= 0; i
< TREE_VEC_LENGTH (t2
); ++i
)
3153 tree parm1
= TREE_VALUE (TREE_VEC_ELT (t1
, i
));
3154 tree parm2
= TREE_VALUE (TREE_VEC_ELT (t2
, i
));
3156 /* If either of the template parameters are invalid, assume
3157 they match for the sake of error recovery. */
3158 if (error_operand_p (parm1
) || error_operand_p (parm2
))
3161 if (TREE_CODE (parm1
) != TREE_CODE (parm2
))
3164 if (TREE_CODE (parm1
) == TEMPLATE_TYPE_PARM
3165 && (TEMPLATE_TYPE_PARAMETER_PACK (parm1
)
3166 == TEMPLATE_TYPE_PARAMETER_PACK (parm2
)))
3168 else if (!same_type_p (TREE_TYPE (parm1
), TREE_TYPE (parm2
)))
3173 if ((p1
!= NULL_TREE
) != (p2
!= NULL_TREE
))
3174 /* One set of parameters has more parameters lists than the
3181 /* Determine whether PARM is a parameter pack. */
3184 template_parameter_pack_p (const_tree parm
)
3186 /* Determine if we have a non-type template parameter pack. */
3187 if (TREE_CODE (parm
) == PARM_DECL
)
3188 return (DECL_TEMPLATE_PARM_P (parm
)
3189 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)));
3190 if (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
)
3191 return TEMPLATE_PARM_PARAMETER_PACK (parm
);
3193 /* If this is a list of template parameters, we could get a
3194 TYPE_DECL or a TEMPLATE_DECL. */
3195 if (TREE_CODE (parm
) == TYPE_DECL
|| TREE_CODE (parm
) == TEMPLATE_DECL
)
3196 parm
= TREE_TYPE (parm
);
3198 /* Otherwise it must be a type template parameter. */
3199 return ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
3200 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
3201 && TEMPLATE_TYPE_PARAMETER_PACK (parm
));
3204 /* Determine if T is a function parameter pack. */
3207 function_parameter_pack_p (const_tree t
)
3209 if (t
&& TREE_CODE (t
) == PARM_DECL
)
3210 return DECL_PACK_P (t
);
3214 /* Return the function template declaration of PRIMARY_FUNC_TMPL_INST.
3215 PRIMARY_FUNC_TMPL_INST is a primary function template instantiation. */
3218 get_function_template_decl (const_tree primary_func_tmpl_inst
)
3220 if (! primary_func_tmpl_inst
3221 || TREE_CODE (primary_func_tmpl_inst
) != FUNCTION_DECL
3222 || ! primary_template_instantiation_p (primary_func_tmpl_inst
))
3225 return DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (primary_func_tmpl_inst
));
3228 /* Return true iff the function parameter PARAM_DECL was expanded
3229 from the function parameter pack PACK. */
3232 function_parameter_expanded_from_pack_p (tree param_decl
, tree pack
)
3234 if (DECL_ARTIFICIAL (param_decl
)
3235 || !function_parameter_pack_p (pack
))
3238 /* The parameter pack and its pack arguments have the same
3240 return DECL_PARM_INDEX (pack
) == DECL_PARM_INDEX (param_decl
);
3243 /* Determine whether ARGS describes a variadic template args list,
3244 i.e., one that is terminated by a template argument pack. */
3247 template_args_variadic_p (tree args
)
3252 if (args
== NULL_TREE
)
3255 args
= INNERMOST_TEMPLATE_ARGS (args
);
3256 nargs
= TREE_VEC_LENGTH (args
);
3261 last_parm
= TREE_VEC_ELT (args
, nargs
- 1);
3263 return ARGUMENT_PACK_P (last_parm
);
3266 /* Generate a new name for the parameter pack name NAME (an
3267 IDENTIFIER_NODE) that incorporates its */
3270 make_ith_pack_parameter_name (tree name
, int i
)
3272 /* Munge the name to include the parameter index. */
3273 #define NUMBUF_LEN 128
3274 char numbuf
[NUMBUF_LEN
];
3278 if (name
== NULL_TREE
)
3280 snprintf (numbuf
, NUMBUF_LEN
, "%i", i
);
3281 newname_len
= IDENTIFIER_LENGTH (name
)
3282 + strlen (numbuf
) + 2;
3283 newname
= (char*)alloca (newname_len
);
3284 snprintf (newname
, newname_len
,
3285 "%s#%i", IDENTIFIER_POINTER (name
), i
);
3286 return get_identifier (newname
);
3289 /* Return true if T is a primary function, class or alias template
3293 primary_template_instantiation_p (const_tree t
)
3298 if (TREE_CODE (t
) == FUNCTION_DECL
)
3299 return DECL_LANG_SPECIFIC (t
)
3300 && DECL_TEMPLATE_INSTANTIATION (t
)
3301 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
));
3302 else if (CLASS_TYPE_P (t
) && !TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
3303 return CLASSTYPE_TEMPLATE_INSTANTIATION (t
)
3304 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
));
3305 else if (alias_template_specialization_p (t
))
3310 /* Return true if PARM is a template template parameter. */
3313 template_template_parameter_p (const_tree parm
)
3315 return DECL_TEMPLATE_TEMPLATE_PARM_P (parm
);
3318 /* Return true iff PARM is a DECL representing a type template
3322 template_type_parameter_p (const_tree parm
)
3325 && (TREE_CODE (parm
) == TYPE_DECL
3326 || TREE_CODE (parm
) == TEMPLATE_DECL
)
3327 && DECL_TEMPLATE_PARM_P (parm
));
3330 /* Return the template parameters of T if T is a
3331 primary template instantiation, NULL otherwise. */
3334 get_primary_template_innermost_parameters (const_tree t
)
3336 tree parms
= NULL
, template_info
= NULL
;
3338 if ((template_info
= get_template_info (t
))
3339 && primary_template_instantiation_p (t
))
3340 parms
= INNERMOST_TEMPLATE_PARMS
3341 (DECL_TEMPLATE_PARMS (TI_TEMPLATE (template_info
)));
3346 /* Return the template parameters of the LEVELth level from the full list
3347 of template parameters PARMS. */
3350 get_template_parms_at_level (tree parms
, int level
)
3354 || TREE_CODE (parms
) != TREE_LIST
3355 || level
> TMPL_PARMS_DEPTH (parms
))
3358 for (p
= parms
; p
; p
= TREE_CHAIN (p
))
3359 if (TMPL_PARMS_DEPTH (p
) == level
)
3365 /* Returns the template arguments of T if T is a template instantiation,
3369 get_template_innermost_arguments (const_tree t
)
3371 tree args
= NULL
, template_info
= NULL
;
3373 if ((template_info
= get_template_info (t
))
3374 && TI_ARGS (template_info
))
3375 args
= INNERMOST_TEMPLATE_ARGS (TI_ARGS (template_info
));
3380 /* Return the argument pack elements of T if T is a template argument pack,
3384 get_template_argument_pack_elems (const_tree t
)
3386 if (TREE_CODE (t
) != TYPE_ARGUMENT_PACK
3387 && TREE_CODE (t
) != NONTYPE_ARGUMENT_PACK
)
3390 return ARGUMENT_PACK_ARGS (t
);
3393 /* True iff FN is a function representing a built-in variadic parameter
3397 builtin_pack_fn_p (tree fn
)
3400 || TREE_CODE (fn
) != FUNCTION_DECL
3401 || !DECL_IS_BUILTIN (fn
))
3404 if (id_equal (DECL_NAME (fn
), "__integer_pack"))
3410 /* True iff CALL is a call to a function representing a built-in variadic
3414 builtin_pack_call_p (tree call
)
3416 if (TREE_CODE (call
) != CALL_EXPR
)
3418 return builtin_pack_fn_p (CALL_EXPR_FN (call
));
3421 /* Return a TREE_VEC for the expansion of __integer_pack(HI). */
3424 expand_integer_pack (tree call
, tree args
, tsubst_flags_t complain
,
3427 tree ohi
= CALL_EXPR_ARG (call
, 0);
3428 tree hi
= tsubst_copy_and_build (ohi
, args
, complain
, in_decl
,
3429 false/*fn*/, true/*int_cst*/);
3431 if (value_dependent_expression_p (hi
))
3435 call
= copy_node (call
);
3436 CALL_EXPR_ARG (call
, 0) = hi
;
3438 tree ex
= make_pack_expansion (call
);
3439 tree vec
= make_tree_vec (1);
3440 TREE_VEC_ELT (vec
, 0) = ex
;
3445 hi
= cxx_constant_value (hi
);
3446 int len
= valid_constant_size_p (hi
) ? tree_to_shwi (hi
) : -1;
3448 /* Calculate the largest value of len that won't make the size of the vec
3449 overflow an int. The compiler will exceed resource limits long before
3450 this, but it seems a decent place to diagnose. */
3451 int max
= ((INT_MAX
- sizeof (tree_vec
)) / sizeof (tree
)) + 1;
3453 if (len
< 0 || len
> max
)
3455 if ((complain
& tf_error
)
3456 && hi
!= error_mark_node
)
3457 error ("argument to __integer_pack must be between 0 and %d", max
);
3458 return error_mark_node
;
3461 tree vec
= make_tree_vec (len
);
3463 for (int i
= 0; i
< len
; ++i
)
3464 TREE_VEC_ELT (vec
, i
) = size_int (i
);
3470 /* Return a TREE_VEC for the expansion of built-in template parameter pack
3474 expand_builtin_pack_call (tree call
, tree args
, tsubst_flags_t complain
,
3477 if (!builtin_pack_call_p (call
))
3480 tree fn
= CALL_EXPR_FN (call
);
3482 if (id_equal (DECL_NAME (fn
), "__integer_pack"))
3483 return expand_integer_pack (call
, args
, complain
, in_decl
);
3488 /* Structure used to track the progress of find_parameter_packs_r. */
3489 struct find_parameter_pack_data
3491 /* TREE_LIST that will contain all of the parameter packs found by
3493 tree
* parameter_packs
;
3495 /* Set of AST nodes that have been visited by the traversal. */
3496 hash_set
<tree
> *visited
;
3498 /* True iff we're making a type pack expansion. */
3499 bool type_pack_expansion_p
;
3502 /* Identifies all of the argument packs that occur in a template
3503 argument and appends them to the TREE_LIST inside DATA, which is a
3504 find_parameter_pack_data structure. This is a subroutine of
3505 make_pack_expansion and uses_parameter_packs. */
3507 find_parameter_packs_r (tree
*tp
, int *walk_subtrees
, void* data
)
3510 struct find_parameter_pack_data
* ppd
=
3511 (struct find_parameter_pack_data
*)data
;
3512 bool parameter_pack_p
= false;
3514 /* Handle type aliases/typedefs. */
3515 if (TYPE_ALIAS_P (t
))
3517 if (tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (t
))
3518 cp_walk_tree (&TI_ARGS (tinfo
),
3519 &find_parameter_packs_r
,
3525 /* Identify whether this is a parameter pack or not. */
3526 switch (TREE_CODE (t
))
3528 case TEMPLATE_PARM_INDEX
:
3529 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
3530 parameter_pack_p
= true;
3533 case TEMPLATE_TYPE_PARM
:
3534 t
= TYPE_MAIN_VARIANT (t
);
3536 case TEMPLATE_TEMPLATE_PARM
:
3537 /* If the placeholder appears in the decl-specifier-seq of a function
3538 parameter pack (14.6.3), or the type-specifier-seq of a type-id that
3539 is a pack expansion, the invented template parameter is a template
3541 if (ppd
->type_pack_expansion_p
&& is_auto (t
))
3542 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
3543 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
3544 parameter_pack_p
= true;
3549 if (DECL_PACK_P (t
))
3551 /* We don't want to walk into the type of a PARM_DECL,
3552 because we don't want to see the type parameter pack. */
3554 parameter_pack_p
= true;
3558 /* Look through a lambda capture proxy to the field pack. */
3560 if (DECL_HAS_VALUE_EXPR_P (t
))
3562 tree v
= DECL_VALUE_EXPR (t
);
3564 &find_parameter_packs_r
,
3568 else if (variable_template_specialization_p (t
))
3570 cp_walk_tree (&DECL_TI_ARGS (t
),
3571 find_parameter_packs_r
,
3578 if (builtin_pack_call_p (t
))
3579 parameter_pack_p
= true;
3583 parameter_pack_p
= true;
3586 /* Not a parameter pack. */
3590 if (parameter_pack_p
)
3592 /* Add this parameter pack to the list. */
3593 *ppd
->parameter_packs
= tree_cons (NULL_TREE
, t
, *ppd
->parameter_packs
);
3597 cp_walk_tree (&TYPE_CONTEXT (t
),
3598 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3600 /* This switch statement will return immediately if we don't find a
3602 switch (TREE_CODE (t
))
3604 case TEMPLATE_PARM_INDEX
:
3607 case BOUND_TEMPLATE_TEMPLATE_PARM
:
3608 /* Check the template itself. */
3609 cp_walk_tree (&TREE_TYPE (TYPE_TI_TEMPLATE (t
)),
3610 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3611 /* Check the template arguments. */
3612 cp_walk_tree (&TYPE_TI_ARGS (t
), &find_parameter_packs_r
, ppd
,
3617 case TEMPLATE_TYPE_PARM
:
3618 case TEMPLATE_TEMPLATE_PARM
:
3625 /* Ignore the declaration of a capture proxy for a parameter pack. */
3626 if (is_capture_proxy (DECL_EXPR_DECL (t
)))
3631 if (TYPE_PTRMEMFUNC_P (t
))
3637 if (TYPE_TEMPLATE_INFO (t
))
3638 cp_walk_tree (&TYPE_TI_ARGS (t
),
3639 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3645 if (!DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
3650 cp_walk_tree (&TREE_TYPE (t
),
3651 &find_parameter_packs_r
, ppd
, ppd
->visited
);
3655 cp_walk_tree (&TYPENAME_TYPE_FULLNAME (t
), &find_parameter_packs_r
,
3660 case TYPE_PACK_EXPANSION
:
3661 case EXPR_PACK_EXPANSION
:
3666 cp_walk_tree (&TYPE_MAX_VALUE (t
), &find_parameter_packs_r
,
3671 case IDENTIFIER_NODE
:
3672 cp_walk_tree (&TREE_TYPE (t
), &find_parameter_packs_r
, ppd
,
3679 tree fn
= lambda_function (t
);
3680 cp_walk_tree (&DECL_SAVED_TREE (fn
), &find_parameter_packs_r
, ppd
,
3688 /* When traversing a DECLTYPE_TYPE_EXPR, we need to set
3689 type_pack_expansion_p to false so that any placeholders
3690 within the expression don't get marked as parameter packs. */
3691 bool type_pack_expansion_p
= ppd
->type_pack_expansion_p
;
3692 ppd
->type_pack_expansion_p
= false;
3693 cp_walk_tree (&DECLTYPE_TYPE_EXPR (t
), &find_parameter_packs_r
,
3695 ppd
->type_pack_expansion_p
= type_pack_expansion_p
;
3707 /* Determines if the expression or type T uses any parameter packs. */
3709 uses_parameter_packs (tree t
)
3711 tree parameter_packs
= NULL_TREE
;
3712 struct find_parameter_pack_data ppd
;
3713 ppd
.parameter_packs
= ¶meter_packs
;
3714 ppd
.visited
= new hash_set
<tree
>;
3715 ppd
.type_pack_expansion_p
= false;
3716 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3718 return parameter_packs
!= NULL_TREE
;
3721 /* Turn ARG, which may be an expression, type, or a TREE_LIST
3722 representation a base-class initializer into a parameter pack
3723 expansion. If all goes well, the resulting node will be an
3724 EXPR_PACK_EXPANSION, TYPE_PACK_EXPANSION, or TREE_LIST,
3727 make_pack_expansion (tree arg
)
3730 tree parameter_packs
= NULL_TREE
;
3731 bool for_types
= false;
3732 struct find_parameter_pack_data ppd
;
3734 if (!arg
|| arg
== error_mark_node
)
3737 if (TREE_CODE (arg
) == TREE_LIST
&& TREE_PURPOSE (arg
))
3739 /* A TREE_LIST with a non-null TREE_PURPOSE is for a base
3740 class initializer. In this case, the TREE_PURPOSE will be a
3741 _TYPE node (representing the base class expansion we're
3742 initializing) and the TREE_VALUE will be a TREE_LIST
3743 containing the initialization arguments.
3745 The resulting expansion looks somewhat different from most
3746 expansions. Rather than returning just one _EXPANSION, we
3747 return a TREE_LIST whose TREE_PURPOSE is a
3748 TYPE_PACK_EXPANSION containing the bases that will be
3749 initialized. The TREE_VALUE will be identical to the
3750 original TREE_VALUE, which is a list of arguments that will
3751 be passed to each base. We do not introduce any new pack
3752 expansion nodes into the TREE_VALUE (although it is possible
3753 that some already exist), because the TREE_PURPOSE and
3754 TREE_VALUE all need to be expanded together with the same
3755 _EXPANSION node. Note that the TYPE_PACK_EXPANSION in the
3756 resulting TREE_PURPOSE will mention the parameter packs in
3757 both the bases and the arguments to the bases. */
3760 tree parameter_packs
= NULL_TREE
;
3762 /* Determine which parameter packs will be used by the base
3764 ppd
.visited
= new hash_set
<tree
>;
3765 ppd
.parameter_packs
= ¶meter_packs
;
3766 ppd
.type_pack_expansion_p
= true;
3767 gcc_assert (TYPE_P (TREE_PURPOSE (arg
)));
3768 cp_walk_tree (&TREE_PURPOSE (arg
), &find_parameter_packs_r
,
3771 if (parameter_packs
== NULL_TREE
)
3773 error ("base initializer expansion %qT contains no parameter packs", arg
);
3775 return error_mark_node
;
3778 if (TREE_VALUE (arg
) != void_type_node
)
3780 /* Collect the sets of parameter packs used in each of the
3781 initialization arguments. */
3782 for (value
= TREE_VALUE (arg
); value
; value
= TREE_CHAIN (value
))
3784 /* Determine which parameter packs will be expanded in this
3786 cp_walk_tree (&TREE_VALUE (value
), &find_parameter_packs_r
,
3793 /* Create the pack expansion type for the base type. */
3794 purpose
= cxx_make_type (TYPE_PACK_EXPANSION
);
3795 SET_PACK_EXPANSION_PATTERN (purpose
, TREE_PURPOSE (arg
));
3796 PACK_EXPANSION_PARAMETER_PACKS (purpose
) = parameter_packs
;
3797 PACK_EXPANSION_LOCAL_P (purpose
) = at_function_scope_p ();
3799 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3800 they will rarely be compared to anything. */
3801 SET_TYPE_STRUCTURAL_EQUALITY (purpose
);
3803 return tree_cons (purpose
, TREE_VALUE (arg
), NULL_TREE
);
3806 if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
3809 /* Build the PACK_EXPANSION_* node. */
3811 ? cxx_make_type (TYPE_PACK_EXPANSION
)
3812 : make_node (EXPR_PACK_EXPANSION
);
3813 SET_PACK_EXPANSION_PATTERN (result
, arg
);
3814 if (TREE_CODE (result
) == EXPR_PACK_EXPANSION
)
3816 /* Propagate type and const-expression information. */
3817 TREE_TYPE (result
) = TREE_TYPE (arg
);
3818 TREE_CONSTANT (result
) = TREE_CONSTANT (arg
);
3819 /* Mark this read now, since the expansion might be length 0. */
3820 mark_exp_read (arg
);
3823 /* Just use structural equality for these TYPE_PACK_EXPANSIONS;
3824 they will rarely be compared to anything. */
3825 SET_TYPE_STRUCTURAL_EQUALITY (result
);
3827 /* Determine which parameter packs will be expanded. */
3828 ppd
.parameter_packs
= ¶meter_packs
;
3829 ppd
.visited
= new hash_set
<tree
>;
3830 ppd
.type_pack_expansion_p
= TYPE_P (arg
);
3831 cp_walk_tree (&arg
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3834 /* Make sure we found some parameter packs. */
3835 if (parameter_packs
== NULL_TREE
)
3838 error ("expansion pattern %qT contains no argument packs", arg
);
3840 error ("expansion pattern %qE contains no argument packs", arg
);
3841 return error_mark_node
;
3843 PACK_EXPANSION_PARAMETER_PACKS (result
) = parameter_packs
;
3845 PACK_EXPANSION_LOCAL_P (result
) = at_function_scope_p ();
3850 /* Checks T for any "bare" parameter packs, which have not yet been
3851 expanded, and issues an error if any are found. This operation can
3852 only be done on full expressions or types (e.g., an expression
3853 statement, "if" condition, etc.), because we could have expressions like:
3855 foo(f(g(h(args)))...)
3857 where "args" is a parameter pack. check_for_bare_parameter_packs
3858 should not be called for the subexpressions args, h(args),
3859 g(h(args)), or f(g(h(args))), because we would produce erroneous
3862 Returns TRUE and emits an error if there were bare parameter packs,
3863 returns FALSE otherwise. */
3865 check_for_bare_parameter_packs (tree t
)
3867 tree parameter_packs
= NULL_TREE
;
3868 struct find_parameter_pack_data ppd
;
3870 if (!processing_template_decl
|| !t
|| t
== error_mark_node
)
3873 /* A lambda might use a parameter pack from the containing context. */
3874 if (current_function_decl
&& LAMBDA_FUNCTION_P (current_function_decl
))
3877 if (TREE_CODE (t
) == TYPE_DECL
)
3880 ppd
.parameter_packs
= ¶meter_packs
;
3881 ppd
.visited
= new hash_set
<tree
>;
3882 ppd
.type_pack_expansion_p
= false;
3883 cp_walk_tree (&t
, &find_parameter_packs_r
, &ppd
, ppd
.visited
);
3886 if (parameter_packs
)
3888 location_t loc
= EXPR_LOC_OR_LOC (t
, input_location
);
3889 error_at (loc
, "parameter packs not expanded with %<...%>:");
3890 while (parameter_packs
)
3892 tree pack
= TREE_VALUE (parameter_packs
);
3893 tree name
= NULL_TREE
;
3895 if (TREE_CODE (pack
) == TEMPLATE_TYPE_PARM
3896 || TREE_CODE (pack
) == TEMPLATE_TEMPLATE_PARM
)
3897 name
= TYPE_NAME (pack
);
3898 else if (TREE_CODE (pack
) == TEMPLATE_PARM_INDEX
)
3899 name
= DECL_NAME (TEMPLATE_PARM_DECL (pack
));
3900 else if (TREE_CODE (pack
) == CALL_EXPR
)
3901 name
= DECL_NAME (CALL_EXPR_FN (pack
));
3903 name
= DECL_NAME (pack
);
3906 inform (loc
, " %qD", name
);
3908 inform (loc
, " <anonymous>");
3910 parameter_packs
= TREE_CHAIN (parameter_packs
);
3919 /* Expand any parameter packs that occur in the template arguments in
3922 expand_template_argument_pack (tree args
)
3924 if (args
== error_mark_node
)
3925 return error_mark_node
;
3927 tree result_args
= NULL_TREE
;
3928 int in_arg
, out_arg
= 0, nargs
= args
? TREE_VEC_LENGTH (args
) : 0;
3929 int num_result_args
= -1;
3930 int non_default_args_count
= -1;
3932 /* First, determine if we need to expand anything, and the number of
3933 slots we'll need. */
3934 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3936 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3937 if (arg
== NULL_TREE
)
3939 if (ARGUMENT_PACK_P (arg
))
3941 int num_packed
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
));
3942 if (num_result_args
< 0)
3943 num_result_args
= in_arg
+ num_packed
;
3945 num_result_args
+= num_packed
;
3949 if (num_result_args
>= 0)
3954 /* If no expansion is necessary, we're done. */
3955 if (num_result_args
< 0)
3958 /* Expand arguments. */
3959 result_args
= make_tree_vec (num_result_args
);
3960 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
))
3961 non_default_args_count
=
3962 GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
3963 for (in_arg
= 0; in_arg
< nargs
; ++in_arg
)
3965 tree arg
= TREE_VEC_ELT (args
, in_arg
);
3966 if (ARGUMENT_PACK_P (arg
))
3968 tree packed
= ARGUMENT_PACK_ARGS (arg
);
3969 int i
, num_packed
= TREE_VEC_LENGTH (packed
);
3970 for (i
= 0; i
< num_packed
; ++i
, ++out_arg
)
3971 TREE_VEC_ELT (result_args
, out_arg
) = TREE_VEC_ELT(packed
, i
);
3972 if (non_default_args_count
> 0)
3973 non_default_args_count
+= num_packed
- 1;
3977 TREE_VEC_ELT (result_args
, out_arg
) = arg
;
3981 if (non_default_args_count
>= 0)
3982 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (result_args
, non_default_args_count
);
3986 /* Checks if DECL shadows a template parameter.
3988 [temp.local]: A template-parameter shall not be redeclared within its
3989 scope (including nested scopes).
3991 Emits an error and returns TRUE if the DECL shadows a parameter,
3992 returns FALSE otherwise. */
3995 check_template_shadow (tree decl
)
3999 /* If we're not in a template, we can't possibly shadow a template
4001 if (!current_template_parms
)
4004 /* Figure out what we're shadowing. */
4005 decl
= OVL_FIRST (decl
);
4006 olddecl
= innermost_non_namespace_value (DECL_NAME (decl
));
4008 /* If there's no previous binding for this name, we're not shadowing
4009 anything, let alone a template parameter. */
4013 /* If we're not shadowing a template parameter, we're done. Note
4014 that OLDDECL might be an OVERLOAD (or perhaps even an
4015 ERROR_MARK), so we can't just blithely assume it to be a _DECL
4017 if (!DECL_P (olddecl
) || !DECL_TEMPLATE_PARM_P (olddecl
))
4020 /* We check for decl != olddecl to avoid bogus errors for using a
4021 name inside a class. We check TPFI to avoid duplicate errors for
4022 inline member templates. */
4024 || (DECL_TEMPLATE_PARM_P (decl
)
4025 && TEMPLATE_PARMS_FOR_INLINE (current_template_parms
)))
4028 /* Don't complain about the injected class name, as we've already
4029 complained about the class itself. */
4030 if (DECL_SELF_REFERENCE_P (decl
))
4033 if (DECL_TEMPLATE_PARM_P (decl
))
4034 error ("declaration of template parameter %q+D shadows "
4035 "template parameter", decl
);
4037 error ("declaration of %q+#D shadows template parameter", decl
);
4038 inform (DECL_SOURCE_LOCATION (olddecl
),
4039 "template parameter %qD declared here", olddecl
);
4043 /* Return a new TEMPLATE_PARM_INDEX with the indicated INDEX, LEVEL,
4044 ORIG_LEVEL, DECL, and TYPE. */
4047 build_template_parm_index (int index
,
4053 tree t
= make_node (TEMPLATE_PARM_INDEX
);
4054 TEMPLATE_PARM_IDX (t
) = index
;
4055 TEMPLATE_PARM_LEVEL (t
) = level
;
4056 TEMPLATE_PARM_ORIG_LEVEL (t
) = orig_level
;
4057 TEMPLATE_PARM_DECL (t
) = decl
;
4058 TREE_TYPE (t
) = type
;
4059 TREE_CONSTANT (t
) = TREE_CONSTANT (decl
);
4060 TREE_READONLY (t
) = TREE_READONLY (decl
);
4065 /* Find the canonical type parameter for the given template type
4066 parameter. Returns the canonical type parameter, which may be TYPE
4067 if no such parameter existed. */
4070 canonical_type_parameter (tree type
)
4073 int idx
= TEMPLATE_TYPE_IDX (type
);
4074 if (!canonical_template_parms
)
4075 vec_alloc (canonical_template_parms
, idx
+ 1);
4077 if (canonical_template_parms
->length () <= (unsigned) idx
)
4078 vec_safe_grow_cleared (canonical_template_parms
, idx
+ 1);
4080 list
= (*canonical_template_parms
)[idx
];
4081 while (list
&& !comptypes (type
, TREE_VALUE (list
), COMPARE_STRUCTURAL
))
4082 list
= TREE_CHAIN (list
);
4085 return TREE_VALUE (list
);
4088 (*canonical_template_parms
)[idx
]
4089 = tree_cons (NULL_TREE
, type
, (*canonical_template_parms
)[idx
]);
4094 /* Return a TEMPLATE_PARM_INDEX, similar to INDEX, but whose
4095 TEMPLATE_PARM_LEVEL has been decreased by LEVELS. If such a
4096 TEMPLATE_PARM_INDEX already exists, it is returned; otherwise, a
4097 new one is created. */
4100 reduce_template_parm_level (tree index
, tree type
, int levels
, tree args
,
4101 tsubst_flags_t complain
)
4103 if (TEMPLATE_PARM_DESCENDANTS (index
) == NULL_TREE
4104 || (TEMPLATE_PARM_LEVEL (TEMPLATE_PARM_DESCENDANTS (index
))
4105 != TEMPLATE_PARM_LEVEL (index
) - levels
)
4106 || !same_type_p (type
, TREE_TYPE (TEMPLATE_PARM_DESCENDANTS (index
))))
4108 tree orig_decl
= TEMPLATE_PARM_DECL (index
);
4111 decl
= build_decl (DECL_SOURCE_LOCATION (orig_decl
),
4112 TREE_CODE (orig_decl
), DECL_NAME (orig_decl
), type
);
4113 TREE_CONSTANT (decl
) = TREE_CONSTANT (orig_decl
);
4114 TREE_READONLY (decl
) = TREE_READONLY (orig_decl
);
4115 DECL_ARTIFICIAL (decl
) = 1;
4116 SET_DECL_TEMPLATE_PARM_P (decl
);
4118 t
= build_template_parm_index (TEMPLATE_PARM_IDX (index
),
4119 TEMPLATE_PARM_LEVEL (index
) - levels
,
4120 TEMPLATE_PARM_ORIG_LEVEL (index
),
4122 TEMPLATE_PARM_DESCENDANTS (index
) = t
;
4123 TEMPLATE_PARM_PARAMETER_PACK (t
)
4124 = TEMPLATE_PARM_PARAMETER_PACK (index
);
4126 /* Template template parameters need this. */
4127 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
4129 DECL_TEMPLATE_RESULT (decl
)
4130 = build_decl (DECL_SOURCE_LOCATION (decl
),
4131 TYPE_DECL
, DECL_NAME (decl
), type
);
4132 DECL_ARTIFICIAL (DECL_TEMPLATE_RESULT (decl
)) = true;
4133 DECL_TEMPLATE_PARMS (decl
) = tsubst_template_parms
4134 (DECL_TEMPLATE_PARMS (orig_decl
), args
, complain
);
4138 return TEMPLATE_PARM_DESCENDANTS (index
);
4141 /* Process information from new template parameter PARM and append it
4142 to the LIST being built. This new parameter is a non-type
4143 parameter iff IS_NON_TYPE is true. This new parameter is a
4144 parameter pack iff IS_PARAMETER_PACK is true. The location of PARM
4148 process_template_parm (tree list
, location_t parm_loc
, tree parm
,
4149 bool is_non_type
, bool is_parameter_pack
)
4154 gcc_assert (TREE_CODE (parm
) == TREE_LIST
);
4155 tree defval
= TREE_PURPOSE (parm
);
4156 tree constr
= TREE_TYPE (parm
);
4160 tree p
= tree_last (list
);
4162 if (p
&& TREE_VALUE (p
) != error_mark_node
)
4165 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
4166 idx
= TEMPLATE_TYPE_IDX (TREE_TYPE (p
));
4168 idx
= TEMPLATE_PARM_IDX (DECL_INITIAL (p
));
4176 parm
= TREE_VALUE (parm
);
4178 SET_DECL_TEMPLATE_PARM_P (parm
);
4180 if (TREE_TYPE (parm
) != error_mark_node
)
4184 The top-level cv-qualifiers on the template-parameter are
4185 ignored when determining its type. */
4186 TREE_TYPE (parm
) = TYPE_MAIN_VARIANT (TREE_TYPE (parm
));
4187 if (invalid_nontype_parm_type_p (TREE_TYPE (parm
), 1))
4188 TREE_TYPE (parm
) = error_mark_node
;
4189 else if (uses_parameter_packs (TREE_TYPE (parm
))
4190 && !is_parameter_pack
4191 /* If we're in a nested template parameter list, the template
4192 template parameter could be a parameter pack. */
4193 && processing_template_parmlist
== 1)
4195 /* This template parameter is not a parameter pack, but it
4196 should be. Complain about "bare" parameter packs. */
4197 check_for_bare_parameter_packs (TREE_TYPE (parm
));
4199 /* Recover by calling this a parameter pack. */
4200 is_parameter_pack
= true;
4204 /* A template parameter is not modifiable. */
4205 TREE_CONSTANT (parm
) = 1;
4206 TREE_READONLY (parm
) = 1;
4207 decl
= build_decl (parm_loc
,
4208 CONST_DECL
, DECL_NAME (parm
), TREE_TYPE (parm
));
4209 TREE_CONSTANT (decl
) = 1;
4210 TREE_READONLY (decl
) = 1;
4211 DECL_INITIAL (parm
) = DECL_INITIAL (decl
)
4212 = build_template_parm_index (idx
, processing_template_decl
,
4213 processing_template_decl
,
4214 decl
, TREE_TYPE (parm
));
4216 TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
))
4217 = is_parameter_pack
;
4222 parm
= TREE_VALUE (TREE_VALUE (parm
));
4224 if (parm
&& TREE_CODE (parm
) == TEMPLATE_DECL
)
4226 t
= cxx_make_type (TEMPLATE_TEMPLATE_PARM
);
4227 /* This is for distinguishing between real templates and template
4228 template parameters */
4229 TREE_TYPE (parm
) = t
;
4230 TREE_TYPE (DECL_TEMPLATE_RESULT (parm
)) = t
;
4235 t
= cxx_make_type (TEMPLATE_TYPE_PARM
);
4236 /* parm is either IDENTIFIER_NODE or NULL_TREE. */
4237 decl
= build_decl (parm_loc
,
4238 TYPE_DECL
, parm
, t
);
4241 TYPE_NAME (t
) = decl
;
4242 TYPE_STUB_DECL (t
) = decl
;
4244 TEMPLATE_TYPE_PARM_INDEX (t
)
4245 = build_template_parm_index (idx
, processing_template_decl
,
4246 processing_template_decl
,
4247 decl
, TREE_TYPE (parm
));
4248 TEMPLATE_TYPE_PARAMETER_PACK (t
) = is_parameter_pack
;
4249 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
4251 DECL_ARTIFICIAL (decl
) = 1;
4252 SET_DECL_TEMPLATE_PARM_P (decl
);
4254 /* Build requirements for the type/template parameter.
4255 This must be done after SET_DECL_TEMPLATE_PARM_P or
4256 process_template_parm could fail. */
4257 tree reqs
= finish_shorthand_constraint (parm
, constr
);
4261 /* Build the parameter node linking the parameter declaration,
4262 its default argument (if any), and its constraints (if any). */
4263 parm
= build_tree_list (defval
, parm
);
4264 TEMPLATE_PARM_CONSTRAINTS (parm
) = reqs
;
4266 return chainon (list
, parm
);
4269 /* The end of a template parameter list has been reached. Process the
4270 tree list into a parameter vector, converting each parameter into a more
4271 useful form. Type parameters are saved as IDENTIFIER_NODEs, and others
4275 end_template_parm_list (tree parms
)
4279 tree saved_parmlist
= make_tree_vec (list_length (parms
));
4281 /* Pop the dummy parameter level and add the real one. */
4282 current_template_parms
= TREE_CHAIN (current_template_parms
);
4284 current_template_parms
4285 = tree_cons (size_int (processing_template_decl
),
4286 saved_parmlist
, current_template_parms
);
4288 for (parm
= parms
, nparms
= 0; parm
; parm
= next
, nparms
++)
4290 next
= TREE_CHAIN (parm
);
4291 TREE_VEC_ELT (saved_parmlist
, nparms
) = parm
;
4292 TREE_CHAIN (parm
) = NULL_TREE
;
4295 --processing_template_parmlist
;
4297 return saved_parmlist
;
4300 // Explicitly indicate the end of the template parameter list. We assume
4301 // that the current template parameters have been constructed and/or
4302 // managed explicitly, as when creating new template template parameters
4303 // from a shorthand constraint.
4305 end_template_parm_list ()
4307 --processing_template_parmlist
;
4310 /* end_template_decl is called after a template declaration is seen. */
4313 end_template_decl (void)
4315 reset_specialization ();
4317 if (! processing_template_decl
)
4320 /* This matches the pushlevel in begin_template_parm_list. */
4323 --processing_template_decl
;
4324 current_template_parms
= TREE_CHAIN (current_template_parms
);
4327 /* Takes a TREE_LIST representing a template parameter and convert it
4328 into an argument suitable to be passed to the type substitution
4329 functions. Note that If the TREE_LIST contains an error_mark
4330 node, the returned argument is error_mark_node. */
4333 template_parm_to_arg (tree t
)
4337 || TREE_CODE (t
) != TREE_LIST
)
4340 if (error_operand_p (TREE_VALUE (t
)))
4341 return error_mark_node
;
4345 if (TREE_CODE (t
) == TYPE_DECL
4346 || TREE_CODE (t
) == TEMPLATE_DECL
)
4350 if (TEMPLATE_TYPE_PARAMETER_PACK (t
))
4352 /* Turn this argument into a TYPE_ARGUMENT_PACK
4353 with a single element, which expands T. */
4354 tree vec
= make_tree_vec (1);
4356 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec
, TREE_VEC_LENGTH (vec
));
4358 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
4360 t
= cxx_make_type (TYPE_ARGUMENT_PACK
);
4361 SET_ARGUMENT_PACK_ARGS (t
, vec
);
4366 t
= DECL_INITIAL (t
);
4368 if (TEMPLATE_PARM_PARAMETER_PACK (t
))
4370 /* Turn this argument into a NONTYPE_ARGUMENT_PACK
4371 with a single element, which expands T. */
4372 tree vec
= make_tree_vec (1);
4374 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec
, TREE_VEC_LENGTH (vec
));
4376 t
= convert_from_reference (t
);
4377 TREE_VEC_ELT (vec
, 0) = make_pack_expansion (t
);
4379 t
= make_node (NONTYPE_ARGUMENT_PACK
);
4380 SET_ARGUMENT_PACK_ARGS (t
, vec
);
4383 t
= convert_from_reference (t
);
4388 /* Given a single level of template parameters (a TREE_VEC), return it
4389 as a set of template arguments. */
4392 template_parms_level_to_args (tree parms
)
4394 tree a
= copy_node (parms
);
4395 TREE_TYPE (a
) = NULL_TREE
;
4396 for (int i
= TREE_VEC_LENGTH (a
) - 1; i
>= 0; --i
)
4397 TREE_VEC_ELT (a
, i
) = template_parm_to_arg (TREE_VEC_ELT (a
, i
));
4400 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a
, TREE_VEC_LENGTH (a
));
4405 /* Given a set of template parameters, return them as a set of template
4406 arguments. The template parameters are represented as a TREE_VEC, in
4407 the form documented in cp-tree.h for template arguments. */
4410 template_parms_to_args (tree parms
)
4413 tree args
= NULL_TREE
;
4414 int length
= TMPL_PARMS_DEPTH (parms
);
4417 /* If there is only one level of template parameters, we do not
4418 create a TREE_VEC of TREE_VECs. Instead, we return a single
4419 TREE_VEC containing the arguments. */
4421 args
= make_tree_vec (length
);
4423 for (header
= parms
; header
; header
= TREE_CHAIN (header
))
4425 tree a
= template_parms_level_to_args (TREE_VALUE (header
));
4428 TREE_VEC_ELT (args
, --l
) = a
;
4436 /* Within the declaration of a template, return the currently active
4437 template parameters as an argument TREE_VEC. */
4440 current_template_args (void)
4442 return template_parms_to_args (current_template_parms
);
4445 /* Update the declared TYPE by doing any lookups which were thought to be
4446 dependent, but are not now that we know the SCOPE of the declarator. */
4449 maybe_update_decl_type (tree orig_type
, tree scope
)
4451 tree type
= orig_type
;
4453 if (type
== NULL_TREE
)
4456 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4457 type
= TREE_TYPE (type
);
4459 if (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
4460 && dependent_type_p (type
)
4461 /* Don't bother building up the args in this case. */
4462 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
4464 /* tsubst in the args corresponding to the template parameters,
4465 including auto if present. Most things will be unchanged, but
4466 make_typename_type and tsubst_qualified_id will resolve
4467 TYPENAME_TYPEs and SCOPE_REFs that were previously dependent. */
4468 tree args
= current_template_args ();
4469 tree auto_node
= type_uses_auto (type
);
4473 tree auto_vec
= make_tree_vec (1);
4474 TREE_VEC_ELT (auto_vec
, 0) = auto_node
;
4475 args
= add_to_template_args (args
, auto_vec
);
4477 pushed
= push_scope (scope
);
4478 type
= tsubst (type
, args
, tf_warning_or_error
, NULL_TREE
);
4483 if (type
== error_mark_node
)
4486 if (TREE_CODE (orig_type
) == TYPE_DECL
)
4488 if (same_type_p (type
, TREE_TYPE (orig_type
)))
4491 type
= TYPE_NAME (type
);
4496 /* Return a TEMPLATE_DECL corresponding to DECL, using the indicated
4497 template PARMS and constraints, CONSTR. If MEMBER_TEMPLATE_P is true,
4498 the new template is a member template. */
4501 build_template_decl (tree decl
, tree parms
, bool member_template_p
)
4503 tree tmpl
= build_lang_decl (TEMPLATE_DECL
, DECL_NAME (decl
), NULL_TREE
);
4504 DECL_TEMPLATE_PARMS (tmpl
) = parms
;
4505 DECL_CONTEXT (tmpl
) = DECL_CONTEXT (decl
);
4506 DECL_SOURCE_LOCATION (tmpl
) = DECL_SOURCE_LOCATION (decl
);
4507 DECL_MEMBER_TEMPLATE_P (tmpl
) = member_template_p
;
4512 struct template_parm_data
4514 /* The level of the template parameters we are currently
4518 /* The index of the specialization argument we are currently
4522 /* An array whose size is the number of template parameters. The
4523 elements are nonzero if the parameter has been used in any one
4524 of the arguments processed so far. */
4527 /* An array whose size is the number of template arguments. The
4528 elements are nonzero if the argument makes use of template
4529 parameters of this level. */
4530 int* arg_uses_template_parms
;
4533 /* Subroutine of push_template_decl used to see if each template
4534 parameter in a partial specialization is used in the explicit
4535 argument list. If T is of the LEVEL given in DATA (which is
4536 treated as a template_parm_data*), then DATA->PARMS is marked
4540 mark_template_parm (tree t
, void* data
)
4544 struct template_parm_data
* tpd
= (struct template_parm_data
*) data
;
4546 template_parm_level_and_index (t
, &level
, &idx
);
4548 if (level
== tpd
->level
)
4550 tpd
->parms
[idx
] = 1;
4551 tpd
->arg_uses_template_parms
[tpd
->current_arg
] = 1;
4554 /* In C++17 the type of a non-type argument is a deduced context. */
4555 if (cxx_dialect
>= cxx17
4556 && TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
4557 for_each_template_parm (TREE_TYPE (t
),
4558 &mark_template_parm
,
4561 /*include_nondeduced_p=*/false);
4563 /* Return zero so that for_each_template_parm will continue the
4564 traversal of the tree; we want to mark *every* template parm. */
4568 /* Process the partial specialization DECL. */
4571 process_partial_specialization (tree decl
)
4573 tree type
= TREE_TYPE (decl
);
4574 tree tinfo
= get_template_info (decl
);
4575 tree maintmpl
= TI_TEMPLATE (tinfo
);
4576 tree specargs
= TI_ARGS (tinfo
);
4577 tree inner_args
= INNERMOST_TEMPLATE_ARGS (specargs
);
4578 tree main_inner_parms
= DECL_INNERMOST_TEMPLATE_PARMS (maintmpl
);
4581 int nargs
= TREE_VEC_LENGTH (inner_args
);
4584 bool did_error_intro
= false;
4585 struct template_parm_data tpd
;
4586 struct template_parm_data tpd2
;
4588 gcc_assert (current_template_parms
);
4590 /* A concept cannot be specialized. */
4591 if (flag_concepts
&& variable_concept_p (maintmpl
))
4593 error ("specialization of variable concept %q#D", maintmpl
);
4594 return error_mark_node
;
4597 inner_parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
4598 ntparms
= TREE_VEC_LENGTH (inner_parms
);
4600 /* We check that each of the template parameters given in the
4601 partial specialization is used in the argument list to the
4602 specialization. For example:
4604 template <class T> struct S;
4605 template <class T> struct S<T*>;
4607 The second declaration is OK because `T*' uses the template
4608 parameter T, whereas
4610 template <class T> struct S<int>;
4612 is no good. Even trickier is:
4623 The S2<T> declaration is actually invalid; it is a
4624 full-specialization. Of course,
4627 struct S2<T (*)(U)>;
4629 or some such would have been OK. */
4630 tpd
.level
= TMPL_PARMS_DEPTH (current_template_parms
);
4631 tpd
.parms
= XALLOCAVEC (int, ntparms
);
4632 memset (tpd
.parms
, 0, sizeof (int) * ntparms
);
4634 tpd
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4635 memset (tpd
.arg_uses_template_parms
, 0, sizeof (int) * nargs
);
4636 for (i
= 0; i
< nargs
; ++i
)
4638 tpd
.current_arg
= i
;
4639 for_each_template_parm (TREE_VEC_ELT (inner_args
, i
),
4640 &mark_template_parm
,
4643 /*include_nondeduced_p=*/false);
4645 for (i
= 0; i
< ntparms
; ++i
)
4646 if (tpd
.parms
[i
] == 0)
4648 /* One of the template parms was not used in a deduced context in the
4650 if (!did_error_intro
)
4652 error ("template parameters not deducible in "
4653 "partial specialization:");
4654 did_error_intro
= true;
4657 inform (input_location
, " %qD",
4658 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
)));
4661 if (did_error_intro
)
4662 return error_mark_node
;
4664 /* [temp.class.spec]
4666 The argument list of the specialization shall not be identical to
4667 the implicit argument list of the primary template. */
4669 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (maintmpl
)));
4670 if (comp_template_args (inner_args
, INNERMOST_TEMPLATE_ARGS (main_args
))
4672 || !strictly_subsumes (current_template_constraints (),
4673 get_constraints (maintmpl
))))
4676 error ("partial specialization %q+D does not specialize "
4677 "any template arguments", decl
);
4679 error ("partial specialization %q+D does not specialize any "
4680 "template arguments and is not more constrained than", decl
);
4681 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4684 /* A partial specialization that replaces multiple parameters of the
4685 primary template with a pack expansion is less specialized for those
4687 if (nargs
< DECL_NTPARMS (maintmpl
))
4689 error ("partial specialization is not more specialized than the "
4690 "primary template because it replaces multiple parameters "
4691 "with a pack expansion");
4692 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template here");
4693 /* Avoid crash in process_partial_specialization. */
4697 /* If we aren't in a dependent class, we can actually try deduction. */
4698 else if (tpd
.level
== 1
4699 /* FIXME we should be able to handle a partial specialization of a
4700 partial instantiation, but currently we can't (c++/41727). */
4701 && TMPL_ARGS_DEPTH (specargs
) == 1
4702 && !get_partial_spec_bindings (maintmpl
, maintmpl
, specargs
))
4704 if (permerror (input_location
, "partial specialization %qD is not "
4705 "more specialized than", decl
))
4706 inform (DECL_SOURCE_LOCATION (maintmpl
), "primary template %qD",
4710 /* [temp.class.spec]
4712 A partially specialized non-type argument expression shall not
4713 involve template parameters of the partial specialization except
4714 when the argument expression is a simple identifier.
4716 The type of a template parameter corresponding to a specialized
4717 non-type argument shall not be dependent on a parameter of the
4720 Also, we verify that pack expansions only occur at the
4721 end of the argument list. */
4722 gcc_assert (nargs
== DECL_NTPARMS (maintmpl
));
4724 for (i
= 0; i
< nargs
; ++i
)
4726 tree parm
= TREE_VALUE (TREE_VEC_ELT (main_inner_parms
, i
));
4727 tree arg
= TREE_VEC_ELT (inner_args
, i
);
4728 tree packed_args
= NULL_TREE
;
4731 if (ARGUMENT_PACK_P (arg
))
4733 /* Extract the arguments from the argument pack. We'll be
4734 iterating over these in the following loop. */
4735 packed_args
= ARGUMENT_PACK_ARGS (arg
);
4736 len
= TREE_VEC_LENGTH (packed_args
);
4739 for (j
= 0; j
< len
; j
++)
4742 /* Get the Jth argument in the parameter pack. */
4743 arg
= TREE_VEC_ELT (packed_args
, j
);
4745 if (PACK_EXPANSION_P (arg
))
4747 /* Pack expansions must come at the end of the
4749 if ((packed_args
&& j
< len
- 1)
4750 || (!packed_args
&& i
< nargs
- 1))
4752 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4753 error ("parameter pack argument %qE must be at the "
4754 "end of the template argument list", arg
);
4756 error ("parameter pack argument %qT must be at the "
4757 "end of the template argument list", arg
);
4761 if (TREE_CODE (arg
) == EXPR_PACK_EXPANSION
)
4762 /* We only care about the pattern. */
4763 arg
= PACK_EXPANSION_PATTERN (arg
);
4765 if (/* These first two lines are the `non-type' bit. */
4767 && TREE_CODE (arg
) != TEMPLATE_DECL
4768 /* This next two lines are the `argument expression is not just a
4769 simple identifier' condition and also the `specialized
4770 non-type argument' bit. */
4771 && TREE_CODE (arg
) != TEMPLATE_PARM_INDEX
4772 && !(REFERENCE_REF_P (arg
)
4773 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_PARM_INDEX
))
4775 if ((!packed_args
&& tpd
.arg_uses_template_parms
[i
])
4776 || (packed_args
&& uses_template_parms (arg
)))
4777 error ("template argument %qE involves template parameter(s)",
4781 /* Look at the corresponding template parameter,
4782 marking which template parameters its type depends
4784 tree type
= TREE_TYPE (parm
);
4788 /* We haven't yet initialized TPD2. Do so now. */
4789 tpd2
.arg_uses_template_parms
= XALLOCAVEC (int, nargs
);
4790 /* The number of parameters here is the number in the
4791 main template, which, as checked in the assertion
4793 tpd2
.parms
= XALLOCAVEC (int, nargs
);
4795 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (maintmpl
));
4798 /* Mark the template parameters. But this time, we're
4799 looking for the template parameters of the main
4800 template, not in the specialization. */
4801 tpd2
.current_arg
= i
;
4802 tpd2
.arg_uses_template_parms
[i
] = 0;
4803 memset (tpd2
.parms
, 0, sizeof (int) * nargs
);
4804 for_each_template_parm (type
,
4805 &mark_template_parm
,
4808 /*include_nondeduced_p=*/false);
4810 if (tpd2
.arg_uses_template_parms
[i
])
4812 /* The type depended on some template parameters.
4813 If they are fully specialized in the
4814 specialization, that's OK. */
4817 for (j
= 0; j
< nargs
; ++j
)
4818 if (tpd2
.parms
[j
] != 0
4819 && tpd
.arg_uses_template_parms
[j
])
4822 error_n (input_location
, count
,
4823 "type %qT of template argument %qE depends "
4824 "on a template parameter",
4825 "type %qT of template argument %qE depends "
4826 "on template parameters",
4835 /* We should only get here once. */
4836 if (TREE_CODE (decl
) == TYPE_DECL
)
4837 gcc_assert (!COMPLETE_TYPE_P (type
));
4839 // Build the template decl.
4840 tree tmpl
= build_template_decl (decl
, current_template_parms
,
4841 DECL_MEMBER_TEMPLATE_P (maintmpl
));
4842 TREE_TYPE (tmpl
) = type
;
4843 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
4844 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
4845 DECL_TEMPLATE_INFO (tmpl
) = build_template_info (maintmpl
, specargs
);
4846 DECL_PRIMARY_TEMPLATE (tmpl
) = maintmpl
;
4848 /* Give template template parms a DECL_CONTEXT of the template
4849 for which they are a parameter. */
4850 for (i
= 0; i
< ntparms
; ++i
)
4852 tree parm
= TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
));
4853 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
4854 DECL_CONTEXT (parm
) = tmpl
;
4858 /* We didn't register this in check_explicit_specialization so we could
4859 wait until the constraints were set. */
4860 decl
= register_specialization (decl
, maintmpl
, specargs
, false, 0);
4862 associate_classtype_constraints (type
);
4864 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)
4865 = tree_cons (specargs
, tmpl
,
4866 DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
));
4867 TREE_TYPE (DECL_TEMPLATE_SPECIALIZATIONS (maintmpl
)) = type
;
4869 for (inst
= DECL_TEMPLATE_INSTANTIATIONS (maintmpl
); inst
;
4870 inst
= TREE_CHAIN (inst
))
4872 tree instance
= TREE_VALUE (inst
);
4873 if (TYPE_P (instance
)
4874 ? (COMPLETE_TYPE_P (instance
)
4875 && CLASSTYPE_IMPLICIT_INSTANTIATION (instance
))
4876 : DECL_TEMPLATE_INSTANTIATION (instance
))
4878 tree spec
= most_specialized_partial_spec (instance
, tf_none
);
4879 tree inst_decl
= (DECL_P (instance
)
4880 ? instance
: TYPE_NAME (instance
));
4883 else if (spec
== error_mark_node
)
4884 permerror (input_location
,
4885 "declaration of %qD ambiguates earlier template "
4886 "instantiation for %qD", decl
, inst_decl
);
4887 else if (TREE_VALUE (spec
) == tmpl
)
4888 permerror (input_location
,
4889 "partial specialization of %qD after instantiation "
4890 "of %qD", decl
, inst_decl
);
4897 /* PARM is a template parameter of some form; return the corresponding
4898 TEMPLATE_PARM_INDEX. */
4901 get_template_parm_index (tree parm
)
4903 if (TREE_CODE (parm
) == PARM_DECL
4904 || TREE_CODE (parm
) == CONST_DECL
)
4905 parm
= DECL_INITIAL (parm
);
4906 else if (TREE_CODE (parm
) == TYPE_DECL
4907 || TREE_CODE (parm
) == TEMPLATE_DECL
)
4908 parm
= TREE_TYPE (parm
);
4909 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
4910 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
4911 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
)
4912 parm
= TEMPLATE_TYPE_PARM_INDEX (parm
);
4913 gcc_assert (TREE_CODE (parm
) == TEMPLATE_PARM_INDEX
);
4917 /* Subroutine of fixed_parameter_pack_p below. Look for any template
4918 parameter packs used by the template parameter PARM. */
4921 fixed_parameter_pack_p_1 (tree parm
, struct find_parameter_pack_data
*ppd
)
4923 /* A type parm can't refer to another parm. */
4924 if (TREE_CODE (parm
) == TYPE_DECL
)
4926 else if (TREE_CODE (parm
) == PARM_DECL
)
4928 cp_walk_tree (&TREE_TYPE (parm
), &find_parameter_packs_r
,
4933 gcc_assert (TREE_CODE (parm
) == TEMPLATE_DECL
);
4935 tree vec
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (parm
));
4936 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
4937 fixed_parameter_pack_p_1 (TREE_VALUE (TREE_VEC_ELT (vec
, i
)), ppd
);
4940 /* PARM is a template parameter pack. Return any parameter packs used in
4941 its type or the type of any of its template parameters. If there are
4942 any such packs, it will be instantiated into a fixed template parameter
4943 list by partial instantiation rather than be fully deduced. */
4946 fixed_parameter_pack_p (tree parm
)
4948 /* This can only be true in a member template. */
4949 if (TEMPLATE_PARM_ORIG_LEVEL (get_template_parm_index (parm
)) < 2)
4951 /* This can only be true for a parameter pack. */
4952 if (!template_parameter_pack_p (parm
))
4954 /* A type parm can't refer to another parm. */
4955 if (TREE_CODE (parm
) == TYPE_DECL
)
4958 tree parameter_packs
= NULL_TREE
;
4959 struct find_parameter_pack_data ppd
;
4960 ppd
.parameter_packs
= ¶meter_packs
;
4961 ppd
.visited
= new hash_set
<tree
>;
4962 ppd
.type_pack_expansion_p
= false;
4964 fixed_parameter_pack_p_1 (parm
, &ppd
);
4967 return parameter_packs
;
4970 /* Check that a template declaration's use of default arguments and
4971 parameter packs is not invalid. Here, PARMS are the template
4972 parameters. IS_PRIMARY is true if DECL is the thing declared by
4973 a primary template. IS_PARTIAL is true if DECL is a partial
4976 IS_FRIEND_DECL is nonzero if DECL is a friend function template
4977 declaration (but not a definition); 1 indicates a declaration, 2
4978 indicates a redeclaration. When IS_FRIEND_DECL=2, no errors are
4979 emitted for extraneous default arguments.
4981 Returns TRUE if there were no errors found, FALSE otherwise. */
4984 check_default_tmpl_args (tree decl
, tree parms
, bool is_primary
,
4985 bool is_partial
, int is_friend_decl
)
4988 int last_level_to_check
;
4990 bool no_errors
= true;
4994 A default template-argument shall not be specified in a
4995 function template declaration or a function template definition, nor
4996 in the template-parameter-list of the definition of a member of a
4999 if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
5000 || (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_LOCAL_FUNCTION_P (decl
)))
5001 /* You can't have a function template declaration in a local
5002 scope, nor you can you define a member of a class template in a
5006 if ((TREE_CODE (decl
) == TYPE_DECL
5008 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5009 || (TREE_CODE (decl
) == FUNCTION_DECL
5010 && LAMBDA_FUNCTION_P (decl
)))
5011 /* A lambda doesn't have an explicit declaration; don't complain
5012 about the parms of the enclosing class. */
5015 if (current_class_type
5016 && !TYPE_BEING_DEFINED (current_class_type
)
5017 && DECL_LANG_SPECIFIC (decl
)
5018 && DECL_DECLARES_FUNCTION_P (decl
)
5019 /* If this is either a friend defined in the scope of the class
5020 or a member function. */
5021 && (DECL_FUNCTION_MEMBER_P (decl
)
5022 ? same_type_p (DECL_CONTEXT (decl
), current_class_type
)
5023 : DECL_FRIEND_CONTEXT (decl
)
5024 ? same_type_p (DECL_FRIEND_CONTEXT (decl
), current_class_type
)
5026 /* And, if it was a member function, it really was defined in
5027 the scope of the class. */
5028 && (!DECL_FUNCTION_MEMBER_P (decl
)
5029 || DECL_INITIALIZED_IN_CLASS_P (decl
)))
5030 /* We already checked these parameters when the template was
5031 declared, so there's no need to do it again now. This function
5032 was defined in class scope, but we're processing its body now
5033 that the class is complete. */
5036 /* Core issue 226 (C++0x only): the following only applies to class
5039 && ((cxx_dialect
== cxx98
) || TREE_CODE (decl
) != FUNCTION_DECL
))
5043 If a template-parameter has a default template-argument, all
5044 subsequent template-parameters shall have a default
5045 template-argument supplied. */
5046 for (parm_level
= parms
; parm_level
; parm_level
= TREE_CHAIN (parm_level
))
5048 tree inner_parms
= TREE_VALUE (parm_level
);
5049 int ntparms
= TREE_VEC_LENGTH (inner_parms
);
5050 int seen_def_arg_p
= 0;
5053 for (i
= 0; i
< ntparms
; ++i
)
5055 tree parm
= TREE_VEC_ELT (inner_parms
, i
);
5057 if (parm
== error_mark_node
)
5060 if (TREE_PURPOSE (parm
))
5062 else if (seen_def_arg_p
5063 && !template_parameter_pack_p (TREE_VALUE (parm
)))
5065 error ("no default argument for %qD", TREE_VALUE (parm
));
5066 /* For better subsequent error-recovery, we indicate that
5067 there should have been a default argument. */
5068 TREE_PURPOSE (parm
) = error_mark_node
;
5071 else if (!is_partial
5073 /* Don't complain about an enclosing partial
5075 && parm_level
== parms
5076 && TREE_CODE (decl
) == TYPE_DECL
5078 && template_parameter_pack_p (TREE_VALUE (parm
))
5079 /* A fixed parameter pack will be partially
5080 instantiated into a fixed length list. */
5081 && !fixed_parameter_pack_p (TREE_VALUE (parm
)))
5083 /* A primary class template can only have one
5084 parameter pack, at the end of the template
5087 error ("parameter pack %q+D must be at the end of the"
5088 " template parameter list", TREE_VALUE (parm
));
5090 TREE_VALUE (TREE_VEC_ELT (inner_parms
, i
))
5098 if (((cxx_dialect
== cxx98
) && TREE_CODE (decl
) != TYPE_DECL
)
5102 /* For an ordinary class template, default template arguments are
5103 allowed at the innermost level, e.g.:
5104 template <class T = int>
5106 but, in a partial specialization, they're not allowed even
5107 there, as we have in [temp.class.spec]:
5109 The template parameter list of a specialization shall not
5110 contain default template argument values.
5112 So, for a partial specialization, or for a function template
5113 (in C++98/C++03), we look at all of them. */
5116 /* But, for a primary class template that is not a partial
5117 specialization we look at all template parameters except the
5119 parms
= TREE_CHAIN (parms
);
5121 /* Figure out what error message to issue. */
5122 if (is_friend_decl
== 2)
5123 msg
= G_("default template arguments may not be used in function template "
5124 "friend re-declaration");
5125 else if (is_friend_decl
)
5126 msg
= G_("default template arguments may not be used in function template "
5127 "friend declarations");
5128 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& (cxx_dialect
== cxx98
))
5129 msg
= G_("default template arguments may not be used in function templates "
5130 "without -std=c++11 or -std=gnu++11");
5131 else if (is_partial
)
5132 msg
= G_("default template arguments may not be used in "
5133 "partial specializations");
5134 else if (current_class_type
&& CLASSTYPE_IS_TEMPLATE (current_class_type
))
5135 msg
= G_("default argument for template parameter for class enclosing %qD");
5137 /* Per [temp.param]/9, "A default template-argument shall not be
5138 specified in the template-parameter-lists of the definition of
5139 a member of a class template that appears outside of the member's
5140 class.", thus if we aren't handling a member of a class template
5141 there is no need to examine the parameters. */
5144 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
5145 /* If we're inside a class definition, there's no need to
5146 examine the parameters to the class itself. On the one
5147 hand, they will be checked when the class is defined, and,
5148 on the other, default arguments are valid in things like:
5149 template <class T = double>
5150 struct S { template <class U> void f(U); };
5151 Here the default argument for `S' has no bearing on the
5152 declaration of `f'. */
5153 last_level_to_check
= template_class_depth (current_class_type
) + 1;
5155 /* Check everything. */
5156 last_level_to_check
= 0;
5158 for (parm_level
= parms
;
5159 parm_level
&& TMPL_PARMS_DEPTH (parm_level
) >= last_level_to_check
;
5160 parm_level
= TREE_CHAIN (parm_level
))
5162 tree inner_parms
= TREE_VALUE (parm_level
);
5166 ntparms
= TREE_VEC_LENGTH (inner_parms
);
5167 for (i
= 0; i
< ntparms
; ++i
)
5169 if (TREE_VEC_ELT (inner_parms
, i
) == error_mark_node
)
5172 if (TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)))
5177 if (is_friend_decl
== 2)
5184 /* Clear out the default argument so that we are not
5186 TREE_PURPOSE (TREE_VEC_ELT (inner_parms
, i
)) = NULL_TREE
;
5190 /* At this point, if we're still interested in issuing messages,
5191 they must apply to classes surrounding the object declared. */
5193 msg
= G_("default argument for template parameter for class "
5200 /* Worker for push_template_decl_real, called via
5201 for_each_template_parm. DATA is really an int, indicating the
5202 level of the parameters we are interested in. If T is a template
5203 parameter of that level, return nonzero. */
5206 template_parm_this_level_p (tree t
, void* data
)
5208 int this_level
= *(int *)data
;
5211 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
5212 level
= TEMPLATE_PARM_LEVEL (t
);
5214 level
= TEMPLATE_TYPE_LEVEL (t
);
5215 return level
== this_level
;
5218 /* Worker for uses_outer_template_parms, called via for_each_template_parm.
5219 DATA is really an int, indicating the innermost outer level of parameters.
5220 If T is a template parameter of that level or further out, return
5224 template_parm_outer_level (tree t
, void *data
)
5226 int this_level
= *(int *)data
;
5229 if (TREE_CODE (t
) == TEMPLATE_PARM_INDEX
)
5230 level
= TEMPLATE_PARM_LEVEL (t
);
5232 level
= TEMPLATE_TYPE_LEVEL (t
);
5233 return level
<= this_level
;
5236 /* Creates a TEMPLATE_DECL for the indicated DECL using the template
5237 parameters given by current_template_args, or reuses a
5238 previously existing one, if appropriate. Returns the DECL, or an
5239 equivalent one, if it is replaced via a call to duplicate_decls.
5241 If IS_FRIEND is true, DECL is a friend declaration. */
5244 push_template_decl_real (tree decl
, bool is_friend
)
5252 int new_template_p
= 0;
5253 /* True if the template is a member template, in the sense of
5255 bool member_template_p
= false;
5257 if (decl
== error_mark_node
|| !current_template_parms
)
5258 return error_mark_node
;
5260 /* See if this is a partial specialization. */
5261 is_partial
= ((DECL_IMPLICIT_TYPEDEF_P (decl
)
5262 && TREE_CODE (TREE_TYPE (decl
)) != ENUMERAL_TYPE
5263 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
5265 && DECL_LANG_SPECIFIC (decl
)
5266 && DECL_TEMPLATE_SPECIALIZATION (decl
)
5267 && TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (decl
))));
5269 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_FRIEND_P (decl
))
5273 /* For a friend, we want the context of the friend function, not
5274 the type of which it is a friend. */
5275 ctx
= CP_DECL_CONTEXT (decl
);
5276 else if (CP_DECL_CONTEXT (decl
)
5277 && TREE_CODE (CP_DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
5278 /* In the case of a virtual function, we want the class in which
5280 ctx
= CP_DECL_CONTEXT (decl
);
5282 /* Otherwise, if we're currently defining some class, the DECL
5283 is assumed to be a member of the class. */
5284 ctx
= current_scope ();
5286 if (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
5289 if (!DECL_CONTEXT (decl
))
5290 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
5292 /* See if this is a primary template. */
5293 if (is_friend
&& ctx
5294 && uses_template_parms_level (ctx
, processing_template_decl
))
5295 /* A friend template that specifies a class context, i.e.
5296 template <typename T> friend void A<T>::f();
5299 else if (TREE_CODE (decl
) == TYPE_DECL
5300 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5303 is_primary
= template_parm_scope_p ();
5307 warning (OPT_Wtemplates
, "template %qD declared", decl
);
5309 if (DECL_CLASS_SCOPE_P (decl
))
5310 member_template_p
= true;
5311 if (TREE_CODE (decl
) == TYPE_DECL
5312 && anon_aggrname_p (DECL_NAME (decl
)))
5314 error ("template class without a name");
5315 return error_mark_node
;
5317 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
5319 if (member_template_p
)
5321 if (DECL_OVERRIDE_P (decl
) || DECL_FINAL_P (decl
))
5322 error ("member template %qD may not have virt-specifiers", decl
);
5324 if (DECL_DESTRUCTOR_P (decl
))
5328 A destructor shall not be a member template. */
5329 error ("destructor %qD declared as member template", decl
);
5330 return error_mark_node
;
5332 if (IDENTIFIER_OVL_OP_P (DECL_NAME (decl
))
5333 && (IDENTIFIER_OVL_OP_FLAGS (DECL_NAME (decl
))
5334 & OVL_OP_FLAG_ALLOC
)
5335 && (!prototype_p (TREE_TYPE (decl
))
5336 || TYPE_ARG_TYPES (TREE_TYPE (decl
)) == void_list_node
5337 || !TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
5338 || (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
5339 == void_list_node
)))
5341 /* [basic.stc.dynamic.allocation]
5343 An allocation function can be a function
5344 template. ... Template allocation functions shall
5345 have two or more parameters. */
5346 error ("invalid template declaration of %qD", decl
);
5347 return error_mark_node
;
5350 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
5351 && CLASS_TYPE_P (TREE_TYPE (decl
)))
5353 /* Class template, set TEMPLATE_TYPE_PARM_FOR_CLASS. */
5354 tree parms
= INNERMOST_TEMPLATE_PARMS (current_template_parms
);
5355 for (int i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
5357 tree t
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5358 if (TREE_CODE (t
) == TYPE_DECL
)
5360 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
5361 TEMPLATE_TYPE_PARM_FOR_CLASS (t
) = true;
5364 else if (TREE_CODE (decl
) == TYPE_DECL
5365 && TYPE_DECL_ALIAS_P (decl
))
5366 /* alias-declaration */
5367 gcc_assert (!DECL_ARTIFICIAL (decl
));
5368 else if (VAR_P (decl
))
5369 /* C++14 variable template. */;
5372 error ("template declaration of %q#D", decl
);
5373 return error_mark_node
;
5377 /* Check to see that the rules regarding the use of default
5378 arguments are not being violated. */
5379 check_default_tmpl_args (decl
, current_template_parms
,
5380 is_primary
, is_partial
, /*is_friend_decl=*/0);
5382 /* Ensure that there are no parameter packs in the type of this
5383 declaration that have not been expanded. */
5384 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5386 /* Check each of the arguments individually to see if there are
5387 any bare parameter packs. */
5388 tree type
= TREE_TYPE (decl
);
5389 tree arg
= DECL_ARGUMENTS (decl
);
5390 tree argtype
= TYPE_ARG_TYPES (type
);
5392 while (arg
&& argtype
)
5394 if (!DECL_PACK_P (arg
)
5395 && check_for_bare_parameter_packs (TREE_TYPE (arg
)))
5397 /* This is a PARM_DECL that contains unexpanded parameter
5398 packs. We have already complained about this in the
5399 check_for_bare_parameter_packs call, so just replace
5400 these types with ERROR_MARK_NODE. */
5401 TREE_TYPE (arg
) = error_mark_node
;
5402 TREE_VALUE (argtype
) = error_mark_node
;
5405 arg
= DECL_CHAIN (arg
);
5406 argtype
= TREE_CHAIN (argtype
);
5409 /* Check for bare parameter packs in the return type and the
5410 exception specifiers. */
5411 if (check_for_bare_parameter_packs (TREE_TYPE (type
)))
5412 /* Errors were already issued, set return type to int
5413 as the frontend doesn't expect error_mark_node as
5415 TREE_TYPE (type
) = integer_type_node
;
5416 if (check_for_bare_parameter_packs (TYPE_RAISES_EXCEPTIONS (type
)))
5417 TYPE_RAISES_EXCEPTIONS (type
) = NULL_TREE
;
5419 else if (check_for_bare_parameter_packs ((TREE_CODE (decl
) == TYPE_DECL
5420 && TYPE_DECL_ALIAS_P (decl
))
5421 ? DECL_ORIGINAL_TYPE (decl
)
5422 : TREE_TYPE (decl
)))
5424 TREE_TYPE (decl
) = error_mark_node
;
5425 return error_mark_node
;
5429 return process_partial_specialization (decl
);
5431 args
= current_template_args ();
5434 || TREE_CODE (ctx
) == FUNCTION_DECL
5435 || (CLASS_TYPE_P (ctx
) && TYPE_BEING_DEFINED (ctx
))
5436 || (TREE_CODE (decl
) == TYPE_DECL
5437 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
5438 || (is_friend
&& !DECL_TEMPLATE_INFO (decl
)))
5440 if (DECL_LANG_SPECIFIC (decl
)
5441 && DECL_TEMPLATE_INFO (decl
)
5442 && DECL_TI_TEMPLATE (decl
))
5443 tmpl
= DECL_TI_TEMPLATE (decl
);
5444 /* If DECL is a TYPE_DECL for a class-template, then there won't
5445 be DECL_LANG_SPECIFIC. The information equivalent to
5446 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
5447 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
5448 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
5449 && TYPE_TI_TEMPLATE (TREE_TYPE (decl
)))
5451 /* Since a template declaration already existed for this
5452 class-type, we must be redeclaring it here. Make sure
5453 that the redeclaration is valid. */
5454 redeclare_class_template (TREE_TYPE (decl
),
5455 current_template_parms
,
5456 current_template_constraints ());
5457 /* We don't need to create a new TEMPLATE_DECL; just use the
5458 one we already had. */
5459 tmpl
= TYPE_TI_TEMPLATE (TREE_TYPE (decl
));
5463 tmpl
= build_template_decl (decl
, current_template_parms
,
5467 if (DECL_LANG_SPECIFIC (decl
)
5468 && DECL_TEMPLATE_SPECIALIZATION (decl
))
5470 /* A specialization of a member template of a template
5472 SET_DECL_TEMPLATE_SPECIALIZATION (tmpl
);
5473 DECL_TEMPLATE_INFO (tmpl
) = DECL_TEMPLATE_INFO (decl
);
5474 DECL_TEMPLATE_INFO (decl
) = NULL_TREE
;
5480 tree a
, t
, current
, parms
;
5482 tree tinfo
= get_template_info (decl
);
5486 error ("template definition of non-template %q#D", decl
);
5487 return error_mark_node
;
5490 tmpl
= TI_TEMPLATE (tinfo
);
5492 if (DECL_FUNCTION_TEMPLATE_P (tmpl
)
5493 && DECL_TEMPLATE_INFO (decl
) && DECL_TI_ARGS (decl
)
5494 && DECL_TEMPLATE_SPECIALIZATION (decl
)
5495 && DECL_MEMBER_TEMPLATE_P (tmpl
))
5499 /* The declaration is a specialization of a member
5500 template, declared outside the class. Therefore, the
5501 innermost template arguments will be NULL, so we
5502 replace them with the arguments determined by the
5503 earlier call to check_explicit_specialization. */
5504 args
= DECL_TI_ARGS (decl
);
5507 = build_template_decl (decl
, current_template_parms
,
5509 DECL_TEMPLATE_RESULT (new_tmpl
) = decl
;
5510 TREE_TYPE (new_tmpl
) = TREE_TYPE (decl
);
5511 DECL_TI_TEMPLATE (decl
) = new_tmpl
;
5512 SET_DECL_TEMPLATE_SPECIALIZATION (new_tmpl
);
5513 DECL_TEMPLATE_INFO (new_tmpl
)
5514 = build_template_info (tmpl
, args
);
5516 register_specialization (new_tmpl
,
5517 most_general_template (tmpl
),
5523 /* Make sure the template headers we got make sense. */
5525 parms
= DECL_TEMPLATE_PARMS (tmpl
);
5526 i
= TMPL_PARMS_DEPTH (parms
);
5527 if (TMPL_ARGS_DEPTH (args
) != i
)
5529 error ("expected %d levels of template parms for %q#D, got %d",
5530 i
, decl
, TMPL_ARGS_DEPTH (args
));
5531 DECL_INTERFACE_KNOWN (decl
) = 1;
5532 return error_mark_node
;
5535 for (current
= decl
; i
> 0; --i
, parms
= TREE_CHAIN (parms
))
5537 a
= TMPL_ARGS_LEVEL (args
, i
);
5538 t
= INNERMOST_TEMPLATE_PARMS (parms
);
5540 if (TREE_VEC_LENGTH (t
) != TREE_VEC_LENGTH (a
))
5542 if (current
== decl
)
5543 error ("got %d template parameters for %q#D",
5544 TREE_VEC_LENGTH (a
), decl
);
5546 error ("got %d template parameters for %q#T",
5547 TREE_VEC_LENGTH (a
), current
);
5548 error (" but %d required", TREE_VEC_LENGTH (t
));
5549 /* Avoid crash in import_export_decl. */
5550 DECL_INTERFACE_KNOWN (decl
) = 1;
5551 return error_mark_node
;
5554 if (current
== decl
)
5556 else if (current
== NULL_TREE
)
5557 /* Can happen in erroneous input. */
5560 current
= get_containing_scope (current
);
5563 /* Check that the parms are used in the appropriate qualifying scopes
5564 in the declarator. */
5565 if (!comp_template_args
5567 TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl
)))))
5569 error ("template arguments to %qD do not match original "
5570 "template %qD", decl
, DECL_TEMPLATE_RESULT (tmpl
));
5571 if (!uses_template_parms (TI_ARGS (tinfo
)))
5572 inform (input_location
, "use %<template<>%> for"
5573 " an explicit specialization");
5574 /* Avoid crash in import_export_decl. */
5575 DECL_INTERFACE_KNOWN (decl
) = 1;
5576 return error_mark_node
;
5580 DECL_TEMPLATE_RESULT (tmpl
) = decl
;
5581 TREE_TYPE (tmpl
) = TREE_TYPE (decl
);
5583 /* Push template declarations for global functions and types. Note
5584 that we do not try to push a global template friend declared in a
5585 template class; such a thing may well depend on the template
5586 parameters of the class. */
5587 if (new_template_p
&& !ctx
5588 && !(is_friend
&& template_class_depth (current_class_type
) > 0))
5590 tmpl
= pushdecl_namespace_level (tmpl
, is_friend
);
5591 if (tmpl
== error_mark_node
)
5592 return error_mark_node
;
5594 /* Hide template friend classes that haven't been declared yet. */
5595 if (is_friend
&& TREE_CODE (decl
) == TYPE_DECL
)
5597 DECL_ANTICIPATED (tmpl
) = 1;
5598 DECL_FRIEND_P (tmpl
) = 1;
5604 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
5606 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5608 /* Give template template parms a DECL_CONTEXT of the template
5609 for which they are a parameter. */
5610 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5611 for (int i
= TREE_VEC_LENGTH (parms
) - 1; i
>= 0; --i
)
5613 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5614 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5615 DECL_CONTEXT (parm
) = tmpl
;
5618 if (TREE_CODE (decl
) == TYPE_DECL
5619 && TYPE_DECL_ALIAS_P (decl
)
5620 && complex_alias_template_p (tmpl
))
5621 TEMPLATE_DECL_COMPLEX_ALIAS_P (tmpl
) = true;
5624 /* The DECL_TI_ARGS of DECL contains full set of arguments referring
5625 back to its most general template. If TMPL is a specialization,
5626 ARGS may only have the innermost set of arguments. Add the missing
5627 argument levels if necessary. */
5628 if (DECL_TEMPLATE_INFO (tmpl
))
5629 args
= add_outermost_template_args (DECL_TI_ARGS (tmpl
), args
);
5631 info
= build_template_info (tmpl
, args
);
5633 if (DECL_IMPLICIT_TYPEDEF_P (decl
))
5634 SET_TYPE_TEMPLATE_INFO (TREE_TYPE (tmpl
), info
);
5638 retrofit_lang_decl (decl
);
5639 if (DECL_LANG_SPECIFIC (decl
))
5640 DECL_TEMPLATE_INFO (decl
) = info
;
5643 if (flag_implicit_templates
5645 && TREE_PUBLIC (decl
)
5646 && VAR_OR_FUNCTION_DECL_P (decl
))
5647 /* Set DECL_COMDAT on template instantiations; if we force
5648 them to be emitted by explicit instantiation or -frepo,
5649 mark_needed will tell cgraph to do the right thing. */
5650 DECL_COMDAT (decl
) = true;
5652 return DECL_TEMPLATE_RESULT (tmpl
);
5656 push_template_decl (tree decl
)
5658 return push_template_decl_real (decl
, false);
5661 /* FN is an inheriting constructor that inherits from the constructor
5662 template INHERITED; turn FN into a constructor template with a matching
5666 add_inherited_template_parms (tree fn
, tree inherited
)
5669 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited
));
5670 inner_parms
= copy_node (inner_parms
);
5672 = tree_cons (size_int (processing_template_decl
+ 1),
5673 inner_parms
, current_template_parms
);
5674 tree tmpl
= build_template_decl (fn
, parms
, /*member*/true);
5675 tree args
= template_parms_to_args (parms
);
5676 DECL_TEMPLATE_INFO (fn
) = build_template_info (tmpl
, args
);
5677 TREE_TYPE (tmpl
) = TREE_TYPE (fn
);
5678 DECL_TEMPLATE_RESULT (tmpl
) = fn
;
5679 DECL_ARTIFICIAL (tmpl
) = true;
5680 DECL_PRIMARY_TEMPLATE (tmpl
) = tmpl
;
5684 /* Called when a class template TYPE is redeclared with the indicated
5685 template PARMS, e.g.:
5687 template <class T> struct S;
5688 template <class T> struct S {}; */
5691 redeclare_class_template (tree type
, tree parms
, tree cons
)
5697 if (!TYPE_TEMPLATE_INFO (type
))
5699 error ("%qT is not a template type", type
);
5703 tmpl
= TYPE_TI_TEMPLATE (type
);
5704 if (!PRIMARY_TEMPLATE_P (tmpl
))
5705 /* The type is nested in some template class. Nothing to worry
5706 about here; there are no new template parameters for the nested
5712 error ("template specifiers not specified in declaration of %qD",
5717 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
5718 tmpl_parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
5720 if (TREE_VEC_LENGTH (parms
) != TREE_VEC_LENGTH (tmpl_parms
))
5722 error_n (input_location
, TREE_VEC_LENGTH (parms
),
5723 "redeclared with %d template parameter",
5724 "redeclared with %d template parameters",
5725 TREE_VEC_LENGTH (parms
));
5726 inform_n (DECL_SOURCE_LOCATION (tmpl
), TREE_VEC_LENGTH (tmpl_parms
),
5727 "previous declaration %qD used %d template parameter",
5728 "previous declaration %qD used %d template parameters",
5729 tmpl
, TREE_VEC_LENGTH (tmpl_parms
));
5733 for (i
= 0; i
< TREE_VEC_LENGTH (tmpl_parms
); ++i
)
5740 if (TREE_VEC_ELT (tmpl_parms
, i
) == error_mark_node
5741 || TREE_VEC_ELT (parms
, i
) == error_mark_node
)
5744 tmpl_parm
= TREE_VALUE (TREE_VEC_ELT (tmpl_parms
, i
));
5745 if (error_operand_p (tmpl_parm
))
5748 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
5749 tmpl_default
= TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
));
5750 parm_default
= TREE_PURPOSE (TREE_VEC_ELT (parms
, i
));
5752 /* TMPL_PARM and PARM can be either TYPE_DECL, PARM_DECL, or
5754 if (TREE_CODE (tmpl_parm
) != TREE_CODE (parm
)
5755 || (TREE_CODE (tmpl_parm
) != TYPE_DECL
5756 && !same_type_p (TREE_TYPE (tmpl_parm
), TREE_TYPE (parm
)))
5757 || (TREE_CODE (tmpl_parm
) != PARM_DECL
5758 && (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (tmpl_parm
))
5759 != TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
))))
5760 || (TREE_CODE (tmpl_parm
) == PARM_DECL
5761 && (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (tmpl_parm
))
5762 != TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))))
5764 error ("template parameter %q+#D", tmpl_parm
);
5765 error ("redeclared here as %q#D", parm
);
5769 if (tmpl_default
!= NULL_TREE
&& parm_default
!= NULL_TREE
)
5771 /* We have in [temp.param]:
5773 A template-parameter may not be given default arguments
5774 by two different declarations in the same scope. */
5775 error_at (input_location
, "redefinition of default argument for %q#D", parm
);
5776 inform (DECL_SOURCE_LOCATION (tmpl_parm
),
5777 "original definition appeared here");
5781 if (parm_default
!= NULL_TREE
)
5782 /* Update the previous template parameters (which are the ones
5783 that will really count) with the new default value. */
5784 TREE_PURPOSE (TREE_VEC_ELT (tmpl_parms
, i
)) = parm_default
;
5785 else if (tmpl_default
!= NULL_TREE
)
5786 /* Update the new parameters, too; they'll be used as the
5787 parameters for any members. */
5788 TREE_PURPOSE (TREE_VEC_ELT (parms
, i
)) = tmpl_default
;
5790 /* Give each template template parm in this redeclaration a
5791 DECL_CONTEXT of the template for which they are a parameter. */
5792 if (TREE_CODE (parm
) == TEMPLATE_DECL
)
5794 gcc_assert (DECL_CONTEXT (parm
) == NULL_TREE
);
5795 DECL_CONTEXT (parm
) = tmpl
;
5798 if (TREE_CODE (parm
) == TYPE_DECL
)
5799 TEMPLATE_TYPE_PARM_FOR_CLASS (TREE_TYPE (parm
)) = true;
5802 // Cannot redeclare a class template with a different set of constraints.
5803 if (!equivalent_constraints (get_constraints (tmpl
), cons
))
5805 error_at (input_location
, "redeclaration %q#D with different "
5806 "constraints", tmpl
);
5807 inform (DECL_SOURCE_LOCATION (tmpl
),
5808 "original declaration appeared here");
5814 /* The actual substitution part of instantiate_non_dependent_expr_sfinae,
5815 to be used when the caller has already checked
5816 (processing_template_decl
5817 && !instantiation_dependent_expression_p (expr)
5818 && potential_constant_expression (expr))
5819 and cleared processing_template_decl. */
5822 instantiate_non_dependent_expr_internal (tree expr
, tsubst_flags_t complain
)
5824 return tsubst_copy_and_build (expr
,
5827 /*in_decl=*/NULL_TREE
,
5828 /*function_p=*/false,
5829 /*integral_constant_expression_p=*/true);
5832 /* Simplify EXPR if it is a non-dependent expression. Returns the
5833 (possibly simplified) expression. */
5836 instantiate_non_dependent_expr_sfinae (tree expr
, tsubst_flags_t complain
)
5838 if (expr
== NULL_TREE
)
5841 /* If we're in a template, but EXPR isn't value dependent, simplify
5842 it. We're supposed to treat:
5844 template <typename T> void f(T[1 + 1]);
5845 template <typename T> void f(T[2]);
5847 as two declarations of the same function, for example. */
5848 if (processing_template_decl
5849 && is_nondependent_constant_expression (expr
))
5851 processing_template_decl_sentinel s
;
5852 expr
= instantiate_non_dependent_expr_internal (expr
, complain
);
5858 instantiate_non_dependent_expr (tree expr
)
5860 return instantiate_non_dependent_expr_sfinae (expr
, tf_error
);
5863 /* Like instantiate_non_dependent_expr, but return NULL_TREE rather than
5864 an uninstantiated expression. */
5867 instantiate_non_dependent_or_null (tree expr
)
5869 if (expr
== NULL_TREE
)
5871 if (processing_template_decl
)
5873 if (!is_nondependent_constant_expression (expr
))
5877 processing_template_decl_sentinel s
;
5878 expr
= instantiate_non_dependent_expr_internal (expr
, tf_error
);
5884 /* True iff T is a specialization of a variable template. */
5887 variable_template_specialization_p (tree t
)
5889 if (!VAR_P (t
) || !DECL_LANG_SPECIFIC (t
) || !DECL_TEMPLATE_INFO (t
))
5891 tree tmpl
= DECL_TI_TEMPLATE (t
);
5892 return variable_template_p (tmpl
);
5895 /* Return TRUE iff T is a type alias, a TEMPLATE_DECL for an alias
5896 template declaration, or a TYPE_DECL for an alias declaration. */
5899 alias_type_or_template_p (tree t
)
5903 return ((TREE_CODE (t
) == TYPE_DECL
&& TYPE_DECL_ALIAS_P (t
))
5906 && TYPE_DECL_ALIAS_P (TYPE_NAME (t
)))
5907 || DECL_ALIAS_TEMPLATE_P (t
));
5910 /* Return TRUE iff T is a specialization of an alias template. */
5913 alias_template_specialization_p (const_tree t
)
5915 /* It's an alias template specialization if it's an alias and its
5916 TYPE_NAME is a specialization of a primary template. */
5917 if (TYPE_ALIAS_P (t
))
5918 if (tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (t
))
5919 return PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo
));
5924 /* An alias template is complex from a SFINAE perspective if a template-id
5925 using that alias can be ill-formed when the expansion is not, as with
5926 the void_t template. We determine this by checking whether the
5927 expansion for the alias template uses all its template parameters. */
5929 struct uses_all_template_parms_data
5936 uses_all_template_parms_r (tree t
, void *data_
)
5938 struct uses_all_template_parms_data
&data
5939 = *(struct uses_all_template_parms_data
*)data_
;
5940 tree idx
= get_template_parm_index (t
);
5942 if (TEMPLATE_PARM_LEVEL (idx
) == data
.level
)
5943 data
.seen
[TEMPLATE_PARM_IDX (idx
)] = true;
5948 complex_alias_template_p (const_tree tmpl
)
5950 struct uses_all_template_parms_data data
;
5951 tree pat
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
5952 tree parms
= DECL_TEMPLATE_PARMS (tmpl
);
5953 data
.level
= TMPL_PARMS_DEPTH (parms
);
5954 int len
= TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS (parms
));
5955 data
.seen
= XALLOCAVEC (bool, len
);
5956 for (int i
= 0; i
< len
; ++i
)
5957 data
.seen
[i
] = false;
5959 for_each_template_parm (pat
, uses_all_template_parms_r
, &data
, NULL
, true);
5960 for (int i
= 0; i
< len
; ++i
)
5966 /* Return TRUE iff T is a specialization of a complex alias template with
5967 dependent template-arguments. */
5970 dependent_alias_template_spec_p (const_tree t
)
5972 if (!alias_template_specialization_p (t
))
5975 tree tinfo
= TYPE_ALIAS_TEMPLATE_INFO (t
);
5976 if (!TEMPLATE_DECL_COMPLEX_ALIAS_P (TI_TEMPLATE (tinfo
)))
5979 tree args
= INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
));
5980 if (!any_dependent_template_arguments_p (args
))
5986 /* Return the number of innermost template parameters in TMPL. */
5989 num_innermost_template_parms (tree tmpl
)
5991 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
5992 return TREE_VEC_LENGTH (parms
);
5995 /* Return either TMPL or another template that it is equivalent to under DR
5996 1286: An alias that just changes the name of a template is equivalent to
5997 the other template. */
6000 get_underlying_template (tree tmpl
)
6002 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
6003 while (DECL_ALIAS_TEMPLATE_P (tmpl
))
6005 /* Determine if the alias is equivalent to an underlying template. */
6006 tree orig_type
= DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl
));
6007 tree tinfo
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (orig_type
);
6011 tree underlying
= TI_TEMPLATE (tinfo
);
6012 if (!PRIMARY_TEMPLATE_P (underlying
)
6013 || (num_innermost_template_parms (tmpl
)
6014 != num_innermost_template_parms (underlying
)))
6017 tree alias_args
= INNERMOST_TEMPLATE_ARGS
6018 (template_parms_to_args (DECL_TEMPLATE_PARMS (tmpl
)));
6019 if (!comp_template_args (TI_ARGS (tinfo
), alias_args
))
6022 /* Alias is equivalent. Strip it and repeat. */
6029 /* Subroutine of convert_nontype_argument. Converts EXPR to TYPE, which
6030 must be a reference-to-function or a pointer-to-function type, as specified
6031 in [temp.arg.nontype]: disambiguate EXPR if it is an overload set,
6032 and check that the resulting function has external linkage. */
6035 convert_nontype_argument_function (tree type
, tree expr
,
6036 tsubst_flags_t complain
)
6040 linkage_kind linkage
;
6042 fn
= instantiate_type (type
, fns
, tf_none
);
6043 if (fn
== error_mark_node
)
6044 return error_mark_node
;
6046 if (value_dependent_expression_p (fn
))
6049 fn_no_ptr
= strip_fnptr_conv (fn
);
6050 if (TREE_CODE (fn_no_ptr
) == ADDR_EXPR
)
6051 fn_no_ptr
= TREE_OPERAND (fn_no_ptr
, 0);
6052 if (BASELINK_P (fn_no_ptr
))
6053 fn_no_ptr
= BASELINK_FUNCTIONS (fn_no_ptr
);
6055 /* [temp.arg.nontype]/1
6057 A template-argument for a non-type, non-template template-parameter
6060 -- the address of an object or function with external [C++11: or
6061 internal] linkage. */
6063 if (TREE_CODE (fn_no_ptr
) != FUNCTION_DECL
)
6065 if (complain
& tf_error
)
6067 error ("%qE is not a valid template argument for type %qT",
6069 if (TYPE_PTR_P (type
))
6070 inform (input_location
, "it must be the address of a function "
6071 "with external linkage");
6073 inform (input_location
, "it must be the name of a function with "
6074 "external linkage");
6079 linkage
= decl_linkage (fn_no_ptr
);
6080 if (cxx_dialect
>= cxx11
? linkage
== lk_none
: linkage
!= lk_external
)
6082 if (complain
& tf_error
)
6084 if (cxx_dialect
>= cxx11
)
6085 error ("%qE is not a valid template argument for type %qT "
6086 "because %qD has no linkage",
6087 expr
, type
, fn_no_ptr
);
6089 error ("%qE is not a valid template argument for type %qT "
6090 "because %qD does not have external linkage",
6091 expr
, type
, fn_no_ptr
);
6097 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6098 fn
= build_address (fn
);
6099 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (fn
)))
6100 fn
= build_nop (type
, fn
);
6105 /* Subroutine of convert_nontype_argument.
6106 Check if EXPR of type TYPE is a valid pointer-to-member constant.
6107 Emit an error otherwise. */
6110 check_valid_ptrmem_cst_expr (tree type
, tree expr
,
6111 tsubst_flags_t complain
)
6113 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
6114 tree orig_expr
= expr
;
6116 if (null_ptr_cst_p (expr
))
6118 if (TREE_CODE (expr
) == PTRMEM_CST
6119 && same_type_p (TYPE_PTRMEM_CLASS_TYPE (type
),
6120 PTRMEM_CST_CLASS (expr
)))
6122 if (cxx_dialect
>= cxx11
&& null_member_pointer_value_p (expr
))
6124 if (processing_template_decl
6125 && TREE_CODE (expr
) == ADDR_EXPR
6126 && TREE_CODE (TREE_OPERAND (expr
, 0)) == OFFSET_REF
)
6128 if (complain
& tf_error
)
6130 error_at (loc
, "%qE is not a valid template argument for type %qT",
6132 if (TREE_CODE (expr
) != PTRMEM_CST
)
6133 inform (loc
, "it must be a pointer-to-member of the form %<&X::Y%>");
6135 inform (loc
, "because it is a member of %qT", PTRMEM_CST_CLASS (expr
));
6140 /* Returns TRUE iff the address of OP is value-dependent.
6142 14.6.2.4 [temp.dep.temp]:
6143 A non-integral non-type template-argument is dependent if its type is
6144 dependent or it has either of the following forms
6147 and contains a nested-name-specifier which specifies a class-name that
6148 names a dependent type.
6150 We generalize this to just say that the address of a member of a
6151 dependent class is value-dependent; the above doesn't cover the
6152 address of a static data member named with an unqualified-id. */
6155 has_value_dependent_address (tree op
)
6157 /* We could use get_inner_reference here, but there's no need;
6158 this is only relevant for template non-type arguments, which
6159 can only be expressed as &id-expression. */
6162 tree ctx
= CP_DECL_CONTEXT (op
);
6163 if (TYPE_P (ctx
) && dependent_type_p (ctx
))
6170 /* The next set of functions are used for providing helpful explanatory
6171 diagnostics for failed overload resolution. Their messages should be
6172 indented by two spaces for consistency with the messages in
6176 unify_success (bool /*explain_p*/)
6181 /* Other failure functions should call this one, to provide a single function
6182 for setting a breakpoint on. */
6185 unify_invalid (bool /*explain_p*/)
6191 unify_parameter_deduction_failure (bool explain_p
, tree parm
)
6194 inform (input_location
,
6195 " couldn't deduce template parameter %qD", parm
);
6196 return unify_invalid (explain_p
);
6200 unify_cv_qual_mismatch (bool explain_p
, tree parm
, tree arg
)
6203 inform (input_location
,
6204 " types %qT and %qT have incompatible cv-qualifiers",
6206 return unify_invalid (explain_p
);
6210 unify_type_mismatch (bool explain_p
, tree parm
, tree arg
)
6213 inform (input_location
, " mismatched types %qT and %qT", parm
, arg
);
6214 return unify_invalid (explain_p
);
6218 unify_parameter_pack_mismatch (bool explain_p
, tree parm
, tree arg
)
6221 inform (input_location
,
6222 " template parameter %qD is not a parameter pack, but "
6225 return unify_invalid (explain_p
);
6229 unify_ptrmem_cst_mismatch (bool explain_p
, tree parm
, tree arg
)
6232 inform (input_location
,
6233 " template argument %qE does not match "
6234 "pointer-to-member constant %qE",
6236 return unify_invalid (explain_p
);
6240 unify_expression_unequal (bool explain_p
, tree parm
, tree arg
)
6243 inform (input_location
, " %qE is not equivalent to %qE", parm
, arg
);
6244 return unify_invalid (explain_p
);
6248 unify_parameter_pack_inconsistent (bool explain_p
, tree old_arg
, tree new_arg
)
6251 inform (input_location
,
6252 " inconsistent parameter pack deduction with %qT and %qT",
6254 return unify_invalid (explain_p
);
6258 unify_inconsistency (bool explain_p
, tree parm
, tree first
, tree second
)
6263 inform (input_location
,
6264 " deduced conflicting types for parameter %qT (%qT and %qT)",
6265 parm
, first
, second
);
6267 inform (input_location
,
6268 " deduced conflicting values for non-type parameter "
6269 "%qE (%qE and %qE)", parm
, first
, second
);
6271 return unify_invalid (explain_p
);
6275 unify_vla_arg (bool explain_p
, tree arg
)
6278 inform (input_location
,
6279 " variable-sized array type %qT is not "
6280 "a valid template argument",
6282 return unify_invalid (explain_p
);
6286 unify_method_type_error (bool explain_p
, tree arg
)
6289 inform (input_location
,
6290 " member function type %qT is not a valid template argument",
6292 return unify_invalid (explain_p
);
6296 unify_arity (bool explain_p
, int have
, int wanted
, bool least_p
= false)
6301 inform_n (input_location
, wanted
,
6302 " candidate expects at least %d argument, %d provided",
6303 " candidate expects at least %d arguments, %d provided",
6306 inform_n (input_location
, wanted
,
6307 " candidate expects %d argument, %d provided",
6308 " candidate expects %d arguments, %d provided",
6311 return unify_invalid (explain_p
);
6315 unify_too_many_arguments (bool explain_p
, int have
, int wanted
)
6317 return unify_arity (explain_p
, have
, wanted
);
6321 unify_too_few_arguments (bool explain_p
, int have
, int wanted
,
6322 bool least_p
= false)
6324 return unify_arity (explain_p
, have
, wanted
, least_p
);
6328 unify_arg_conversion (bool explain_p
, tree to_type
,
6329 tree from_type
, tree arg
)
6332 inform (EXPR_LOC_OR_LOC (arg
, input_location
),
6333 " cannot convert %qE (type %qT) to type %qT",
6334 arg
, from_type
, to_type
);
6335 return unify_invalid (explain_p
);
6339 unify_no_common_base (bool explain_p
, enum template_base_result r
,
6340 tree parm
, tree arg
)
6345 case tbr_ambiguous_baseclass
:
6346 inform (input_location
, " %qT is an ambiguous base class of %qT",
6350 inform (input_location
, " %qT is not derived from %qT", arg
, parm
);
6353 return unify_invalid (explain_p
);
6357 unify_inconsistent_template_template_parameters (bool explain_p
)
6360 inform (input_location
,
6361 " template parameters of a template template argument are "
6362 "inconsistent with other deduced template arguments");
6363 return unify_invalid (explain_p
);
6367 unify_template_deduction_failure (bool explain_p
, tree parm
, tree arg
)
6370 inform (input_location
,
6371 " can't deduce a template for %qT from non-template type %qT",
6373 return unify_invalid (explain_p
);
6377 unify_template_argument_mismatch (bool explain_p
, tree parm
, tree arg
)
6380 inform (input_location
,
6381 " template argument %qE does not match %qE", arg
, parm
);
6382 return unify_invalid (explain_p
);
6385 /* Attempt to convert the non-type template parameter EXPR to the
6386 indicated TYPE. If the conversion is successful, return the
6387 converted value. If the conversion is unsuccessful, return
6388 NULL_TREE if we issued an error message, or error_mark_node if we
6389 did not. We issue error messages for out-and-out bad template
6390 parameters, but not simply because the conversion failed, since we
6391 might be just trying to do argument deduction. Both TYPE and EXPR
6392 must be non-dependent.
6394 The conversion follows the special rules described in
6395 [temp.arg.nontype], and it is much more strict than an implicit
6398 This function is called twice for each template argument (see
6399 lookup_template_class for a more accurate description of this
6400 problem). This means that we need to handle expressions which
6401 are not valid in a C++ source, but can be created from the
6402 first call (for instance, casts to perform conversions). These
6403 hacks can go away after we fix the double coercion problem. */
6406 convert_nontype_argument (tree type
, tree expr
, tsubst_flags_t complain
)
6409 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
6410 tree orig_expr
= expr
;
6412 /* Detect immediately string literals as invalid non-type argument.
6413 This special-case is not needed for correctness (we would easily
6414 catch this later), but only to provide better diagnostic for this
6415 common user mistake. As suggested by DR 100, we do not mention
6416 linkage issues in the diagnostic as this is not the point. */
6417 /* FIXME we're making this OK. */
6418 if (TREE_CODE (expr
) == STRING_CST
)
6420 if (complain
& tf_error
)
6421 error ("%qE is not a valid template argument for type %qT "
6422 "because string literals can never be used in this context",
6427 /* Add the ADDR_EXPR now for the benefit of
6428 value_dependent_expression_p. */
6429 if (TYPE_PTROBV_P (type
)
6430 && TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
)
6432 expr
= decay_conversion (expr
, complain
);
6433 if (expr
== error_mark_node
)
6434 return error_mark_node
;
6437 /* If we are in a template, EXPR may be non-dependent, but still
6438 have a syntactic, rather than semantic, form. For example, EXPR
6439 might be a SCOPE_REF, rather than the VAR_DECL to which the
6440 SCOPE_REF refers. Preserving the qualifying scope is necessary
6441 so that access checking can be performed when the template is
6442 instantiated -- but here we need the resolved form so that we can
6443 convert the argument. */
6444 bool non_dep
= false;
6445 if (TYPE_REF_OBJ_P (type
)
6446 && has_value_dependent_address (expr
))
6447 /* If we want the address and it's value-dependent, don't fold. */;
6448 else if (processing_template_decl
6449 && is_nondependent_constant_expression (expr
))
6451 if (error_operand_p (expr
))
6452 return error_mark_node
;
6453 expr_type
= TREE_TYPE (expr
);
6455 /* If the argument is non-dependent, perform any conversions in
6456 non-dependent context as well. */
6457 processing_template_decl_sentinel
s (non_dep
);
6459 expr
= instantiate_non_dependent_expr_internal (expr
, complain
);
6461 if (value_dependent_expression_p (expr
))
6462 expr
= canonicalize_expr_argument (expr
, complain
);
6464 /* 14.3.2/5: The null pointer{,-to-member} conversion is applied
6465 to a non-type argument of "nullptr". */
6466 if (NULLPTR_TYPE_P (expr_type
) && TYPE_PTR_OR_PTRMEM_P (type
))
6467 expr
= fold_simple (convert (type
, expr
));
6469 /* In C++11, integral or enumeration non-type template arguments can be
6470 arbitrary constant expressions. Pointer and pointer to
6471 member arguments can be general constant expressions that evaluate
6472 to a null value, but otherwise still need to be of a specific form. */
6473 if (cxx_dialect
>= cxx11
)
6475 if (TREE_CODE (expr
) == PTRMEM_CST
)
6476 /* A PTRMEM_CST is already constant, and a valid template
6477 argument for a parameter of pointer to member type, we just want
6478 to leave it in that form rather than lower it to a
6480 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
6481 || cxx_dialect
>= cxx17
)
6483 /* C++17: A template-argument for a non-type template-parameter shall
6484 be a converted constant expression (8.20) of the type of the
6485 template-parameter. */
6486 expr
= build_converted_constant_expr (type
, expr
, complain
);
6487 if (expr
== error_mark_node
)
6488 return error_mark_node
;
6489 expr
= maybe_constant_value (expr
);
6490 expr
= convert_from_reference (expr
);
6492 else if (TYPE_PTR_OR_PTRMEM_P (type
))
6494 tree folded
= maybe_constant_value (expr
);
6495 if (TYPE_PTR_P (type
) ? integer_zerop (folded
)
6496 : null_member_pointer_value_p (folded
))
6501 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6502 expr
= mark_lvalue_use (expr
);
6504 expr
= mark_rvalue_use (expr
);
6506 /* HACK: Due to double coercion, we can get a
6507 NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
6508 which is the tree that we built on the first call (see
6509 below when coercing to reference to object or to reference to
6510 function). We just strip everything and get to the arg.
6511 See g++.old-deja/g++.oliva/template4.C and g++.dg/template/nontype9.C
6513 if (TYPE_REF_OBJ_P (type
) || TYPE_REFFN_P (type
))
6515 tree probe_type
, probe
= expr
;
6516 if (REFERENCE_REF_P (probe
))
6517 probe
= TREE_OPERAND (probe
, 0);
6518 probe_type
= TREE_TYPE (probe
);
6519 if (TREE_CODE (probe
) == NOP_EXPR
)
6521 /* ??? Maybe we could use convert_from_reference here, but we
6522 would need to relax its constraints because the NOP_EXPR
6523 could actually change the type to something more cv-qualified,
6524 and this is not folded by convert_from_reference. */
6525 tree addr
= TREE_OPERAND (probe
, 0);
6526 if (TREE_CODE (probe_type
) == REFERENCE_TYPE
6527 && TREE_CODE (addr
) == ADDR_EXPR
6528 && TYPE_PTR_P (TREE_TYPE (addr
))
6529 && (same_type_ignoring_top_level_qualifiers_p
6530 (TREE_TYPE (probe_type
),
6531 TREE_TYPE (TREE_TYPE (addr
)))))
6533 expr
= TREE_OPERAND (addr
, 0);
6534 expr_type
= TREE_TYPE (probe_type
);
6539 /* [temp.arg.nontype]/5, bullet 1
6541 For a non-type template-parameter of integral or enumeration type,
6542 integral promotions (_conv.prom_) and integral conversions
6543 (_conv.integral_) are applied. */
6544 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
6546 if (cxx_dialect
< cxx11
)
6548 tree t
= build_converted_constant_expr (type
, expr
, complain
);
6549 t
= maybe_constant_value (t
);
6550 if (t
!= error_mark_node
)
6554 if (!same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (expr
)))
6555 return error_mark_node
;
6557 /* Notice that there are constant expressions like '4 % 0' which
6558 do not fold into integer constants. */
6559 if (TREE_CODE (expr
) != INTEGER_CST
6560 && !value_dependent_expression_p (expr
))
6562 if (complain
& tf_error
)
6564 int errs
= errorcount
, warns
= warningcount
+ werrorcount
;
6565 if (!require_potential_constant_expression (expr
))
6566 expr
= error_mark_node
;
6568 expr
= cxx_constant_value (expr
);
6569 if (errorcount
> errs
|| warningcount
+ werrorcount
> warns
)
6570 inform (loc
, "in template argument for type %qT ", type
);
6571 if (expr
== error_mark_node
)
6573 /* else cxx_constant_value complained but gave us
6574 a real constant, so go ahead. */
6575 gcc_assert (TREE_CODE (expr
) == INTEGER_CST
);
6581 /* Avoid typedef problems. */
6582 if (TREE_TYPE (expr
) != type
)
6583 expr
= fold_convert (type
, expr
);
6585 /* [temp.arg.nontype]/5, bullet 2
6587 For a non-type template-parameter of type pointer to object,
6588 qualification conversions (_conv.qual_) and the array-to-pointer
6589 conversion (_conv.array_) are applied. */
6590 else if (TYPE_PTROBV_P (type
))
6592 tree decayed
= expr
;
6594 /* Look through any NOP_EXPRs around an ADDR_EXPR, whether they come from
6595 decay_conversion or an explicit cast. If it's a problematic cast,
6596 we'll complain about it below. */
6597 if (TREE_CODE (expr
) == NOP_EXPR
)
6601 if (TREE_CODE (probe
) == ADDR_EXPR
6602 && TYPE_PTR_P (TREE_TYPE (probe
)))
6605 expr_type
= TREE_TYPE (expr
);
6609 /* [temp.arg.nontype]/1 (TC1 version, DR 49):
6611 A template-argument for a non-type, non-template template-parameter
6612 shall be one of: [...]
6614 -- the name of a non-type template-parameter;
6615 -- the address of an object or function with external linkage, [...]
6616 expressed as "& id-expression" where the & is optional if the name
6617 refers to a function or array, or if the corresponding
6618 template-parameter is a reference.
6620 Here, we do not care about functions, as they are invalid anyway
6621 for a parameter of type pointer-to-object. */
6623 if (value_dependent_expression_p (expr
))
6624 /* Non-type template parameters are OK. */
6626 else if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
6627 /* Null pointer values are OK in C++11. */;
6628 else if (TREE_CODE (expr
) != ADDR_EXPR
)
6632 if (complain
& tf_error
)
6633 error ("%qD is not a valid template argument "
6634 "because %qD is a variable, not the address of "
6635 "a variable", orig_expr
, expr
);
6638 if (POINTER_TYPE_P (expr_type
))
6640 if (complain
& tf_error
)
6641 error ("%qE is not a valid template argument for %qT "
6642 "because it is not the address of a variable",
6646 /* Other values, like integer constants, might be valid
6647 non-type arguments of some other type. */
6648 return error_mark_node
;
6652 tree decl
= TREE_OPERAND (expr
, 0);
6656 if (complain
& tf_error
)
6657 error ("%qE is not a valid template argument of type %qT "
6658 "because %qE is not a variable", orig_expr
, type
, decl
);
6661 else if (cxx_dialect
< cxx11
&& !DECL_EXTERNAL_LINKAGE_P (decl
))
6663 if (complain
& tf_error
)
6664 error ("%qE is not a valid template argument of type %qT "
6665 "because %qD does not have external linkage",
6666 orig_expr
, type
, decl
);
6669 else if ((cxx_dialect
>= cxx11
&& cxx_dialect
< cxx17
)
6670 && decl_linkage (decl
) == lk_none
)
6672 if (complain
& tf_error
)
6673 error ("%qE is not a valid template argument of type %qT "
6674 "because %qD has no linkage", orig_expr
, type
, decl
);
6677 /* C++17: For a non-type template-parameter of reference or pointer
6678 type, the value of the constant expression shall not refer to (or
6679 for a pointer type, shall not be the address of):
6680 * a subobject (4.5),
6681 * a temporary object (15.2),
6682 * a string literal (5.13.5),
6683 * the result of a typeid expression (8.2.8), or
6684 * a predefined __func__ variable (11.4.1). */
6685 else if (DECL_ARTIFICIAL (decl
))
6687 if (complain
& tf_error
)
6688 error ("the address of %qD is not a valid template argument",
6692 else if (!same_type_ignoring_top_level_qualifiers_p
6693 (strip_array_types (TREE_TYPE (type
)),
6694 strip_array_types (TREE_TYPE (decl
))))
6696 if (complain
& tf_error
)
6697 error ("the address of the %qT subobject of %qD is not a "
6698 "valid template argument", TREE_TYPE (type
), decl
);
6701 else if (!TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
))
6703 if (complain
& tf_error
)
6704 error ("the address of %qD is not a valid template argument "
6705 "because it does not have static storage duration",
6713 expr
= perform_qualification_conversions (type
, expr
);
6714 if (expr
== error_mark_node
)
6715 return error_mark_node
;
6717 /* [temp.arg.nontype]/5, bullet 3
6719 For a non-type template-parameter of type reference to object, no
6720 conversions apply. The type referred to by the reference may be more
6721 cv-qualified than the (otherwise identical) type of the
6722 template-argument. The template-parameter is bound directly to the
6723 template-argument, which must be an lvalue. */
6724 else if (TYPE_REF_OBJ_P (type
))
6726 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type
),
6728 return error_mark_node
;
6730 if (!at_least_as_qualified_p (TREE_TYPE (type
), expr_type
))
6732 if (complain
& tf_error
)
6733 error ("%qE is not a valid template argument for type %qT "
6734 "because of conflicts in cv-qualification", expr
, type
);
6738 if (!lvalue_p (expr
))
6740 if (complain
& tf_error
)
6741 error ("%qE is not a valid template argument for type %qT "
6742 "because it is not an lvalue", expr
, type
);
6746 /* [temp.arg.nontype]/1
6748 A template-argument for a non-type, non-template template-parameter
6749 shall be one of: [...]
6751 -- the address of an object or function with external linkage. */
6752 if (INDIRECT_REF_P (expr
)
6753 && TYPE_REF_OBJ_P (TREE_TYPE (TREE_OPERAND (expr
, 0))))
6755 expr
= TREE_OPERAND (expr
, 0);
6758 if (complain
& tf_error
)
6759 error ("%q#D is not a valid template argument for type %qT "
6760 "because a reference variable does not have a constant "
6761 "address", expr
, type
);
6766 if (TYPE_REF_OBJ_P (TREE_TYPE (expr
))
6767 && value_dependent_expression_p (expr
))
6768 /* OK, dependent reference. We don't want to ask whether a DECL is
6769 itself value-dependent, since what we want here is its address. */;
6774 if (complain
& tf_error
)
6775 error ("%qE is not a valid template argument for type %qT "
6776 "because it is not an object with linkage",
6781 /* DR 1155 allows internal linkage in C++11 and up. */
6782 linkage_kind linkage
= decl_linkage (expr
);
6783 if (linkage
< (cxx_dialect
>= cxx11
? lk_internal
: lk_external
))
6785 if (complain
& tf_error
)
6786 error ("%qE is not a valid template argument for type %qT "
6787 "because object %qD does not have linkage",
6792 expr
= build_address (expr
);
6795 if (!same_type_p (type
, TREE_TYPE (expr
)))
6796 expr
= build_nop (type
, expr
);
6798 /* [temp.arg.nontype]/5, bullet 4
6800 For a non-type template-parameter of type pointer to function, only
6801 the function-to-pointer conversion (_conv.func_) is applied. If the
6802 template-argument represents a set of overloaded functions (or a
6803 pointer to such), the matching function is selected from the set
6805 else if (TYPE_PTRFN_P (type
))
6807 /* If the argument is a template-id, we might not have enough
6808 context information to decay the pointer. */
6809 if (!type_unknown_p (expr_type
))
6811 expr
= decay_conversion (expr
, complain
);
6812 if (expr
== error_mark_node
)
6813 return error_mark_node
;
6816 if (cxx_dialect
>= cxx11
&& integer_zerop (expr
))
6817 /* Null pointer values are OK in C++11. */
6818 return perform_qualification_conversions (type
, expr
);
6820 expr
= convert_nontype_argument_function (type
, expr
, complain
);
6821 if (!expr
|| expr
== error_mark_node
)
6824 /* [temp.arg.nontype]/5, bullet 5
6826 For a non-type template-parameter of type reference to function, no
6827 conversions apply. If the template-argument represents a set of
6828 overloaded functions, the matching function is selected from the set
6830 else if (TYPE_REFFN_P (type
))
6832 if (TREE_CODE (expr
) == ADDR_EXPR
)
6834 if (complain
& tf_error
)
6836 error ("%qE is not a valid template argument for type %qT "
6837 "because it is a pointer", expr
, type
);
6838 inform (input_location
, "try using %qE instead",
6839 TREE_OPERAND (expr
, 0));
6844 expr
= convert_nontype_argument_function (type
, expr
, complain
);
6845 if (!expr
|| expr
== error_mark_node
)
6848 /* [temp.arg.nontype]/5, bullet 6
6850 For a non-type template-parameter of type pointer to member function,
6851 no conversions apply. If the template-argument represents a set of
6852 overloaded member functions, the matching member function is selected
6853 from the set (_over.over_). */
6854 else if (TYPE_PTRMEMFUNC_P (type
))
6856 expr
= instantiate_type (type
, expr
, tf_none
);
6857 if (expr
== error_mark_node
)
6858 return error_mark_node
;
6860 /* [temp.arg.nontype] bullet 1 says the pointer to member
6861 expression must be a pointer-to-member constant. */
6862 if (!value_dependent_expression_p (expr
)
6863 && !check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6866 /* Repeated conversion can't deal with a conversion that turns PTRMEM_CST
6867 into a CONSTRUCTOR, so build up a new PTRMEM_CST instead. */
6868 if (fnptr_conv_p (type
, TREE_TYPE (expr
)))
6869 expr
= make_ptrmem_cst (type
, PTRMEM_CST_MEMBER (expr
));
6871 /* [temp.arg.nontype]/5, bullet 7
6873 For a non-type template-parameter of type pointer to data member,
6874 qualification conversions (_conv.qual_) are applied. */
6875 else if (TYPE_PTRDATAMEM_P (type
))
6877 /* [temp.arg.nontype] bullet 1 says the pointer to member
6878 expression must be a pointer-to-member constant. */
6879 if (!value_dependent_expression_p (expr
)
6880 && !check_valid_ptrmem_cst_expr (type
, expr
, complain
))
6883 expr
= perform_qualification_conversions (type
, expr
);
6884 if (expr
== error_mark_node
)
6887 else if (NULLPTR_TYPE_P (type
))
6889 if (!NULLPTR_TYPE_P (TREE_TYPE (expr
)))
6891 if (complain
& tf_error
)
6892 error ("%qE is not a valid template argument for type %qT "
6893 "because it is of type %qT", expr
, type
, TREE_TYPE (expr
));
6898 /* A template non-type parameter must be one of the above. */
6902 /* Sanity check: did we actually convert the argument to the
6904 gcc_assert (same_type_ignoring_top_level_qualifiers_p
6905 (type
, TREE_TYPE (expr
)));
6906 return convert_from_reference (expr
);
6909 /* Subroutine of coerce_template_template_parms, which returns 1 if
6910 PARM_PARM and ARG_PARM match using the rule for the template
6911 parameters of template template parameters. Both PARM and ARG are
6912 template parameters; the rest of the arguments are the same as for
6913 coerce_template_template_parms.
6916 coerce_template_template_parm (tree parm
,
6918 tsubst_flags_t complain
,
6922 if (arg
== NULL_TREE
|| error_operand_p (arg
)
6923 || parm
== NULL_TREE
|| error_operand_p (parm
))
6926 if (TREE_CODE (arg
) != TREE_CODE (parm
))
6929 switch (TREE_CODE (parm
))
6932 /* We encounter instantiations of templates like
6933 template <template <template <class> class> class TT>
6936 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
6937 tree argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
6939 if (!coerce_template_template_parms
6940 (parmparm
, argparm
, complain
, in_decl
, outer_args
))
6946 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (arg
))
6947 && !TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
6948 /* Argument is a parameter pack but parameter is not. */
6953 /* The tsubst call is used to handle cases such as
6955 template <int> class C {};
6956 template <class T, template <T> class TT> class D {};
6959 i.e. the parameter list of TT depends on earlier parameters. */
6960 if (!uses_template_parms (TREE_TYPE (arg
)))
6962 tree t
= tsubst (TREE_TYPE (parm
), outer_args
, complain
, in_decl
);
6963 if (!uses_template_parms (t
)
6964 && !same_type_p (t
, TREE_TYPE (arg
)))
6968 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (arg
))
6969 && !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
6970 /* Argument is a parameter pack but parameter is not. */
6982 /* Coerce template argument list ARGLIST for use with template
6983 template-parameter TEMPL. */
6986 coerce_template_args_for_ttp (tree templ
, tree arglist
,
6987 tsubst_flags_t complain
)
6989 /* Consider an example where a template template parameter declared as
6991 template <class T, class U = std::allocator<T> > class TT
6993 The template parameter level of T and U are one level larger than
6994 of TT. To proper process the default argument of U, say when an
6995 instantiation `TT<int>' is seen, we need to build the full
6996 arguments containing {int} as the innermost level. Outer levels,
6997 available when not appearing as default template argument, can be
6998 obtained from the arguments of the enclosing template.
7000 Suppose that TT is later substituted with std::vector. The above
7001 instantiation is `TT<int, std::allocator<T> >' with TT at
7002 level 1, and T at level 2, while the template arguments at level 1
7003 becomes {std::vector} and the inner level 2 is {int}. */
7005 tree outer
= DECL_CONTEXT (templ
);
7008 if (DECL_TEMPLATE_SPECIALIZATION (outer
))
7009 /* We want arguments for the partial specialization, not arguments for
7010 the primary template. */
7011 outer
= template_parms_to_args (DECL_TEMPLATE_PARMS (outer
));
7013 outer
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer
)));
7015 else if (current_template_parms
)
7017 /* This is an argument of the current template, so we haven't set
7018 DECL_CONTEXT yet. */
7019 tree relevant_template_parms
;
7021 /* Parameter levels that are greater than the level of the given
7022 template template parm are irrelevant. */
7023 relevant_template_parms
= current_template_parms
;
7024 while (TMPL_PARMS_DEPTH (relevant_template_parms
)
7025 != TEMPLATE_TYPE_LEVEL (TREE_TYPE (templ
)))
7026 relevant_template_parms
= TREE_CHAIN (relevant_template_parms
);
7028 outer
= template_parms_to_args (relevant_template_parms
);
7032 arglist
= add_to_template_args (outer
, arglist
);
7034 tree parmlist
= DECL_INNERMOST_TEMPLATE_PARMS (templ
);
7035 return coerce_template_parms (parmlist
, arglist
, templ
,
7037 /*require_all_args=*/true,
7038 /*use_default_args=*/true);
7041 /* A cache of template template parameters with match-all default
7043 static GTY((deletable
)) hash_map
<tree
,tree
> *defaulted_ttp_cache
;
7045 store_defaulted_ttp (tree v
, tree t
)
7047 if (!defaulted_ttp_cache
)
7048 defaulted_ttp_cache
= hash_map
<tree
,tree
>::create_ggc (13);
7049 defaulted_ttp_cache
->put (v
, t
);
7052 lookup_defaulted_ttp (tree v
)
7054 if (defaulted_ttp_cache
)
7055 if (tree
*p
= defaulted_ttp_cache
->get (v
))
7060 /* T is a bound template template-parameter. Copy its arguments into default
7061 arguments of the template template-parameter's template parameters. */
7064 add_defaults_to_ttp (tree otmpl
)
7066 if (tree c
= lookup_defaulted_ttp (otmpl
))
7069 tree ntmpl
= copy_node (otmpl
);
7071 tree ntype
= copy_node (TREE_TYPE (otmpl
));
7072 TYPE_STUB_DECL (ntype
) = TYPE_NAME (ntype
) = ntmpl
;
7073 TYPE_MAIN_VARIANT (ntype
) = ntype
;
7074 TYPE_POINTER_TO (ntype
) = TYPE_REFERENCE_TO (ntype
) = NULL_TREE
;
7075 TYPE_NAME (ntype
) = ntmpl
;
7076 SET_TYPE_STRUCTURAL_EQUALITY (ntype
);
7078 tree idx
= TEMPLATE_TYPE_PARM_INDEX (ntype
)
7079 = copy_node (TEMPLATE_TYPE_PARM_INDEX (ntype
));
7080 TEMPLATE_PARM_DECL (idx
) = ntmpl
;
7081 TREE_TYPE (ntmpl
) = TREE_TYPE (idx
) = ntype
;
7083 tree oparms
= DECL_TEMPLATE_PARMS (otmpl
);
7084 tree parms
= DECL_TEMPLATE_PARMS (ntmpl
) = copy_node (oparms
);
7085 TREE_CHAIN (parms
) = TREE_CHAIN (oparms
);
7086 tree vec
= TREE_VALUE (parms
) = copy_node (TREE_VALUE (parms
));
7087 for (int i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
7089 tree o
= TREE_VEC_ELT (vec
, i
);
7090 if (!template_parameter_pack_p (TREE_VALUE (o
)))
7092 tree n
= TREE_VEC_ELT (vec
, i
) = copy_node (o
);
7093 TREE_PURPOSE (n
) = any_targ_node
;
7097 store_defaulted_ttp (otmpl
, ntmpl
);
7101 /* ARG is a bound potential template template-argument, and PARGS is a list
7102 of arguments for the corresponding template template-parameter. Adjust
7103 PARGS as appropriate for application to ARG's template, and if ARG is a
7104 BOUND_TEMPLATE_TEMPLATE_PARM, possibly adjust it to add default template
7105 arguments to the template template parameter. */
7108 coerce_ttp_args_for_tta (tree
& arg
, tree pargs
, tsubst_flags_t complain
)
7110 ++processing_template_decl
;
7111 tree arg_tmpl
= TYPE_TI_TEMPLATE (arg
);
7112 if (DECL_TEMPLATE_TEMPLATE_PARM_P (arg_tmpl
))
7114 /* When comparing two template template-parameters in partial ordering,
7115 rewrite the one currently being used as an argument to have default
7116 arguments for all parameters. */
7117 arg_tmpl
= add_defaults_to_ttp (arg_tmpl
);
7118 pargs
= coerce_template_args_for_ttp (arg_tmpl
, pargs
, complain
);
7119 if (pargs
!= error_mark_node
)
7120 arg
= bind_template_template_parm (TREE_TYPE (arg_tmpl
),
7121 TYPE_TI_ARGS (arg
));
7126 = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (arg_tmpl
));
7127 pargs
= coerce_template_parms (aparms
, pargs
, arg_tmpl
, complain
,
7128 /*require_all*/true,
7129 /*use_default*/true);
7131 --processing_template_decl
;
7135 /* Subroutine of unify for the case when PARM is a
7136 BOUND_TEMPLATE_TEMPLATE_PARM. */
7139 unify_bound_ttp_args (tree tparms
, tree targs
, tree parm
, tree
& arg
,
7142 tree parmvec
= TYPE_TI_ARGS (parm
);
7143 tree argvec
= INNERMOST_TEMPLATE_ARGS (TYPE_TI_ARGS (arg
));
7145 /* The template template parm might be variadic and the argument
7146 not, so flatten both argument lists. */
7147 parmvec
= expand_template_argument_pack (parmvec
);
7148 argvec
= expand_template_argument_pack (argvec
);
7152 /* In keeping with P0522R0, adjust P's template arguments
7153 to apply to A's template; then flatten it again. */
7154 tree nparmvec
= parmvec
;
7155 nparmvec
= coerce_ttp_args_for_tta (arg
, parmvec
, tf_none
);
7156 nparmvec
= expand_template_argument_pack (nparmvec
);
7158 if (unify (tparms
, targs
, nparmvec
, argvec
,
7159 UNIFY_ALLOW_NONE
, explain_p
))
7162 /* If the P0522 adjustment eliminated a pack expansion, deduce
7165 && TREE_VEC_LENGTH (nparmvec
) < TREE_VEC_LENGTH (parmvec
)
7166 && unify_pack_expansion (tparms
, targs
, parmvec
, argvec
,
7167 DEDUCE_EXACT
, /*sub*/true, explain_p
))
7172 /* Deduce arguments T, i from TT<T> or TT<i>.
7173 We check each element of PARMVEC and ARGVEC individually
7174 rather than the whole TREE_VEC since they can have
7175 different number of elements, which is allowed under N2555. */
7177 int len
= TREE_VEC_LENGTH (parmvec
);
7179 /* Check if the parameters end in a pack, making them
7181 int parm_variadic_p
= 0;
7183 && PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, len
- 1)))
7184 parm_variadic_p
= 1;
7186 for (int i
= 0; i
< len
- parm_variadic_p
; ++i
)
7187 /* If the template argument list of P contains a pack
7188 expansion that is not the last template argument, the
7189 entire template argument list is a non-deduced
7191 if (PACK_EXPANSION_P (TREE_VEC_ELT (parmvec
, i
)))
7192 return unify_success (explain_p
);
7194 if (TREE_VEC_LENGTH (argvec
) < len
- parm_variadic_p
)
7195 return unify_too_few_arguments (explain_p
,
7196 TREE_VEC_LENGTH (argvec
), len
);
7198 for (int i
= 0; i
< len
- parm_variadic_p
; ++i
)
7199 if (unify (tparms
, targs
,
7200 TREE_VEC_ELT (parmvec
, i
),
7201 TREE_VEC_ELT (argvec
, i
),
7202 UNIFY_ALLOW_NONE
, explain_p
))
7206 && unify_pack_expansion (tparms
, targs
,
7209 /*subr=*/true, explain_p
))
7216 /* Return 1 if PARM_PARMS and ARG_PARMS matches using rule for
7217 template template parameters. Both PARM_PARMS and ARG_PARMS are
7218 vectors of TREE_LIST nodes containing TYPE_DECL, TEMPLATE_DECL
7221 Consider the example:
7222 template <class T> class A;
7223 template<template <class U> class TT> class B;
7225 For B<A>, PARM_PARMS are the parameters to TT, while ARG_PARMS are
7226 the parameters to A, and OUTER_ARGS contains A. */
7229 coerce_template_template_parms (tree parm_parms
,
7231 tsubst_flags_t complain
,
7235 int nparms
, nargs
, i
;
7239 gcc_assert (TREE_CODE (parm_parms
) == TREE_VEC
);
7240 gcc_assert (TREE_CODE (arg_parms
) == TREE_VEC
);
7242 nparms
= TREE_VEC_LENGTH (parm_parms
);
7243 nargs
= TREE_VEC_LENGTH (arg_parms
);
7247 /* P0522R0: A template template-parameter P is at least as specialized as
7248 a template template-argument A if, given the following rewrite to two
7249 function templates, the function template corresponding to P is at
7250 least as specialized as the function template corresponding to A
7251 according to the partial ordering rules for function templates
7252 ([temp.func.order]). Given an invented class template X with the
7253 template parameter list of A (including default arguments):
7255 * Each of the two function templates has the same template parameters,
7256 respectively, as P or A.
7258 * Each function template has a single function parameter whose type is
7259 a specialization of X with template arguments corresponding to the
7260 template parameters from the respective function template where, for
7261 each template parameter PP in the template parameter list of the
7262 function template, a corresponding template argument AA is formed. If
7263 PP declares a parameter pack, then AA is the pack expansion
7264 PP... ([temp.variadic]); otherwise, AA is the id-expression PP.
7266 If the rewrite produces an invalid type, then P is not at least as
7267 specialized as A. */
7269 /* So coerce P's args to apply to A's parms, and then deduce between A's
7270 args and the converted args. If that succeeds, A is at least as
7271 specialized as P, so they match.*/
7272 tree pargs
= template_parms_level_to_args (parm_parms
);
7273 ++processing_template_decl
;
7274 pargs
= coerce_template_parms (arg_parms
, pargs
, NULL_TREE
, tf_none
,
7275 /*require_all*/true, /*use_default*/true);
7276 --processing_template_decl
;
7277 if (pargs
!= error_mark_node
)
7279 tree targs
= make_tree_vec (nargs
);
7280 tree aargs
= template_parms_level_to_args (arg_parms
);
7281 if (!unify (arg_parms
, targs
, aargs
, pargs
, UNIFY_ALLOW_NONE
,
7287 /* Determine whether we have a parameter pack at the end of the
7288 template template parameter's template parameter list. */
7289 if (TREE_VEC_ELT (parm_parms
, nparms
- 1) != error_mark_node
)
7291 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, nparms
- 1));
7293 if (error_operand_p (parm
))
7296 switch (TREE_CODE (parm
))
7300 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm
)))
7305 if (TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm
)))
7315 && !(variadic_p
&& nargs
>= nparms
- 1))
7318 /* Check all of the template parameters except the parameter pack at
7319 the end (if any). */
7320 for (i
= 0; i
< nparms
- variadic_p
; ++i
)
7322 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
7323 || TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
7326 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
7327 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
7329 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
7337 /* Check each of the template parameters in the template
7338 argument against the template parameter pack at the end of
7339 the template template parameter. */
7340 if (TREE_VEC_ELT (parm_parms
, i
) == error_mark_node
)
7343 parm
= TREE_VALUE (TREE_VEC_ELT (parm_parms
, i
));
7345 for (; i
< nargs
; ++i
)
7347 if (TREE_VEC_ELT (arg_parms
, i
) == error_mark_node
)
7350 arg
= TREE_VALUE (TREE_VEC_ELT (arg_parms
, i
));
7352 if (!coerce_template_template_parm (parm
, arg
, complain
, in_decl
,
7361 /* Verifies that the deduced template arguments (in TARGS) for the
7362 template template parameters (in TPARMS) represent valid bindings,
7363 by comparing the template parameter list of each template argument
7364 to the template parameter list of its corresponding template
7365 template parameter, in accordance with DR150. This
7366 routine can only be called after all template arguments have been
7367 deduced. It will return TRUE if all of the template template
7368 parameter bindings are okay, FALSE otherwise. */
7370 template_template_parm_bindings_ok_p (tree tparms
, tree targs
)
7372 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
7375 /* We're dealing with template parms in this process. */
7376 ++processing_template_decl
;
7378 targs
= INNERMOST_TEMPLATE_ARGS (targs
);
7380 for (i
= 0; i
< ntparms
; ++i
)
7382 tree tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
7383 tree targ
= TREE_VEC_ELT (targs
, i
);
7385 if (TREE_CODE (tparm
) == TEMPLATE_DECL
&& targ
)
7387 tree packed_args
= NULL_TREE
;
7390 if (ARGUMENT_PACK_P (targ
))
7392 /* Look inside the argument pack. */
7393 packed_args
= ARGUMENT_PACK_ARGS (targ
);
7394 len
= TREE_VEC_LENGTH (packed_args
);
7397 for (idx
= 0; idx
< len
; ++idx
)
7399 tree targ_parms
= NULL_TREE
;
7402 /* Extract the next argument from the argument
7404 targ
= TREE_VEC_ELT (packed_args
, idx
);
7406 if (PACK_EXPANSION_P (targ
))
7407 /* Look at the pattern of the pack expansion. */
7408 targ
= PACK_EXPANSION_PATTERN (targ
);
7410 /* Extract the template parameters from the template
7412 if (TREE_CODE (targ
) == TEMPLATE_DECL
)
7413 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (targ
);
7414 else if (TREE_CODE (targ
) == TEMPLATE_TEMPLATE_PARM
)
7415 targ_parms
= DECL_INNERMOST_TEMPLATE_PARMS (TYPE_NAME (targ
));
7417 /* Verify that we can coerce the template template
7418 parameters from the template argument to the template
7419 parameter. This requires an exact match. */
7421 && !coerce_template_template_parms
7422 (DECL_INNERMOST_TEMPLATE_PARMS (tparm
),
7437 --processing_template_decl
;
7441 /* Since type attributes aren't mangled, we need to strip them from
7442 template type arguments. */
7445 canonicalize_type_argument (tree arg
, tsubst_flags_t complain
)
7447 if (!arg
|| arg
== error_mark_node
|| arg
== TYPE_CANONICAL (arg
))
7449 bool removed_attributes
= false;
7450 tree canon
= strip_typedefs (arg
, &removed_attributes
);
7451 if (removed_attributes
7452 && (complain
& tf_warning
))
7453 warning (OPT_Wignored_attributes
,
7454 "ignoring attributes on template argument %qT", arg
);
7458 /* And from inside dependent non-type arguments like sizeof(Type). */
7461 canonicalize_expr_argument (tree arg
, tsubst_flags_t complain
)
7463 if (!arg
|| arg
== error_mark_node
)
7465 bool removed_attributes
= false;
7466 tree canon
= strip_typedefs_expr (arg
, &removed_attributes
);
7467 if (removed_attributes
7468 && (complain
& tf_warning
))
7469 warning (OPT_Wignored_attributes
,
7470 "ignoring attributes in template argument %qE", arg
);
7474 // A template declaration can be substituted for a constrained
7475 // template template parameter only when the argument is more
7476 // constrained than the parameter.
7478 is_compatible_template_arg (tree parm
, tree arg
)
7480 tree parm_cons
= get_constraints (parm
);
7482 /* For now, allow constrained template template arguments
7483 and unconstrained template template parameters. */
7484 if (parm_cons
== NULL_TREE
)
7487 tree arg_cons
= get_constraints (arg
);
7489 // If the template parameter is constrained, we need to rewrite its
7490 // constraints in terms of the ARG's template parameters. This ensures
7491 // that all of the template parameter types will have the same depth.
7493 // Note that this is only valid when coerce_template_template_parm is
7494 // true for the innermost template parameters of PARM and ARG. In other
7495 // words, because coercion is successful, this conversion will be valid.
7498 tree args
= template_parms_to_args (DECL_TEMPLATE_PARMS (arg
));
7499 parm_cons
= tsubst_constraint_info (parm_cons
,
7500 INNERMOST_TEMPLATE_ARGS (args
),
7501 tf_none
, NULL_TREE
);
7502 if (parm_cons
== error_mark_node
)
7506 return subsumes (parm_cons
, arg_cons
);
7509 // Convert a placeholder argument into a binding to the original
7510 // parameter. The original parameter is saved as the TREE_TYPE of
7513 convert_wildcard_argument (tree parm
, tree arg
)
7515 TREE_TYPE (arg
) = parm
;
7519 /* Convert the indicated template ARG as necessary to match the
7520 indicated template PARM. Returns the converted ARG, or
7521 error_mark_node if the conversion was unsuccessful. Error and
7522 warning messages are issued under control of COMPLAIN. This
7523 conversion is for the Ith parameter in the parameter list. ARGS is
7524 the full set of template arguments deduced so far. */
7527 convert_template_argument (tree parm
,
7530 tsubst_flags_t complain
,
7536 int is_type
, requires_type
, is_tmpl_type
, requires_tmpl_type
;
7538 if (parm
== error_mark_node
)
7539 return error_mark_node
;
7541 /* Trivially convert placeholders. */
7542 if (TREE_CODE (arg
) == WILDCARD_DECL
)
7543 return convert_wildcard_argument (parm
, arg
);
7545 if (arg
== any_targ_node
)
7548 if (TREE_CODE (arg
) == TREE_LIST
7549 && TREE_CODE (TREE_VALUE (arg
)) == OFFSET_REF
)
7551 /* The template argument was the name of some
7552 member function. That's usually
7553 invalid, but static members are OK. In any
7554 case, grab the underlying fields/functions
7555 and issue an error later if required. */
7556 orig_arg
= TREE_VALUE (arg
);
7557 TREE_TYPE (arg
) = unknown_type_node
;
7562 requires_tmpl_type
= TREE_CODE (parm
) == TEMPLATE_DECL
;
7563 requires_type
= (TREE_CODE (parm
) == TYPE_DECL
7564 || requires_tmpl_type
);
7566 /* When determining whether an argument pack expansion is a template,
7567 look at the pattern. */
7568 if (TREE_CODE (arg
) == TYPE_PACK_EXPANSION
)
7569 arg
= PACK_EXPANSION_PATTERN (arg
);
7571 /* Deal with an injected-class-name used as a template template arg. */
7572 if (requires_tmpl_type
&& CLASS_TYPE_P (arg
))
7574 tree t
= maybe_get_template_decl_from_type_decl (TYPE_NAME (arg
));
7575 if (TREE_CODE (t
) == TEMPLATE_DECL
)
7577 if (cxx_dialect
>= cxx11
)
7578 /* OK under DR 1004. */;
7579 else if (complain
& tf_warning_or_error
)
7580 pedwarn (input_location
, OPT_Wpedantic
, "injected-class-name %qD"
7581 " used as template template argument", TYPE_NAME (arg
));
7582 else if (flag_pedantic_errors
)
7590 ((TREE_CODE (arg
) == TEMPLATE_DECL
7591 && TREE_CODE (DECL_TEMPLATE_RESULT (arg
)) == TYPE_DECL
)
7592 || (requires_tmpl_type
&& TREE_CODE (arg
) == TYPE_ARGUMENT_PACK
)
7593 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
7594 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
7597 && (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
7598 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
))
7599 arg
= TYPE_STUB_DECL (arg
);
7601 is_type
= TYPE_P (arg
) || is_tmpl_type
;
7603 if (requires_type
&& ! is_type
&& TREE_CODE (arg
) == SCOPE_REF
7604 && TREE_CODE (TREE_OPERAND (arg
, 0)) == TEMPLATE_TYPE_PARM
)
7606 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == BIT_NOT_EXPR
)
7608 if (complain
& tf_error
)
7609 error ("invalid use of destructor %qE as a type", orig_arg
);
7610 return error_mark_node
;
7613 permerror (input_location
,
7614 "to refer to a type member of a template parameter, "
7615 "use %<typename %E%>", orig_arg
);
7617 orig_arg
= make_typename_type (TREE_OPERAND (arg
, 0),
7618 TREE_OPERAND (arg
, 1),
7624 if (is_type
!= requires_type
)
7628 if (complain
& tf_error
)
7630 error ("type/value mismatch at argument %d in template "
7631 "parameter list for %qD",
7634 inform (input_location
,
7635 " expected a constant of type %qT, got %qT",
7637 (DECL_P (arg
) ? DECL_NAME (arg
) : orig_arg
));
7638 else if (requires_tmpl_type
)
7639 inform (input_location
,
7640 " expected a class template, got %qE", orig_arg
);
7642 inform (input_location
,
7643 " expected a type, got %qE", orig_arg
);
7646 return error_mark_node
;
7648 if (is_tmpl_type
^ requires_tmpl_type
)
7650 if (in_decl
&& (complain
& tf_error
))
7652 error ("type/value mismatch at argument %d in template "
7653 "parameter list for %qD",
7656 inform (input_location
,
7657 " expected a type, got %qT", DECL_NAME (arg
));
7659 inform (input_location
,
7660 " expected a class template, got %qT", orig_arg
);
7662 return error_mark_node
;
7665 if (template_parameter_pack_p (parm
) && ARGUMENT_PACK_P (orig_arg
))
7666 /* We already did the appropriate conversion when packing args. */
7670 if (requires_tmpl_type
)
7672 if (TREE_CODE (TREE_TYPE (arg
)) == UNBOUND_CLASS_TEMPLATE
)
7673 /* The number of argument required is not known yet.
7674 Just accept it for now. */
7678 tree parmparm
= DECL_INNERMOST_TEMPLATE_PARMS (parm
);
7681 /* Strip alias templates that are equivalent to another
7683 arg
= get_underlying_template (arg
);
7684 argparm
= DECL_INNERMOST_TEMPLATE_PARMS (arg
);
7686 if (coerce_template_template_parms (parmparm
, argparm
,
7692 /* TEMPLATE_TEMPLATE_PARM node is preferred over
7694 if (val
!= error_mark_node
)
7696 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
7697 val
= TREE_TYPE (val
);
7698 if (TREE_CODE (orig_arg
) == TYPE_PACK_EXPANSION
)
7699 val
= make_pack_expansion (val
);
7704 if (in_decl
&& (complain
& tf_error
))
7706 error ("type/value mismatch at argument %d in "
7707 "template parameter list for %qD",
7709 inform (input_location
,
7710 " expected a template of type %qD, got %qT",
7714 val
= error_mark_node
;
7717 // Check that the constraints are compatible before allowing the
7719 if (val
!= error_mark_node
)
7720 if (!is_compatible_template_arg (parm
, arg
))
7722 if (in_decl
&& (complain
& tf_error
))
7724 error ("constraint mismatch at argument %d in "
7725 "template parameter list for %qD",
7727 inform (input_location
, " expected %qD but got %qD",
7730 val
= error_mark_node
;
7736 /* We only form one instance of each template specialization.
7737 Therefore, if we use a non-canonical variant (i.e., a
7738 typedef), any future messages referring to the type will use
7739 the typedef, which is confusing if those future uses do not
7740 themselves also use the typedef. */
7742 val
= canonicalize_type_argument (val
, complain
);
7746 tree t
= TREE_TYPE (parm
);
7748 if (tree a
= type_uses_auto (t
))
7750 t
= do_auto_deduction (t
, arg
, a
, complain
, adc_unify
, args
);
7751 if (t
== error_mark_node
)
7752 return error_mark_node
;
7755 t
= tsubst (t
, args
, complain
, in_decl
);
7757 if (invalid_nontype_parm_type_p (t
, complain
))
7758 return error_mark_node
;
7760 if (!type_dependent_expression_p (orig_arg
)
7761 && !uses_template_parms (t
))
7762 /* We used to call digest_init here. However, digest_init
7763 will report errors, which we don't want when complain
7764 is zero. More importantly, digest_init will try too
7765 hard to convert things: for example, `0' should not be
7766 converted to pointer type at this point according to
7767 the standard. Accepting this is not merely an
7768 extension, since deciding whether or not these
7769 conversions can occur is part of determining which
7770 function template to call, or whether a given explicit
7771 argument specification is valid. */
7772 val
= convert_nontype_argument (t
, orig_arg
, complain
);
7774 val
= canonicalize_expr_argument (orig_arg
, complain
);
7776 if (val
== NULL_TREE
)
7777 val
= error_mark_node
;
7778 else if (val
== error_mark_node
&& (complain
& tf_error
))
7779 error ("could not convert template argument %qE from %qT to %qT",
7780 orig_arg
, TREE_TYPE (orig_arg
), t
);
7782 if (INDIRECT_REF_P (val
))
7784 /* Reject template arguments that are references to built-in
7785 functions with no library fallbacks. */
7786 const_tree inner
= TREE_OPERAND (val
, 0);
7787 const_tree innertype
= TREE_TYPE (inner
);
7789 && TREE_CODE (innertype
) == REFERENCE_TYPE
7790 && TREE_CODE (TREE_TYPE (innertype
)) == FUNCTION_TYPE
7791 && 0 < TREE_OPERAND_LENGTH (inner
)
7792 && reject_gcc_builtin (TREE_OPERAND (inner
, 0)))
7793 return error_mark_node
;
7796 if (TREE_CODE (val
) == SCOPE_REF
)
7798 /* Strip typedefs from the SCOPE_REF. */
7799 tree type
= canonicalize_type_argument (TREE_TYPE (val
), complain
);
7800 tree scope
= canonicalize_type_argument (TREE_OPERAND (val
, 0),
7802 val
= build_qualified_name (type
, scope
, TREE_OPERAND (val
, 1),
7803 QUALIFIED_NAME_IS_TEMPLATE (val
));
7810 /* Coerces the remaining template arguments in INNER_ARGS (from
7811 ARG_IDX to the end) into the parameter pack at PARM_IDX in PARMS.
7812 Returns the coerced argument pack. PARM_IDX is the position of this
7813 parameter in the template parameter list. ARGS is the original
7814 template argument list. */
7816 coerce_template_parameter_pack (tree parms
,
7824 tsubst_flags_t complain
)
7826 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
7827 int nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
7830 tree packed_parms
= NULL_TREE
;
7832 if (arg_idx
> nargs
)
7835 if (tree packs
= fixed_parameter_pack_p (TREE_VALUE (parm
)))
7837 /* When the template parameter is a non-type template parameter pack
7838 or template template parameter pack whose type or template
7839 parameters use parameter packs, we know exactly how many arguments
7840 we are looking for. Build a vector of the instantiated decls for
7841 these template parameters in PACKED_PARMS. */
7842 /* We can't use make_pack_expansion here because it would interpret a
7843 _DECL as a use rather than a declaration. */
7844 tree decl
= TREE_VALUE (parm
);
7845 tree exp
= cxx_make_type (TYPE_PACK_EXPANSION
);
7846 SET_PACK_EXPANSION_PATTERN (exp
, decl
);
7847 PACK_EXPANSION_PARAMETER_PACKS (exp
) = packs
;
7848 SET_TYPE_STRUCTURAL_EQUALITY (exp
);
7850 TREE_VEC_LENGTH (args
)--;
7851 packed_parms
= tsubst_pack_expansion (exp
, args
, complain
, decl
);
7852 TREE_VEC_LENGTH (args
)++;
7854 if (packed_parms
== error_mark_node
)
7855 return error_mark_node
;
7857 /* If we're doing a partial instantiation of a member template,
7858 verify that all of the types used for the non-type
7859 template parameter pack are, in fact, valid for non-type
7860 template parameters. */
7862 && PACK_EXPANSION_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
7864 int j
, len
= TREE_VEC_LENGTH (packed_parms
);
7865 for (j
= 0; j
< len
; ++j
)
7867 tree t
= TREE_TYPE (TREE_VEC_ELT (packed_parms
, j
));
7868 if (invalid_nontype_parm_type_p (t
, complain
))
7869 return error_mark_node
;
7871 /* We don't know how many args we have yet, just
7872 use the unconverted ones for now. */
7876 packed_args
= make_tree_vec (TREE_VEC_LENGTH (packed_parms
));
7878 /* Check if we have a placeholder pack, which indicates we're
7879 in the context of a introduction list. In that case we want
7880 to match this pack to the single placeholder. */
7881 else if (arg_idx
< nargs
7882 && TREE_CODE (TREE_VEC_ELT (inner_args
, arg_idx
)) == WILDCARD_DECL
7883 && WILDCARD_PACK_P (TREE_VEC_ELT (inner_args
, arg_idx
)))
7885 nargs
= arg_idx
+ 1;
7886 packed_args
= make_tree_vec (1);
7889 packed_args
= make_tree_vec (nargs
- arg_idx
);
7891 /* Convert the remaining arguments, which will be a part of the
7892 parameter pack "parm". */
7893 int first_pack_arg
= arg_idx
;
7894 for (; arg_idx
< nargs
; ++arg_idx
)
7896 tree arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
7897 tree actual_parm
= TREE_VALUE (parm
);
7898 int pack_idx
= arg_idx
- first_pack_arg
;
7902 /* Once we've packed as many args as we have types, stop. */
7903 if (pack_idx
>= TREE_VEC_LENGTH (packed_parms
))
7905 else if (PACK_EXPANSION_P (arg
))
7906 /* We don't know how many args we have yet, just
7907 use the unconverted ones for now. */
7910 actual_parm
= TREE_VEC_ELT (packed_parms
, pack_idx
);
7913 if (arg
== error_mark_node
)
7915 if (complain
& tf_error
)
7916 error ("template argument %d is invalid", arg_idx
+ 1);
7919 arg
= convert_template_argument (actual_parm
,
7920 arg
, new_args
, complain
, parm_idx
,
7922 if (arg
== error_mark_node
)
7924 TREE_VEC_ELT (packed_args
, pack_idx
) = arg
;
7927 if (arg_idx
- first_pack_arg
< TREE_VEC_LENGTH (packed_args
)
7928 && TREE_VEC_LENGTH (packed_args
) > 0)
7930 if (complain
& tf_error
)
7931 error ("wrong number of template arguments (%d, should be %d)",
7932 arg_idx
- first_pack_arg
, TREE_VEC_LENGTH (packed_args
));
7933 return error_mark_node
;
7936 if (TREE_CODE (TREE_VALUE (parm
)) == TYPE_DECL
7937 || TREE_CODE (TREE_VALUE (parm
)) == TEMPLATE_DECL
)
7938 argument_pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
7941 argument_pack
= make_node (NONTYPE_ARGUMENT_PACK
);
7942 TREE_CONSTANT (argument_pack
) = 1;
7945 SET_ARGUMENT_PACK_ARGS (argument_pack
, packed_args
);
7947 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args
,
7948 TREE_VEC_LENGTH (packed_args
));
7949 return argument_pack
;
7952 /* Returns the number of pack expansions in the template argument vector
7956 pack_expansion_args_count (tree args
)
7961 for (i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
7963 tree elt
= TREE_VEC_ELT (args
, i
);
7964 if (elt
&& PACK_EXPANSION_P (elt
))
7970 /* Convert all template arguments to their appropriate types, and
7971 return a vector containing the innermost resulting template
7972 arguments. If any error occurs, return error_mark_node. Error and
7973 warning messages are issued under control of COMPLAIN.
7975 If REQUIRE_ALL_ARGS is false, argument deduction will be performed
7976 for arguments not specified in ARGS. Otherwise, if
7977 USE_DEFAULT_ARGS is true, default arguments will be used to fill in
7978 unspecified arguments. If REQUIRE_ALL_ARGS is true, but
7979 USE_DEFAULT_ARGS is false, then all arguments must be specified in
7983 coerce_template_parms (tree parms
,
7986 tsubst_flags_t complain
,
7987 bool require_all_args
,
7988 bool use_default_args
)
7990 int nparms
, nargs
, parm_idx
, arg_idx
, lost
= 0;
7991 tree orig_inner_args
;
7994 tree new_inner_args
;
7995 int saved_unevaluated_operand
;
7996 int saved_inhibit_evaluation_warnings
;
7998 /* When used as a boolean value, indicates whether this is a
7999 variadic template parameter list. Since it's an int, we can also
8000 subtract it from nparms to get the number of non-variadic
8003 int variadic_args_p
= 0;
8004 int post_variadic_parms
= 0;
8006 /* Likewise for parameters with default arguments. */
8009 if (args
== error_mark_node
)
8010 return error_mark_node
;
8012 nparms
= TREE_VEC_LENGTH (parms
);
8014 /* Determine if there are any parameter packs or default arguments. */
8015 for (parm_idx
= 0; parm_idx
< nparms
; ++parm_idx
)
8017 tree parm
= TREE_VEC_ELT (parms
, parm_idx
);
8019 ++post_variadic_parms
;
8020 if (template_parameter_pack_p (TREE_VALUE (parm
)))
8022 if (TREE_PURPOSE (parm
))
8026 inner_args
= orig_inner_args
= INNERMOST_TEMPLATE_ARGS (args
);
8027 /* If there are no parameters that follow a parameter pack, we need to
8028 expand any argument packs so that we can deduce a parameter pack from
8029 some non-packed args followed by an argument pack, as in variadic85.C.
8030 If there are such parameters, we need to leave argument packs intact
8031 so the arguments are assigned properly. This can happen when dealing
8032 with a nested class inside a partial specialization of a class
8033 template, as in variadic92.C, or when deducing a template parameter pack
8034 from a sub-declarator, as in variadic114.C. */
8035 if (!post_variadic_parms
)
8036 inner_args
= expand_template_argument_pack (inner_args
);
8038 /* Count any pack expansion args. */
8039 variadic_args_p
= pack_expansion_args_count (inner_args
);
8041 nargs
= inner_args
? NUM_TMPL_ARGS (inner_args
) : 0;
8042 if ((nargs
- variadic_args_p
> nparms
&& !variadic_p
)
8043 || (nargs
< nparms
- variadic_p
8046 && (!use_default_args
8047 || (TREE_VEC_ELT (parms
, nargs
) != error_mark_node
8048 && !TREE_PURPOSE (TREE_VEC_ELT (parms
, nargs
))))))
8050 if (complain
& tf_error
)
8052 if (variadic_p
|| default_p
)
8054 nparms
-= variadic_p
+ default_p
;
8055 error ("wrong number of template arguments "
8056 "(%d, should be at least %d)", nargs
, nparms
);
8059 error ("wrong number of template arguments "
8060 "(%d, should be %d)", nargs
, nparms
);
8063 inform (DECL_SOURCE_LOCATION (in_decl
),
8064 "provided for %qD", in_decl
);
8067 return error_mark_node
;
8069 /* We can't pass a pack expansion to a non-pack parameter of an alias
8070 template (DR 1430). */
8072 && (DECL_ALIAS_TEMPLATE_P (in_decl
)
8073 || concept_template_p (in_decl
))
8075 && nargs
- variadic_args_p
< nparms
- variadic_p
)
8077 if (complain
& tf_error
)
8079 for (int i
= 0; i
< TREE_VEC_LENGTH (inner_args
); ++i
)
8081 tree arg
= TREE_VEC_ELT (inner_args
, i
);
8082 tree parm
= TREE_VALUE (TREE_VEC_ELT (parms
, i
));
8084 if (PACK_EXPANSION_P (arg
)
8085 && !template_parameter_pack_p (parm
))
8087 if (DECL_ALIAS_TEMPLATE_P (in_decl
))
8088 error_at (location_of (arg
),
8089 "pack expansion argument for non-pack parameter "
8090 "%qD of alias template %qD", parm
, in_decl
);
8092 error_at (location_of (arg
),
8093 "pack expansion argument for non-pack parameter "
8094 "%qD of concept %qD", parm
, in_decl
);
8095 inform (DECL_SOURCE_LOCATION (parm
), "declared here");
8102 return error_mark_node
;
8105 /* We need to evaluate the template arguments, even though this
8106 template-id may be nested within a "sizeof". */
8107 saved_unevaluated_operand
= cp_unevaluated_operand
;
8108 cp_unevaluated_operand
= 0;
8109 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
8110 c_inhibit_evaluation_warnings
= 0;
8111 new_inner_args
= make_tree_vec (nparms
);
8112 new_args
= add_outermost_template_args (args
, new_inner_args
);
8113 int pack_adjust
= 0;
8114 for (parm_idx
= 0, arg_idx
= 0; parm_idx
< nparms
; parm_idx
++, arg_idx
++)
8119 /* Get the Ith template parameter. */
8120 parm
= TREE_VEC_ELT (parms
, parm_idx
);
8122 if (parm
== error_mark_node
)
8124 TREE_VEC_ELT (new_inner_args
, arg_idx
) = error_mark_node
;
8128 /* Calculate the next argument. */
8129 if (arg_idx
< nargs
)
8130 arg
= TREE_VEC_ELT (inner_args
, arg_idx
);
8134 if (template_parameter_pack_p (TREE_VALUE (parm
))
8135 && !(arg
&& ARGUMENT_PACK_P (arg
)))
8137 /* Some arguments will be placed in the
8138 template parameter pack PARM. */
8139 arg
= coerce_template_parameter_pack (parms
, parm_idx
, args
,
8140 inner_args
, arg_idx
,
8144 if (arg
== NULL_TREE
)
8146 /* We don't know how many args we have yet, just use the
8147 unconverted (and still packed) ones for now. */
8148 new_inner_args
= orig_inner_args
;
8153 TREE_VEC_ELT (new_inner_args
, parm_idx
) = arg
;
8155 /* Store this argument. */
8156 if (arg
== error_mark_node
)
8159 /* We are done with all of the arguments. */
8164 pack_adjust
= TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) - 1;
8165 arg_idx
+= pack_adjust
;
8172 if (PACK_EXPANSION_P (arg
))
8174 /* "If every valid specialization of a variadic template
8175 requires an empty template parameter pack, the template is
8176 ill-formed, no diagnostic required." So check that the
8177 pattern works with this parameter. */
8178 tree pattern
= PACK_EXPANSION_PATTERN (arg
);
8179 tree conv
= convert_template_argument (TREE_VALUE (parm
),
8183 if (conv
== error_mark_node
)
8185 if (complain
& tf_error
)
8186 inform (input_location
, "so any instantiation with a "
8187 "non-empty parameter pack would be ill-formed");
8190 else if (TYPE_P (conv
) && !TYPE_P (pattern
))
8191 /* Recover from missing typename. */
8192 TREE_VEC_ELT (inner_args
, arg_idx
)
8193 = make_pack_expansion (conv
);
8195 /* We don't know how many args we have yet, just
8196 use the unconverted ones for now. */
8197 new_inner_args
= inner_args
;
8202 else if (require_all_args
)
8204 /* There must be a default arg in this case. */
8205 arg
= tsubst_template_arg (TREE_PURPOSE (parm
), new_args
,
8207 /* The position of the first default template argument,
8208 is also the number of non-defaulted arguments in NEW_INNER_ARGS.
8210 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
8211 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
8212 arg_idx
- pack_adjust
);
8217 if (arg
== error_mark_node
)
8219 if (complain
& tf_error
)
8220 error ("template argument %d is invalid", arg_idx
+ 1);
8223 /* This only occurs if there was an error in the template
8224 parameter list itself (which we would already have
8225 reported) that we are trying to recover from, e.g., a class
8226 template with a parameter list such as
8227 template<typename..., typename>. */
8230 arg
= convert_template_argument (TREE_VALUE (parm
),
8231 arg
, new_args
, complain
,
8234 if (arg
== error_mark_node
)
8236 TREE_VEC_ELT (new_inner_args
, arg_idx
- pack_adjust
) = arg
;
8238 cp_unevaluated_operand
= saved_unevaluated_operand
;
8239 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
8241 if (variadic_p
&& arg_idx
< nargs
)
8243 if (complain
& tf_error
)
8245 error ("wrong number of template arguments "
8246 "(%d, should be %d)", nargs
, arg_idx
);
8248 error ("provided for %q+D", in_decl
);
8250 return error_mark_node
;
8254 return error_mark_node
;
8256 if (CHECKING_P
&& !NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
))
8257 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args
,
8258 TREE_VEC_LENGTH (new_inner_args
));
8260 return new_inner_args
;
8263 /* Convert all template arguments to their appropriate types, and
8264 return a vector containing the innermost resulting template
8265 arguments. If any error occurs, return error_mark_node. Error and
8266 warning messages are not issued.
8268 Note that no function argument deduction is performed, and default
8269 arguments are used to fill in unspecified arguments. */
8271 coerce_template_parms (tree parms
, tree args
, tree in_decl
)
8273 return coerce_template_parms (parms
, args
, in_decl
, tf_none
, true, true);
8276 /* Convert all template arguments to their appropriate type, and
8277 instantiate default arguments as needed. This returns a vector
8278 containing the innermost resulting template arguments, or
8279 error_mark_node if unsuccessful. */
8281 coerce_template_parms (tree parms
, tree args
, tree in_decl
,
8282 tsubst_flags_t complain
)
8284 return coerce_template_parms (parms
, args
, in_decl
, complain
, true, true);
8287 /* Like coerce_template_parms. If PARMS represents all template
8288 parameters levels, this function returns a vector of vectors
8289 representing all the resulting argument levels. Note that in this
8290 case, only the innermost arguments are coerced because the
8291 outermost ones are supposed to have been coerced already.
8293 Otherwise, if PARMS represents only (the innermost) vector of
8294 parameters, this function returns a vector containing just the
8295 innermost resulting arguments. */
8298 coerce_innermost_template_parms (tree parms
,
8301 tsubst_flags_t complain
,
8302 bool require_all_args
,
8303 bool use_default_args
)
8305 int parms_depth
= TMPL_PARMS_DEPTH (parms
);
8306 int args_depth
= TMPL_ARGS_DEPTH (args
);
8309 if (parms_depth
> 1)
8311 coerced_args
= make_tree_vec (parms_depth
);
8315 for (level
= parms
, cur_depth
= parms_depth
;
8316 parms_depth
> 0 && level
!= NULL_TREE
;
8317 level
= TREE_CHAIN (level
), --cur_depth
)
8320 if (cur_depth
== args_depth
)
8321 l
= coerce_template_parms (TREE_VALUE (level
),
8322 args
, in_decl
, complain
,
8326 l
= TMPL_ARGS_LEVEL (args
, cur_depth
);
8328 if (l
== error_mark_node
)
8329 return error_mark_node
;
8331 SET_TMPL_ARGS_LEVEL (coerced_args
, cur_depth
, l
);
8335 coerced_args
= coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parms
),
8336 args
, in_decl
, complain
,
8339 return coerced_args
;
8342 /* Returns 1 if template args OT and NT are equivalent. */
8345 template_args_equal (tree ot
, tree nt
, bool partial_order
/* = false */)
8349 if (nt
== NULL_TREE
|| ot
== NULL_TREE
)
8351 if (nt
== any_targ_node
|| ot
== any_targ_node
)
8354 if (TREE_CODE (nt
) == TREE_VEC
)
8355 /* For member templates */
8356 return TREE_CODE (ot
) == TREE_VEC
&& comp_template_args (ot
, nt
);
8357 else if (PACK_EXPANSION_P (ot
))
8358 return (PACK_EXPANSION_P (nt
)
8359 && template_args_equal (PACK_EXPANSION_PATTERN (ot
),
8360 PACK_EXPANSION_PATTERN (nt
))
8361 && template_args_equal (PACK_EXPANSION_EXTRA_ARGS (ot
),
8362 PACK_EXPANSION_EXTRA_ARGS (nt
)));
8363 else if (ARGUMENT_PACK_P (ot
))
8368 if (!ARGUMENT_PACK_P (nt
))
8371 opack
= ARGUMENT_PACK_ARGS (ot
);
8372 npack
= ARGUMENT_PACK_ARGS (nt
);
8373 len
= TREE_VEC_LENGTH (opack
);
8374 if (TREE_VEC_LENGTH (npack
) != len
)
8376 for (i
= 0; i
< len
; ++i
)
8377 if (!template_args_equal (TREE_VEC_ELT (opack
, i
),
8378 TREE_VEC_ELT (npack
, i
)))
8382 else if (ot
&& TREE_CODE (ot
) == ARGUMENT_PACK_SELECT
)
8384 else if (TYPE_P (nt
))
8388 /* Don't treat an alias template specialization with dependent
8389 arguments as equivalent to its underlying type when used as a
8390 template argument; we need them to be distinct so that we
8391 substitute into the specialization arguments at instantiation
8392 time. And aliases can't be equivalent without being ==, so
8393 we don't need to look any deeper.
8395 During partial ordering, however, we need to treat them normally so
8396 that we can order uses of the same alias with different
8397 cv-qualification (79960). */
8399 && (TYPE_ALIAS_P (nt
) || TYPE_ALIAS_P (ot
)))
8402 return same_type_p (ot
, nt
);
8404 else if (TREE_CODE (ot
) == TREE_VEC
|| TYPE_P (ot
))
8408 /* Try to treat a template non-type argument that has been converted
8409 to the parameter type as equivalent to one that hasn't yet. */
8410 for (enum tree_code code1
= TREE_CODE (ot
);
8411 CONVERT_EXPR_CODE_P (code1
)
8412 || code1
== NON_LVALUE_EXPR
;
8413 code1
= TREE_CODE (ot
))
8414 ot
= TREE_OPERAND (ot
, 0);
8415 for (enum tree_code code2
= TREE_CODE (nt
);
8416 CONVERT_EXPR_CODE_P (code2
)
8417 || code2
== NON_LVALUE_EXPR
;
8418 code2
= TREE_CODE (nt
))
8419 nt
= TREE_OPERAND (nt
, 0);
8421 return cp_tree_equal (ot
, nt
);
8425 /* Returns 1 iff the OLDARGS and NEWARGS are in fact identical sets of
8426 template arguments. Returns 0 otherwise, and updates OLDARG_PTR and
8427 NEWARG_PTR with the offending arguments if they are non-NULL. */
8430 comp_template_args (tree oldargs
, tree newargs
,
8431 tree
*oldarg_ptr
, tree
*newarg_ptr
,
8436 if (oldargs
== newargs
)
8439 if (!oldargs
|| !newargs
)
8442 if (TREE_VEC_LENGTH (oldargs
) != TREE_VEC_LENGTH (newargs
))
8445 for (i
= 0; i
< TREE_VEC_LENGTH (oldargs
); ++i
)
8447 tree nt
= TREE_VEC_ELT (newargs
, i
);
8448 tree ot
= TREE_VEC_ELT (oldargs
, i
);
8450 if (! template_args_equal (ot
, nt
, partial_order
))
8452 if (oldarg_ptr
!= NULL
)
8454 if (newarg_ptr
!= NULL
)
8463 comp_template_args_porder (tree oargs
, tree nargs
)
8465 return comp_template_args (oargs
, nargs
, NULL
, NULL
, true);
8469 add_pending_template (tree d
)
8471 tree ti
= (TYPE_P (d
)
8472 ? CLASSTYPE_TEMPLATE_INFO (d
)
8473 : DECL_TEMPLATE_INFO (d
));
8474 struct pending_template
*pt
;
8477 if (TI_PENDING_TEMPLATE_FLAG (ti
))
8480 /* We are called both from instantiate_decl, where we've already had a
8481 tinst_level pushed, and instantiate_template, where we haven't.
8483 level
= !current_tinst_level
|| current_tinst_level
->decl
!= d
;
8486 push_tinst_level (d
);
8488 pt
= ggc_alloc
<pending_template
> ();
8490 pt
->tinst
= current_tinst_level
;
8491 if (last_pending_template
)
8492 last_pending_template
->next
= pt
;
8494 pending_templates
= pt
;
8496 last_pending_template
= pt
;
8498 TI_PENDING_TEMPLATE_FLAG (ti
) = 1;
8505 /* Return a TEMPLATE_ID_EXPR corresponding to the indicated FNS and
8506 ARGLIST. Valid choices for FNS are given in the cp-tree.def
8507 documentation for TEMPLATE_ID_EXPR. */
8510 lookup_template_function (tree fns
, tree arglist
)
8514 if (fns
== error_mark_node
|| arglist
== error_mark_node
)
8515 return error_mark_node
;
8517 gcc_assert (!arglist
|| TREE_CODE (arglist
) == TREE_VEC
);
8519 if (!is_overloaded_fn (fns
) && !identifier_p (fns
))
8521 error ("%q#D is not a function template", fns
);
8522 return error_mark_node
;
8525 if (BASELINK_P (fns
))
8527 BASELINK_FUNCTIONS (fns
) = build2 (TEMPLATE_ID_EXPR
,
8529 BASELINK_FUNCTIONS (fns
),
8534 type
= TREE_TYPE (fns
);
8535 if (TREE_CODE (fns
) == OVERLOAD
|| !type
)
8536 type
= unknown_type_node
;
8538 return build2 (TEMPLATE_ID_EXPR
, type
, fns
, arglist
);
8541 /* Within the scope of a template class S<T>, the name S gets bound
8542 (in build_self_reference) to a TYPE_DECL for the class, not a
8543 TEMPLATE_DECL. If DECL is a TYPE_DECL for current_class_type,
8544 or one of its enclosing classes, and that type is a template,
8545 return the associated TEMPLATE_DECL. Otherwise, the original
8548 Also handle the case when DECL is a TREE_LIST of ambiguous
8549 injected-class-names from different bases. */
8552 maybe_get_template_decl_from_type_decl (tree decl
)
8554 if (decl
== NULL_TREE
)
8557 /* DR 176: A lookup that finds an injected-class-name (10.2
8558 [class.member.lookup]) can result in an ambiguity in certain cases
8559 (for example, if it is found in more than one base class). If all of
8560 the injected-class-names that are found refer to specializations of
8561 the same class template, and if the name is followed by a
8562 template-argument-list, the reference refers to the class template
8563 itself and not a specialization thereof, and is not ambiguous. */
8564 if (TREE_CODE (decl
) == TREE_LIST
)
8566 tree t
, tmpl
= NULL_TREE
;
8567 for (t
= decl
; t
; t
= TREE_CHAIN (t
))
8569 tree elt
= maybe_get_template_decl_from_type_decl (TREE_VALUE (t
));
8572 else if (tmpl
!= elt
)
8575 if (tmpl
&& t
== NULL_TREE
)
8581 return (decl
!= NULL_TREE
8582 && DECL_SELF_REFERENCE_P (decl
)
8583 && CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
8584 ? CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl
)) : decl
;
8587 /* Given an IDENTIFIER_NODE (or type TEMPLATE_DECL) and a chain of
8588 parameters, find the desired type.
8590 D1 is the PTYPENAME terminal, and ARGLIST is the list of arguments.
8592 IN_DECL, if non-NULL, is the template declaration we are trying to
8595 If ENTERING_SCOPE is nonzero, we are about to enter the scope of
8596 the class we are looking up.
8598 Issue error and warning messages under control of COMPLAIN.
8600 If the template class is really a local class in a template
8601 function, then the FUNCTION_CONTEXT is the function in which it is
8604 ??? Note that this function is currently called *twice* for each
8605 template-id: the first time from the parser, while creating the
8606 incomplete type (finish_template_type), and the second type during the
8607 real instantiation (instantiate_template_class). This is surely something
8608 that we want to avoid. It also causes some problems with argument
8609 coercion (see convert_nontype_argument for more information on this). */
8612 lookup_template_class_1 (tree d1
, tree arglist
, tree in_decl
, tree context
,
8613 int entering_scope
, tsubst_flags_t complain
)
8615 tree templ
= NULL_TREE
, parmlist
;
8622 if (identifier_p (d1
))
8624 tree value
= innermost_non_namespace_value (d1
);
8625 if (value
&& DECL_TEMPLATE_TEMPLATE_PARM_P (value
))
8630 push_decl_namespace (context
);
8631 templ
= lookup_name (d1
);
8632 templ
= maybe_get_template_decl_from_type_decl (templ
);
8634 pop_decl_namespace ();
8637 context
= DECL_CONTEXT (templ
);
8639 else if (TREE_CODE (d1
) == TYPE_DECL
&& MAYBE_CLASS_TYPE_P (TREE_TYPE (d1
)))
8641 tree type
= TREE_TYPE (d1
);
8643 /* If we are declaring a constructor, say A<T>::A<T>, we will get
8644 an implicit typename for the second A. Deal with it. */
8645 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
8646 type
= TREE_TYPE (type
);
8648 if (CLASSTYPE_TEMPLATE_INFO (type
))
8650 templ
= CLASSTYPE_TI_TEMPLATE (type
);
8651 d1
= DECL_NAME (templ
);
8654 else if (TREE_CODE (d1
) == ENUMERAL_TYPE
8655 || (TYPE_P (d1
) && MAYBE_CLASS_TYPE_P (d1
)))
8657 templ
= TYPE_TI_TEMPLATE (d1
);
8658 d1
= DECL_NAME (templ
);
8660 else if (DECL_TYPE_TEMPLATE_P (d1
))
8663 d1
= DECL_NAME (templ
);
8664 context
= DECL_CONTEXT (templ
);
8666 else if (DECL_TEMPLATE_TEMPLATE_PARM_P (d1
))
8669 d1
= DECL_NAME (templ
);
8672 /* Issue an error message if we didn't find a template. */
8675 if (complain
& tf_error
)
8676 error ("%qT is not a template", d1
);
8677 return error_mark_node
;
8680 if (TREE_CODE (templ
) != TEMPLATE_DECL
8681 /* Make sure it's a user visible template, if it was named by
8683 || ((complain
& tf_user
) && !DECL_TEMPLATE_PARM_P (templ
)
8684 && !PRIMARY_TEMPLATE_P (templ
)))
8686 if (complain
& tf_error
)
8688 error ("non-template type %qT used as a template", d1
);
8690 error ("for template declaration %q+D", in_decl
);
8692 return error_mark_node
;
8695 complain
&= ~tf_user
;
8697 /* An alias that just changes the name of a template is equivalent to the
8698 other template, so if any of the arguments are pack expansions, strip
8699 the alias to avoid problems with a pack expansion passed to a non-pack
8700 alias template parameter (DR 1430). */
8701 if (pack_expansion_args_count (INNERMOST_TEMPLATE_ARGS (arglist
)))
8702 templ
= get_underlying_template (templ
);
8704 if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ
))
8707 tree arglist2
= coerce_template_args_for_ttp (templ
, arglist
, complain
);
8708 if (arglist2
== error_mark_node
8709 || (!uses_template_parms (arglist2
)
8710 && check_instantiated_args (templ
, arglist2
, complain
)))
8711 return error_mark_node
;
8713 parm
= bind_template_template_parm (TREE_TYPE (templ
), arglist2
);
8718 tree template_type
= TREE_TYPE (templ
);
8721 tree found
= NULL_TREE
;
8724 int is_dependent_type
;
8725 int use_partial_inst_tmpl
= false;
8727 if (template_type
== error_mark_node
)
8728 /* An error occurred while building the template TEMPL, and a
8729 diagnostic has most certainly been emitted for that
8730 already. Let's propagate that error. */
8731 return error_mark_node
;
8733 gen_tmpl
= most_general_template (templ
);
8734 parmlist
= DECL_TEMPLATE_PARMS (gen_tmpl
);
8735 parm_depth
= TMPL_PARMS_DEPTH (parmlist
);
8736 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
8738 if (arg_depth
== 1 && parm_depth
> 1)
8740 /* We've been given an incomplete set of template arguments.
8743 template <class T> struct S1 {
8744 template <class U> struct S2 {};
8745 template <class U> struct S2<U*> {};
8748 we will be called with an ARGLIST of `U*', but the
8749 TEMPLATE will be `template <class T> template
8750 <class U> struct S1<T>::S2'. We must fill in the missing
8752 tree ti
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (TREE_TYPE (templ
));
8753 arglist
= add_outermost_template_args (TI_ARGS (ti
), arglist
);
8754 arg_depth
= TMPL_ARGS_DEPTH (arglist
);
8757 /* Now we should have enough arguments. */
8758 gcc_assert (parm_depth
== arg_depth
);
8760 /* From here on, we're only interested in the most general
8763 /* Calculate the BOUND_ARGS. These will be the args that are
8764 actually tsubst'd into the definition to create the
8766 arglist
= coerce_innermost_template_parms (parmlist
, arglist
, gen_tmpl
,
8768 /*require_all_args=*/true,
8769 /*use_default_args=*/true);
8771 if (arglist
== error_mark_node
)
8772 /* We were unable to bind the arguments. */
8773 return error_mark_node
;
8775 /* In the scope of a template class, explicit references to the
8776 template class refer to the type of the template, not any
8777 instantiation of it. For example, in:
8779 template <class T> class C { void f(C<T>); }
8781 the `C<T>' is just the same as `C'. Outside of the
8782 class, however, such a reference is an instantiation. */
8784 || !PRIMARY_TEMPLATE_P (gen_tmpl
)
8785 || currently_open_class (template_type
))
8787 tree tinfo
= TYPE_TEMPLATE_INFO (template_type
);
8789 if (tinfo
&& comp_template_args (TI_ARGS (tinfo
), arglist
))
8790 return template_type
;
8793 /* If we already have this specialization, return it. */
8794 elt
.tmpl
= gen_tmpl
;
8796 elt
.spec
= NULL_TREE
;
8797 hash
= spec_hasher::hash (&elt
);
8798 entry
= type_specializations
->find_with_hash (&elt
, hash
);
8803 /* If the the template's constraints are not satisfied,
8804 then we cannot form a valid type.
8806 Note that the check is deferred until after the hash
8807 lookup. This prevents redundant checks on previously
8808 instantiated specializations. */
8809 if (flag_concepts
&& !constraints_satisfied_p (gen_tmpl
, arglist
))
8811 if (complain
& tf_error
)
8813 error ("template constraint failure");
8814 diagnose_constraints (input_location
, gen_tmpl
, arglist
);
8816 return error_mark_node
;
8819 is_dependent_type
= uses_template_parms (arglist
);
8821 /* If the deduced arguments are invalid, then the binding
8823 if (!is_dependent_type
8824 && check_instantiated_args (gen_tmpl
,
8825 INNERMOST_TEMPLATE_ARGS (arglist
),
8827 return error_mark_node
;
8829 if (!is_dependent_type
8830 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
8831 && !LAMBDA_TYPE_P (TREE_TYPE (gen_tmpl
))
8832 && TREE_CODE (CP_DECL_CONTEXT (gen_tmpl
)) == NAMESPACE_DECL
)
8834 found
= xref_tag_from_type (TREE_TYPE (gen_tmpl
),
8835 DECL_NAME (gen_tmpl
),
8836 /*tag_scope=*/ts_global
);
8840 context
= tsubst (DECL_CONTEXT (gen_tmpl
), arglist
,
8842 if (context
== error_mark_node
)
8843 return error_mark_node
;
8846 context
= global_namespace
;
8848 /* Create the type. */
8849 if (DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
8851 /* The user referred to a specialization of an alias
8852 template represented by GEN_TMPL.
8854 [temp.alias]/2 says:
8856 When a template-id refers to the specialization of an
8857 alias template, it is equivalent to the associated
8858 type obtained by substitution of its
8859 template-arguments for the template-parameters in the
8860 type-id of the alias template. */
8862 t
= tsubst (TREE_TYPE (gen_tmpl
), arglist
, complain
, in_decl
);
8863 /* Note that the call above (by indirectly calling
8864 register_specialization in tsubst_decl) registers the
8865 TYPE_DECL representing the specialization of the alias
8866 template. So next time someone substitutes ARGLIST for
8867 the template parms into the alias template (GEN_TMPL),
8868 she'll get that TYPE_DECL back. */
8870 if (t
== error_mark_node
)
8873 else if (TREE_CODE (template_type
) == ENUMERAL_TYPE
)
8875 if (!is_dependent_type
)
8877 set_current_access_from_decl (TYPE_NAME (template_type
));
8878 t
= start_enum (TYPE_IDENTIFIER (template_type
), NULL_TREE
,
8879 tsubst (ENUM_UNDERLYING_TYPE (template_type
),
8880 arglist
, complain
, in_decl
),
8881 tsubst_attributes (TYPE_ATTRIBUTES (template_type
),
8882 arglist
, complain
, in_decl
),
8883 SCOPED_ENUM_P (template_type
), NULL
);
8885 if (t
== error_mark_node
)
8890 /* We don't want to call start_enum for this type, since
8891 the values for the enumeration constants may involve
8892 template parameters. And, no one should be interested
8893 in the enumeration constants for such a type. */
8894 t
= cxx_make_type (ENUMERAL_TYPE
);
8895 SET_SCOPED_ENUM_P (t
, SCOPED_ENUM_P (template_type
));
8897 SET_OPAQUE_ENUM_P (t
, OPAQUE_ENUM_P (template_type
));
8898 ENUM_FIXED_UNDERLYING_TYPE_P (t
)
8899 = ENUM_FIXED_UNDERLYING_TYPE_P (template_type
);
8901 else if (CLASS_TYPE_P (template_type
))
8903 t
= make_class_type (TREE_CODE (template_type
));
8904 CLASSTYPE_DECLARED_CLASS (t
)
8905 = CLASSTYPE_DECLARED_CLASS (template_type
);
8906 SET_CLASSTYPE_IMPLICIT_INSTANTIATION (t
);
8908 /* A local class. Make sure the decl gets registered properly. */
8909 if (context
== current_function_decl
)
8910 pushtag (DECL_NAME (gen_tmpl
), t
, /*tag_scope=*/ts_current
);
8912 if (comp_template_args (CLASSTYPE_TI_ARGS (template_type
), arglist
))
8913 /* This instantiation is another name for the primary
8914 template type. Set the TYPE_CANONICAL field
8916 TYPE_CANONICAL (t
) = template_type
;
8917 else if (any_template_arguments_need_structural_equality_p (arglist
))
8918 /* Some of the template arguments require structural
8919 equality testing, so this template class requires
8920 structural equality testing. */
8921 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8926 /* If we called start_enum or pushtag above, this information
8927 will already be set up. */
8930 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
8932 type_decl
= create_implicit_typedef (DECL_NAME (gen_tmpl
), t
);
8933 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (t
);
8934 DECL_SOURCE_LOCATION (type_decl
)
8935 = DECL_SOURCE_LOCATION (TYPE_STUB_DECL (template_type
));
8938 type_decl
= TYPE_NAME (t
);
8940 if (CLASS_TYPE_P (template_type
))
8942 TREE_PRIVATE (type_decl
)
8943 = TREE_PRIVATE (TYPE_MAIN_DECL (template_type
));
8944 TREE_PROTECTED (type_decl
)
8945 = TREE_PROTECTED (TYPE_MAIN_DECL (template_type
));
8946 if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type
))
8948 DECL_VISIBILITY_SPECIFIED (type_decl
) = 1;
8949 DECL_VISIBILITY (type_decl
) = CLASSTYPE_VISIBILITY (template_type
);
8953 if (OVERLOAD_TYPE_P (t
)
8954 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
8956 static const char *tags
[] = {"abi_tag", "may_alias"};
8958 for (unsigned ix
= 0; ix
!= 2; ix
++)
8961 = lookup_attribute (tags
[ix
], TYPE_ATTRIBUTES (template_type
));
8965 = tree_cons (TREE_PURPOSE (attributes
),
8966 TREE_VALUE (attributes
),
8967 TYPE_ATTRIBUTES (t
));
8971 /* Let's consider the explicit specialization of a member
8972 of a class template specialization that is implicitly instantiated,
8977 template<class U> struct M {}; //#0
8982 struct S<int>::M<char> //#1
8986 [temp.expl.spec]/4 says this is valid.
8988 In this case, when we write:
8991 M is instantiated from the CLASSTYPE_TI_TEMPLATE of #1, not from
8994 When we encounter #1, we want to store the partial instantiation
8995 of M (template<class T> S<int>::M<T>) in its CLASSTYPE_TI_TEMPLATE.
8997 For all cases other than this "explicit specialization of member of a
8998 class template", we just want to store the most general template into
8999 the CLASSTYPE_TI_TEMPLATE of M.
9001 This case of "explicit specialization of member of a class template"
9003 1/ the enclosing class is an instantiation of, and therefore not
9004 the same as, the context of the most general template, and
9005 2/ we aren't looking at the partial instantiation itself, i.e.
9006 the innermost arguments are not the same as the innermost parms of
9007 the most general template.
9009 So it's only when 1/ and 2/ happens that we want to use the partial
9010 instantiation of the member template in lieu of its most general
9013 if (PRIMARY_TEMPLATE_P (gen_tmpl
)
9014 && TMPL_ARGS_HAVE_MULTIPLE_LEVELS (arglist
)
9015 /* the enclosing class must be an instantiation... */
9016 && CLASS_TYPE_P (context
)
9017 && !same_type_p (context
, DECL_CONTEXT (gen_tmpl
)))
9019 TREE_VEC_LENGTH (arglist
)--;
9020 ++processing_template_decl
;
9021 tree tinfo
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (TREE_TYPE (gen_tmpl
));
9022 tree partial_inst_args
=
9023 tsubst (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo
)),
9024 arglist
, complain
, NULL_TREE
);
9025 --processing_template_decl
;
9026 TREE_VEC_LENGTH (arglist
)++;
9027 if (partial_inst_args
== error_mark_node
)
9028 return error_mark_node
;
9029 use_partial_inst_tmpl
=
9030 /*...and we must not be looking at the partial instantiation
9032 !comp_template_args (INNERMOST_TEMPLATE_ARGS (arglist
),
9036 if (!use_partial_inst_tmpl
)
9037 /* This case is easy; there are no member templates involved. */
9041 /* This is a full instantiation of a member template. Find
9042 the partial instantiation of which this is an instance. */
9044 /* Temporarily reduce by one the number of levels in the ARGLIST
9045 so as to avoid comparing the last set of arguments. */
9046 TREE_VEC_LENGTH (arglist
)--;
9047 found
= tsubst (gen_tmpl
, arglist
, complain
, NULL_TREE
);
9048 TREE_VEC_LENGTH (arglist
)++;
9049 /* FOUND is either a proper class type, or an alias
9050 template specialization. In the later case, it's a
9051 TYPE_DECL, resulting from the substituting of arguments
9052 for parameters in the TYPE_DECL of the alias template
9053 done earlier. So be careful while getting the template
9055 found
= (TREE_CODE (found
) == TEMPLATE_DECL
9057 : (TREE_CODE (found
) == TYPE_DECL
9058 ? DECL_TI_TEMPLATE (found
)
9059 : CLASSTYPE_TI_TEMPLATE (found
)));
9062 // Build template info for the new specialization.
9063 SET_TYPE_TEMPLATE_INFO (t
, build_template_info (found
, arglist
));
9066 slot
= type_specializations
->find_slot_with_hash (&elt
, hash
, INSERT
);
9067 entry
= ggc_alloc
<spec_entry
> ();
9071 /* Note this use of the partial instantiation so we can check it
9072 later in maybe_process_partial_specialization. */
9073 DECL_TEMPLATE_INSTANTIATIONS (found
)
9074 = tree_cons (arglist
, t
,
9075 DECL_TEMPLATE_INSTANTIATIONS (found
));
9077 if (TREE_CODE (template_type
) == ENUMERAL_TYPE
&& !is_dependent_type
9078 && !DECL_ALIAS_TEMPLATE_P (gen_tmpl
))
9079 /* Now that the type has been registered on the instantiations
9080 list, we set up the enumerators. Because the enumeration
9081 constants may involve the enumeration type itself, we make
9082 sure to register the type first, and then create the
9083 constants. That way, doing tsubst_expr for the enumeration
9084 constants won't result in recursive calls here; we'll find
9085 the instantiation and exit above. */
9086 tsubst_enum (template_type
, t
, arglist
);
9088 if (CLASS_TYPE_P (template_type
) && is_dependent_type
)
9089 /* If the type makes use of template parameters, the
9090 code that generates debugging information will crash. */
9091 DECL_IGNORED_P (TYPE_MAIN_DECL (t
)) = 1;
9093 /* Possibly limit visibility based on template args. */
9094 TREE_PUBLIC (type_decl
) = 1;
9095 determine_visibility (type_decl
);
9097 inherit_targ_abi_tags (t
);
9103 /* Wrapper for lookup_template_class_1. */
9106 lookup_template_class (tree d1
, tree arglist
, tree in_decl
, tree context
,
9107 int entering_scope
, tsubst_flags_t complain
)
9110 timevar_push (TV_TEMPLATE_INST
);
9111 ret
= lookup_template_class_1 (d1
, arglist
, in_decl
, context
,
9112 entering_scope
, complain
);
9113 timevar_pop (TV_TEMPLATE_INST
);
9117 /* Return a TEMPLATE_ID_EXPR for the given variable template and ARGLIST. */
9120 lookup_template_variable (tree templ
, tree arglist
)
9122 /* The type of the expression is NULL_TREE since the template-id could refer
9123 to an explicit or partial specialization. */
9124 tree type
= NULL_TREE
;
9125 if (flag_concepts
&& variable_concept_p (templ
))
9126 /* Except that concepts are always bool. */
9127 type
= boolean_type_node
;
9128 return build2 (TEMPLATE_ID_EXPR
, type
, templ
, arglist
);
9131 /* Instantiate a variable declaration from a TEMPLATE_ID_EXPR for use. */
9134 finish_template_variable (tree var
, tsubst_flags_t complain
)
9136 tree templ
= TREE_OPERAND (var
, 0);
9137 tree arglist
= TREE_OPERAND (var
, 1);
9139 /* We never want to return a VAR_DECL for a variable concept, since they
9140 aren't instantiated. In a template, leave the TEMPLATE_ID_EXPR alone. */
9141 bool concept_p
= flag_concepts
&& variable_concept_p (templ
);
9142 if (concept_p
&& processing_template_decl
)
9145 tree tmpl_args
= DECL_TI_ARGS (DECL_TEMPLATE_RESULT (templ
));
9146 arglist
= add_outermost_template_args (tmpl_args
, arglist
);
9148 templ
= most_general_template (templ
);
9149 tree parms
= DECL_TEMPLATE_PARMS (templ
);
9150 arglist
= coerce_innermost_template_parms (parms
, arglist
, templ
, complain
,
9152 /*use_default*/true);
9154 if (flag_concepts
&& !constraints_satisfied_p (templ
, arglist
))
9156 if (complain
& tf_error
)
9158 error ("use of invalid variable template %qE", var
);
9159 diagnose_constraints (location_of (var
), templ
, arglist
);
9161 return error_mark_node
;
9164 /* If a template-id refers to a specialization of a variable
9165 concept, then the expression is true if and only if the
9166 concept's constraints are satisfied by the given template
9169 NOTE: This is an extension of Concepts Lite TS that
9170 allows constraints to be used in expressions. */
9173 tree decl
= DECL_TEMPLATE_RESULT (templ
);
9174 return evaluate_variable_concept (decl
, arglist
);
9177 return instantiate_template (templ
, arglist
, complain
);
9180 /* Construct a TEMPLATE_ID_EXPR for the given variable template TEMPL having
9181 TARGS template args, and instantiate it if it's not dependent. */
9184 lookup_and_finish_template_variable (tree templ
, tree targs
,
9185 tsubst_flags_t complain
)
9187 templ
= lookup_template_variable (templ
, targs
);
9188 if (!any_dependent_template_arguments_p (targs
))
9190 templ
= finish_template_variable (templ
, complain
);
9194 return convert_from_reference (templ
);
9203 /* True when we should also visit template parameters that occur in
9204 non-deduced contexts. */
9205 bool include_nondeduced_p
;
9206 hash_set
<tree
> *visited
;
9209 /* Called from for_each_template_parm via walk_tree. */
9212 for_each_template_parm_r (tree
*tp
, int *walk_subtrees
, void *d
)
9215 struct pair_fn_data
*pfd
= (struct pair_fn_data
*) d
;
9216 tree_fn_t fn
= pfd
->fn
;
9217 void *data
= pfd
->data
;
9218 tree result
= NULL_TREE
;
9220 #define WALK_SUBTREE(NODE) \
9223 result = for_each_template_parm (NODE, fn, data, pfd->visited, \
9224 pfd->include_nondeduced_p, \
9226 if (result) goto out; \
9230 if (pfd
->any_fn
&& (*pfd
->any_fn
)(t
, data
))
9234 && (pfd
->include_nondeduced_p
|| TREE_CODE (t
) != TYPENAME_TYPE
))
9235 WALK_SUBTREE (TYPE_CONTEXT (t
));
9237 switch (TREE_CODE (t
))
9240 if (TYPE_PTRMEMFUNC_P (t
))
9246 if (!TYPE_TEMPLATE_INFO (t
))
9249 WALK_SUBTREE (TYPE_TI_ARGS (t
));
9253 WALK_SUBTREE (TYPE_MIN_VALUE (t
));
9254 WALK_SUBTREE (TYPE_MAX_VALUE (t
));
9258 /* Since we're not going to walk subtrees, we have to do this
9260 WALK_SUBTREE (TYPE_METHOD_BASETYPE (t
));
9264 /* Check the return type. */
9265 WALK_SUBTREE (TREE_TYPE (t
));
9267 /* Check the parameter types. Since default arguments are not
9268 instantiated until they are needed, the TYPE_ARG_TYPES may
9269 contain expressions that involve template parameters. But,
9270 no-one should be looking at them yet. And, once they're
9271 instantiated, they don't contain template parameters, so
9272 there's no point in looking at them then, either. */
9276 for (parm
= TYPE_ARG_TYPES (t
); parm
; parm
= TREE_CHAIN (parm
))
9277 WALK_SUBTREE (TREE_VALUE (parm
));
9279 /* Since we've already handled the TYPE_ARG_TYPES, we don't
9280 want walk_tree walking into them itself. */
9284 if (flag_noexcept_type
)
9286 tree spec
= TYPE_RAISES_EXCEPTIONS (t
);
9288 WALK_SUBTREE (TREE_PURPOSE (spec
));
9293 case UNDERLYING_TYPE
:
9294 if (pfd
->include_nondeduced_p
9295 && for_each_template_parm (TYPE_VALUES_RAW (t
), fn
, data
,
9297 pfd
->include_nondeduced_p
,
9299 return error_mark_node
;
9304 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
9305 WALK_SUBTREE (DECL_TI_ARGS (t
));
9310 if (TREE_CODE (t
) == CONST_DECL
&& DECL_TEMPLATE_PARM_P (t
))
9311 WALK_SUBTREE (DECL_INITIAL (t
));
9312 if (DECL_CONTEXT (t
)
9313 && pfd
->include_nondeduced_p
)
9314 WALK_SUBTREE (DECL_CONTEXT (t
));
9317 case BOUND_TEMPLATE_TEMPLATE_PARM
:
9318 /* Record template parameters such as `T' inside `TT<T>'. */
9319 WALK_SUBTREE (TYPE_TI_ARGS (t
));
9322 case TEMPLATE_TEMPLATE_PARM
:
9323 case TEMPLATE_TYPE_PARM
:
9324 case TEMPLATE_PARM_INDEX
:
9325 if (fn
&& (*fn
)(t
, data
))
9332 /* A template template parameter is encountered. */
9333 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
9334 WALK_SUBTREE (TREE_TYPE (t
));
9336 /* Already substituted template template parameter */
9341 /* A template-id in a TYPENAME_TYPE might be a deduced context after
9342 partial instantiation. */
9343 WALK_SUBTREE (TYPENAME_TYPE_FULLNAME (t
));
9347 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
))
9348 && pfd
->include_nondeduced_p
)
9349 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
9354 /* If there's no type, then this thing must be some expression
9355 involving template parameters. */
9356 if (!fn
&& !TREE_TYPE (t
))
9357 return error_mark_node
;
9362 case IMPLICIT_CONV_EXPR
:
9363 case REINTERPRET_CAST_EXPR
:
9364 case CONST_CAST_EXPR
:
9365 case STATIC_CAST_EXPR
:
9366 case DYNAMIC_CAST_EXPR
:
9370 case PSEUDO_DTOR_EXPR
:
9372 return error_mark_node
;
9381 /* We didn't find any template parameters we liked. */
9386 /* For each TEMPLATE_TYPE_PARM, TEMPLATE_TEMPLATE_PARM,
9387 BOUND_TEMPLATE_TEMPLATE_PARM or TEMPLATE_PARM_INDEX in T,
9388 call FN with the parameter and the DATA.
9389 If FN returns nonzero, the iteration is terminated, and
9390 for_each_template_parm returns 1. Otherwise, the iteration
9391 continues. If FN never returns a nonzero value, the value
9392 returned by for_each_template_parm is 0. If FN is NULL, it is
9393 considered to be the function which always returns 1.
9395 If INCLUDE_NONDEDUCED_P, then this routine will also visit template
9396 parameters that occur in non-deduced contexts. When false, only
9397 visits those template parameters that can be deduced. */
9400 for_each_template_parm (tree t
, tree_fn_t fn
, void* data
,
9401 hash_set
<tree
> *visited
,
9402 bool include_nondeduced_p
,
9405 struct pair_fn_data pfd
;
9410 pfd
.any_fn
= any_fn
;
9412 pfd
.include_nondeduced_p
= include_nondeduced_p
;
9414 /* Walk the tree. (Conceptually, we would like to walk without
9415 duplicates, but for_each_template_parm_r recursively calls
9416 for_each_template_parm, so we would need to reorganize a fair
9417 bit to use walk_tree_without_duplicates, so we keep our own
9420 pfd
.visited
= visited
;
9422 pfd
.visited
= new hash_set
<tree
>;
9423 result
= cp_walk_tree (&t
,
9424 for_each_template_parm_r
,
9438 /* Returns true if T depends on any template parameter. */
9441 uses_template_parms (tree t
)
9447 int saved_processing_template_decl
;
9449 saved_processing_template_decl
= processing_template_decl
;
9450 if (!saved_processing_template_decl
)
9451 processing_template_decl
= 1;
9453 dependent_p
= dependent_type_p (t
);
9454 else if (TREE_CODE (t
) == TREE_VEC
)
9455 dependent_p
= any_dependent_template_arguments_p (t
);
9456 else if (TREE_CODE (t
) == TREE_LIST
)
9457 dependent_p
= (uses_template_parms (TREE_VALUE (t
))
9458 || uses_template_parms (TREE_CHAIN (t
)));
9459 else if (TREE_CODE (t
) == TYPE_DECL
)
9460 dependent_p
= dependent_type_p (TREE_TYPE (t
));
9463 || TREE_CODE (t
) == TEMPLATE_PARM_INDEX
9464 || TREE_CODE (t
) == OVERLOAD
9467 || TREE_CODE (t
) == TRAIT_EXPR
9468 || TREE_CODE (t
) == CONSTRUCTOR
9469 || CONSTANT_CLASS_P (t
))
9470 dependent_p
= (type_dependent_expression_p (t
)
9471 || value_dependent_expression_p (t
));
9474 gcc_assert (t
== error_mark_node
);
9475 dependent_p
= false;
9478 processing_template_decl
= saved_processing_template_decl
;
9483 /* Returns true iff current_function_decl is an incompletely instantiated
9484 template. Useful instead of processing_template_decl because the latter
9485 is set to 0 during instantiate_non_dependent_expr. */
9488 in_template_function (void)
9490 tree fn
= current_function_decl
;
9492 ++processing_template_decl
;
9493 ret
= (fn
&& DECL_LANG_SPECIFIC (fn
)
9494 && DECL_TEMPLATE_INFO (fn
)
9495 && any_dependent_template_arguments_p (DECL_TI_ARGS (fn
)));
9496 --processing_template_decl
;
9500 /* Returns true iff we are currently within a template other than a
9501 default-capturing generic lambda, so we don't need to worry about semantic
9505 processing_nonlambda_template (void)
9507 return processing_template_decl
&& !need_generic_capture ();
9510 /* Returns true if T depends on any template parameter with level LEVEL. */
9513 uses_template_parms_level (tree t
, int level
)
9515 return for_each_template_parm (t
, template_parm_this_level_p
, &level
, NULL
,
9516 /*include_nondeduced_p=*/true);
9519 /* Returns true if the signature of DECL depends on any template parameter from
9520 its enclosing class. */
9523 uses_outer_template_parms (tree decl
)
9525 int depth
= template_class_depth (CP_DECL_CONTEXT (decl
));
9528 if (for_each_template_parm (TREE_TYPE (decl
), template_parm_outer_level
,
9529 &depth
, NULL
, /*include_nondeduced_p=*/true))
9531 if (PRIMARY_TEMPLATE_P (decl
)
9532 && for_each_template_parm (INNERMOST_TEMPLATE_PARMS
9533 (DECL_TEMPLATE_PARMS (decl
)),
9534 template_parm_outer_level
,
9535 &depth
, NULL
, /*include_nondeduced_p=*/true))
9537 tree ci
= get_constraints (decl
);
9539 ci
= CI_ASSOCIATED_CONSTRAINTS (ci
);
9540 if (ci
&& for_each_template_parm (ci
, template_parm_outer_level
,
9541 &depth
, NULL
, /*nondeduced*/true))
9546 /* Returns TRUE iff INST is an instantiation we don't need to do in an
9547 ill-formed translation unit, i.e. a variable or function that isn't
9548 usable in a constant expression. */
9551 neglectable_inst_p (tree d
)
9554 && !undeduced_auto_decl (d
)
9555 && !(TREE_CODE (d
) == FUNCTION_DECL
? DECL_DECLARED_CONSTEXPR_P (d
)
9556 : decl_maybe_constant_var_p (d
)));
9559 /* Returns TRUE iff we should refuse to instantiate DECL because it's
9560 neglectable and instantiated from within an erroneous instantiation. */
9563 limit_bad_template_recursion (tree decl
)
9565 struct tinst_level
*lev
= current_tinst_level
;
9566 int errs
= errorcount
+ sorrycount
;
9567 if (lev
== NULL
|| errs
== 0 || !neglectable_inst_p (decl
))
9570 for (; lev
; lev
= lev
->next
)
9571 if (neglectable_inst_p (lev
->decl
))
9574 return (lev
&& errs
> lev
->errors
);
9577 static int tinst_depth
;
9578 extern int max_tinst_depth
;
9581 static GTY(()) struct tinst_level
*last_error_tinst_level
;
9583 /* We're starting to instantiate D; record the template instantiation context
9584 for diagnostics and to restore it later. */
9587 push_tinst_level (tree d
)
9589 return push_tinst_level_loc (d
, input_location
);
9592 /* We're starting to instantiate D; record the template instantiation context
9593 at LOC for diagnostics and to restore it later. */
9596 push_tinst_level_loc (tree d
, location_t loc
)
9598 struct tinst_level
*new_level
;
9600 if (tinst_depth
>= max_tinst_depth
)
9602 /* Tell error.c not to try to instantiate any templates. */
9604 fatal_error (input_location
,
9605 "template instantiation depth exceeds maximum of %d"
9606 " (use -ftemplate-depth= to increase the maximum)",
9611 /* If the current instantiation caused problems, don't let it instantiate
9612 anything else. Do allow deduction substitution and decls usable in
9613 constant expressions. */
9614 if (limit_bad_template_recursion (d
))
9617 /* When not -quiet, dump template instantiations other than functions, since
9618 announce_function will take care of those. */
9620 && TREE_CODE (d
) != TREE_LIST
9621 && TREE_CODE (d
) != FUNCTION_DECL
)
9622 fprintf (stderr
, " %s", decl_as_string (d
, TFF_DECL_SPECIFIERS
));
9624 new_level
= ggc_alloc
<tinst_level
> ();
9625 new_level
->decl
= d
;
9626 new_level
->locus
= loc
;
9627 new_level
->errors
= errorcount
+sorrycount
;
9628 new_level
->in_system_header_p
= in_system_header_at (input_location
);
9629 new_level
->next
= current_tinst_level
;
9630 current_tinst_level
= new_level
;
9633 if (GATHER_STATISTICS
&& (tinst_depth
> depth_reached
))
9634 depth_reached
= tinst_depth
;
9639 /* We're done instantiating this template; return to the instantiation
9643 pop_tinst_level (void)
9645 /* Restore the filename and line number stashed away when we started
9646 this instantiation. */
9647 input_location
= current_tinst_level
->locus
;
9648 current_tinst_level
= current_tinst_level
->next
;
9652 /* We're instantiating a deferred template; restore the template
9653 instantiation context in which the instantiation was requested, which
9654 is one step out from LEVEL. Return the corresponding DECL or TYPE. */
9657 reopen_tinst_level (struct tinst_level
*level
)
9659 struct tinst_level
*t
;
9662 for (t
= level
; t
; t
= t
->next
)
9665 current_tinst_level
= level
;
9667 if (current_tinst_level
)
9668 current_tinst_level
->errors
= errorcount
+sorrycount
;
9672 /* Returns the TINST_LEVEL which gives the original instantiation
9675 struct tinst_level
*
9676 outermost_tinst_level (void)
9678 struct tinst_level
*level
= current_tinst_level
;
9681 level
= level
->next
;
9685 /* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
9686 vector of template arguments, as for tsubst.
9688 Returns an appropriate tsubst'd friend declaration. */
9691 tsubst_friend_function (tree decl
, tree args
)
9695 if (TREE_CODE (decl
) == FUNCTION_DECL
9696 && DECL_TEMPLATE_INSTANTIATION (decl
)
9697 && TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
9698 /* This was a friend declared with an explicit template
9699 argument list, e.g.:
9703 to indicate that f was a template instantiation, not a new
9704 function declaration. Now, we have to figure out what
9705 instantiation of what template. */
9707 tree template_id
, arglist
, fns
;
9710 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (current_class_type
));
9712 /* Friend functions are looked up in the containing namespace scope.
9713 We must enter that scope, to avoid finding member functions of the
9714 current class with same name. */
9715 push_nested_namespace (ns
);
9716 fns
= tsubst_expr (DECL_TI_TEMPLATE (decl
), args
,
9717 tf_warning_or_error
, NULL_TREE
,
9718 /*integral_constant_expression_p=*/false);
9719 pop_nested_namespace (ns
);
9720 arglist
= tsubst (DECL_TI_ARGS (decl
), args
,
9721 tf_warning_or_error
, NULL_TREE
);
9722 template_id
= lookup_template_function (fns
, arglist
);
9724 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
9725 tmpl
= determine_specialization (template_id
, new_friend
,
9727 /*need_member_template=*/0,
9728 TREE_VEC_LENGTH (args
),
9730 return instantiate_template (tmpl
, new_args
, tf_error
);
9733 new_friend
= tsubst (decl
, args
, tf_warning_or_error
, NULL_TREE
);
9735 /* The NEW_FRIEND will look like an instantiation, to the
9736 compiler, but is not an instantiation from the point of view of
9737 the language. For example, we might have had:
9739 template <class T> struct S {
9740 template <class U> friend void f(T, U);
9743 Then, in S<int>, template <class U> void f(int, U) is not an
9744 instantiation of anything. */
9745 if (new_friend
== error_mark_node
)
9746 return error_mark_node
;
9748 DECL_USE_TEMPLATE (new_friend
) = 0;
9749 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
9751 DECL_USE_TEMPLATE (DECL_TEMPLATE_RESULT (new_friend
)) = 0;
9752 DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (new_friend
))
9753 = DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl
));
9756 /* The mangled name for the NEW_FRIEND is incorrect. The function
9757 is not a template instantiation and should not be mangled like
9758 one. Therefore, we forget the mangling here; we'll recompute it
9759 later if we need it. */
9760 if (TREE_CODE (new_friend
) != TEMPLATE_DECL
)
9762 SET_DECL_RTL (new_friend
, NULL
);
9763 SET_DECL_ASSEMBLER_NAME (new_friend
, NULL_TREE
);
9766 if (DECL_NAMESPACE_SCOPE_P (new_friend
))
9769 tree new_friend_template_info
;
9770 tree new_friend_result_template_info
;
9772 int new_friend_is_defn
;
9774 /* We must save some information from NEW_FRIEND before calling
9775 duplicate decls since that function will free NEW_FRIEND if
9777 new_friend_template_info
= DECL_TEMPLATE_INFO (new_friend
);
9778 new_friend_is_defn
=
9779 (DECL_INITIAL (DECL_TEMPLATE_RESULT
9780 (template_for_substitution (new_friend
)))
9782 if (TREE_CODE (new_friend
) == TEMPLATE_DECL
)
9784 /* This declaration is a `primary' template. */
9785 DECL_PRIMARY_TEMPLATE (new_friend
) = new_friend
;
9787 new_friend_result_template_info
9788 = DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (new_friend
));
9791 new_friend_result_template_info
= NULL_TREE
;
9793 /* Inside pushdecl_namespace_level, we will push into the
9794 current namespace. However, the friend function should go
9795 into the namespace of the template. */
9796 ns
= decl_namespace_context (new_friend
);
9797 push_nested_namespace (ns
);
9798 old_decl
= pushdecl_namespace_level (new_friend
, /*is_friend=*/true);
9799 pop_nested_namespace (ns
);
9801 if (old_decl
== error_mark_node
)
9802 return error_mark_node
;
9804 if (old_decl
!= new_friend
)
9806 /* This new friend declaration matched an existing
9807 declaration. For example, given:
9809 template <class T> void f(T);
9810 template <class U> class C {
9811 template <class T> friend void f(T) {}
9814 the friend declaration actually provides the definition
9815 of `f', once C has been instantiated for some type. So,
9816 old_decl will be the out-of-class template declaration,
9817 while new_friend is the in-class definition.
9819 But, if `f' was called before this point, the
9820 instantiation of `f' will have DECL_TI_ARGS corresponding
9821 to `T' but not to `U', references to which might appear
9822 in the definition of `f'. Previously, the most general
9823 template for an instantiation of `f' was the out-of-class
9824 version; now it is the in-class version. Therefore, we
9825 run through all specialization of `f', adding to their
9826 DECL_TI_ARGS appropriately. In particular, they need a
9827 new set of outer arguments, corresponding to the
9828 arguments for this class instantiation.
9830 The same situation can arise with something like this:
9833 template <class T> class C {
9837 when `C<int>' is instantiated. Now, `f(int)' is defined
9840 if (!new_friend_is_defn
)
9841 /* On the other hand, if the in-class declaration does
9842 *not* provide a definition, then we don't want to alter
9843 existing definitions. We can just leave everything
9848 tree new_template
= TI_TEMPLATE (new_friend_template_info
);
9849 tree new_args
= TI_ARGS (new_friend_template_info
);
9851 /* Overwrite whatever template info was there before, if
9852 any, with the new template information pertaining to
9854 DECL_TEMPLATE_INFO (old_decl
) = new_friend_template_info
;
9856 if (TREE_CODE (old_decl
) != TEMPLATE_DECL
)
9858 /* We should have called reregister_specialization in
9860 gcc_assert (retrieve_specialization (new_template
,
9864 /* Instantiate it if the global has already been used. */
9865 if (DECL_ODR_USED (old_decl
))
9866 instantiate_decl (old_decl
, /*defer_ok=*/true,
9867 /*expl_inst_class_mem_p=*/false);
9873 /* Indicate that the old function template is a partial
9875 DECL_TEMPLATE_INFO (DECL_TEMPLATE_RESULT (old_decl
))
9876 = new_friend_result_template_info
;
9878 gcc_assert (new_template
9879 == most_general_template (new_template
));
9880 gcc_assert (new_template
!= old_decl
);
9882 /* Reassign any specializations already in the hash table
9883 to the new more general template, and add the
9884 additional template args. */
9885 for (t
= DECL_TEMPLATE_INSTANTIATIONS (old_decl
);
9889 tree spec
= TREE_VALUE (t
);
9892 elt
.tmpl
= old_decl
;
9893 elt
.args
= DECL_TI_ARGS (spec
);
9894 elt
.spec
= NULL_TREE
;
9896 decl_specializations
->remove_elt (&elt
);
9899 = add_outermost_template_args (new_args
,
9900 DECL_TI_ARGS (spec
));
9902 register_specialization
9903 (spec
, new_template
, DECL_TI_ARGS (spec
), true, 0);
9906 DECL_TEMPLATE_INSTANTIATIONS (old_decl
) = NULL_TREE
;
9910 /* The information from NEW_FRIEND has been merged into OLD_DECL
9911 by duplicate_decls. */
9912 new_friend
= old_decl
;
9917 tree context
= DECL_CONTEXT (new_friend
);
9921 template <class T> class C {
9922 template <class U> friend void C1<U>::f (); // case 1
9923 friend void C2<T>::f (); // case 2
9925 we only need to make sure CONTEXT is a complete type for
9926 case 2. To distinguish between the two cases, we note that
9927 CONTEXT of case 1 remains dependent type after tsubst while
9928 this isn't true for case 2. */
9929 ++processing_template_decl
;
9930 dependent_p
= dependent_type_p (context
);
9931 --processing_template_decl
;
9934 && !complete_type_or_else (context
, NULL_TREE
))
9935 return error_mark_node
;
9937 if (COMPLETE_TYPE_P (context
))
9939 tree fn
= new_friend
;
9940 /* do_friend adds the TEMPLATE_DECL for any member friend
9941 template even if it isn't a member template, i.e.
9942 template <class T> friend A<T>::f();
9943 Look through it in that case. */
9944 if (TREE_CODE (fn
) == TEMPLATE_DECL
9945 && !PRIMARY_TEMPLATE_P (fn
))
9946 fn
= DECL_TEMPLATE_RESULT (fn
);
9947 /* Check to see that the declaration is really present, and,
9948 possibly obtain an improved declaration. */
9949 fn
= check_classfn (context
, fn
, NULL_TREE
);
9959 /* FRIEND_TMPL is a friend TEMPLATE_DECL. ARGS is the vector of
9960 template arguments, as for tsubst.
9962 Returns an appropriate tsubst'd friend type or error_mark_node on
9966 tsubst_friend_class (tree friend_tmpl
, tree args
)
9972 if (DECL_TEMPLATE_TEMPLATE_PARM_P (friend_tmpl
))
9974 tree t
= tsubst (TREE_TYPE (friend_tmpl
), args
, tf_none
, NULL_TREE
);
9975 return TREE_TYPE (t
);
9978 context
= CP_DECL_CONTEXT (friend_tmpl
);
9980 if (context
!= global_namespace
)
9982 if (TREE_CODE (context
) == NAMESPACE_DECL
)
9983 push_nested_namespace (context
);
9985 push_nested_class (tsubst (context
, args
, tf_none
, NULL_TREE
));
9988 /* Look for a class template declaration. We look for hidden names
9989 because two friend declarations of the same template are the
9990 same. For example, in:
9993 template <typename> friend class F;
9995 template <typename> struct B {
9996 template <typename> friend class F;
9999 both F templates are the same. */
10000 tmpl
= lookup_name_real (DECL_NAME (friend_tmpl
), 0, 0,
10001 /*block_p=*/true, 0, LOOKUP_HIDDEN
);
10003 /* But, if we don't find one, it might be because we're in a
10004 situation like this:
10012 Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
10013 for `S<int>', not the TEMPLATE_DECL. */
10014 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
10016 tmpl
= lookup_name_prefer_type (DECL_NAME (friend_tmpl
), 1);
10017 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
10020 if (tmpl
&& DECL_CLASS_TEMPLATE_P (tmpl
))
10022 /* The friend template has already been declared. Just
10023 check to see that the declarations match, and install any new
10024 default parameters. We must tsubst the default parameters,
10025 of course. We only need the innermost template parameters
10026 because that is all that redeclare_class_template will look
10028 if (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (friend_tmpl
))
10029 > TMPL_ARGS_DEPTH (args
))
10032 location_t saved_input_location
;
10033 parms
= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_tmpl
),
10034 args
, tf_warning_or_error
);
10036 saved_input_location
= input_location
;
10037 input_location
= DECL_SOURCE_LOCATION (friend_tmpl
);
10038 tree cons
= get_constraints (tmpl
);
10039 redeclare_class_template (TREE_TYPE (tmpl
), parms
, cons
);
10040 input_location
= saved_input_location
;
10044 friend_type
= TREE_TYPE (tmpl
);
10048 /* The friend template has not already been declared. In this
10049 case, the instantiation of the template class will cause the
10050 injection of this template into the global scope. */
10051 tmpl
= tsubst (friend_tmpl
, args
, tf_warning_or_error
, NULL_TREE
);
10052 if (tmpl
== error_mark_node
)
10053 return error_mark_node
;
10055 /* The new TMPL is not an instantiation of anything, so we
10056 forget its origins. We don't reset CLASSTYPE_TI_TEMPLATE for
10057 the new type because that is supposed to be the corresponding
10058 template decl, i.e., TMPL. */
10059 DECL_USE_TEMPLATE (tmpl
) = 0;
10060 DECL_TEMPLATE_INFO (tmpl
) = NULL_TREE
;
10061 CLASSTYPE_USE_TEMPLATE (TREE_TYPE (tmpl
)) = 0;
10062 CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
))
10063 = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (TREE_TYPE (tmpl
)));
10065 /* Inject this template into the global scope. */
10066 friend_type
= TREE_TYPE (pushdecl_top_level (tmpl
, true));
10069 if (context
!= global_namespace
)
10071 if (TREE_CODE (context
) == NAMESPACE_DECL
)
10072 pop_nested_namespace (context
);
10074 pop_nested_class ();
10077 return friend_type
;
10080 /* Returns zero if TYPE cannot be completed later due to circularity.
10081 Otherwise returns one. */
10084 can_complete_type_without_circularity (tree type
)
10086 if (type
== NULL_TREE
|| type
== error_mark_node
)
10088 else if (COMPLETE_TYPE_P (type
))
10090 else if (TREE_CODE (type
) == ARRAY_TYPE
)
10091 return can_complete_type_without_circularity (TREE_TYPE (type
));
10092 else if (CLASS_TYPE_P (type
)
10093 && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type
)))
10099 static tree
tsubst_omp_clauses (tree
, enum c_omp_region_type
, tree
,
10100 tsubst_flags_t
, tree
);
10102 /* Instantiate a single dependent attribute T (a TREE_LIST), and return either
10103 T or a new TREE_LIST, possibly a chain in the case of a pack expansion. */
10106 tsubst_attribute (tree t
, tree
*decl_p
, tree args
,
10107 tsubst_flags_t complain
, tree in_decl
)
10109 gcc_assert (ATTR_IS_DEPENDENT (t
));
10111 tree val
= TREE_VALUE (t
);
10112 if (val
== NULL_TREE
)
10113 /* Nothing to do. */;
10114 else if ((flag_openmp
|| flag_openmp_simd
|| flag_cilkplus
)
10115 && is_attribute_p ("omp declare simd",
10116 get_attribute_name (t
)))
10118 tree clauses
= TREE_VALUE (val
);
10119 clauses
= tsubst_omp_clauses (clauses
, C_ORT_OMP_DECLARE_SIMD
, args
,
10120 complain
, in_decl
);
10121 c_omp_declare_simd_clauses_to_decls (*decl_p
, clauses
);
10122 clauses
= finish_omp_clauses (clauses
, C_ORT_OMP_DECLARE_SIMD
);
10123 tree parms
= DECL_ARGUMENTS (*decl_p
);
10125 = c_omp_declare_simd_clauses_to_numbers (parms
, clauses
);
10127 val
= build_tree_list (NULL_TREE
, clauses
);
10131 /* If the first attribute argument is an identifier, don't
10132 pass it through tsubst. Attributes like mode, format,
10133 cleanup and several target specific attributes expect it
10135 else if (attribute_takes_identifier_p (get_attribute_name (t
)))
10138 = tsubst_expr (TREE_CHAIN (val
), args
, complain
, in_decl
,
10139 /*integral_constant_expression_p=*/false);
10140 if (chain
!= TREE_CHAIN (val
))
10141 val
= tree_cons (NULL_TREE
, TREE_VALUE (val
), chain
);
10143 else if (PACK_EXPANSION_P (val
))
10145 /* An attribute pack expansion. */
10146 tree purp
= TREE_PURPOSE (t
);
10147 tree pack
= tsubst_pack_expansion (val
, args
, complain
, in_decl
);
10148 if (pack
== error_mark_node
)
10149 return error_mark_node
;
10150 int len
= TREE_VEC_LENGTH (pack
);
10151 tree list
= NULL_TREE
;
10153 for (int i
= 0; i
< len
; ++i
)
10155 tree elt
= TREE_VEC_ELT (pack
, i
);
10156 *q
= build_tree_list (purp
, elt
);
10157 q
= &TREE_CHAIN (*q
);
10162 val
= tsubst_expr (val
, args
, complain
, in_decl
,
10163 /*integral_constant_expression_p=*/false);
10165 if (val
!= TREE_VALUE (t
))
10166 return build_tree_list (TREE_PURPOSE (t
), val
);
10170 /* Instantiate any dependent attributes in ATTRIBUTES, returning either it
10171 unchanged or a new TREE_LIST chain. */
10174 tsubst_attributes (tree attributes
, tree args
,
10175 tsubst_flags_t complain
, tree in_decl
)
10177 tree last_dep
= NULL_TREE
;
10179 for (tree t
= attributes
; t
; t
= TREE_CHAIN (t
))
10180 if (ATTR_IS_DEPENDENT (t
))
10183 attributes
= copy_list (attributes
);
10188 for (tree
*p
= &attributes
; *p
; )
10191 if (ATTR_IS_DEPENDENT (t
))
10193 tree subst
= tsubst_attribute (t
, NULL
, args
, complain
, in_decl
);
10198 p
= &TREE_CHAIN (*p
);
10200 *p
= TREE_CHAIN (t
);
10204 p
= &TREE_CHAIN (*p
);
10210 /* Apply any attributes which had to be deferred until instantiation
10211 time. DECL_P, ATTRIBUTES and ATTR_FLAGS are as cplus_decl_attributes;
10212 ARGS, COMPLAIN, IN_DECL are as tsubst. */
10215 apply_late_template_attributes (tree
*decl_p
, tree attributes
, int attr_flags
,
10216 tree args
, tsubst_flags_t complain
, tree in_decl
)
10218 tree last_dep
= NULL_TREE
;
10222 if (attributes
== NULL_TREE
)
10225 if (DECL_P (*decl_p
))
10227 if (TREE_TYPE (*decl_p
) == error_mark_node
)
10229 p
= &DECL_ATTRIBUTES (*decl_p
);
10230 /* DECL_ATTRIBUTES comes from copy_node in tsubst_decl, and is identical
10231 to our attributes parameter. */
10232 gcc_assert (*p
== attributes
);
10236 p
= &TYPE_ATTRIBUTES (*decl_p
);
10237 /* TYPE_ATTRIBUTES was set up (with abi_tag and may_alias) in
10238 lookup_template_class_1, and should be preserved. */
10239 gcc_assert (*p
!= attributes
);
10241 p
= &TREE_CHAIN (*p
);
10244 for (t
= attributes
; t
; t
= TREE_CHAIN (t
))
10245 if (ATTR_IS_DEPENDENT (t
))
10248 attributes
= copy_list (attributes
);
10255 tree late_attrs
= NULL_TREE
;
10256 tree
*q
= &late_attrs
;
10261 if (ATTR_IS_DEPENDENT (t
))
10263 *p
= TREE_CHAIN (t
);
10264 TREE_CHAIN (t
) = NULL_TREE
;
10265 *q
= tsubst_attribute (t
, decl_p
, args
, complain
, in_decl
);
10267 q
= &TREE_CHAIN (*q
);
10271 p
= &TREE_CHAIN (t
);
10274 cplus_decl_attributes (decl_p
, late_attrs
, attr_flags
);
10278 /* Perform (or defer) access check for typedefs that were referenced
10279 from within the template TMPL code.
10280 This is a subroutine of instantiate_decl and instantiate_class_template.
10281 TMPL is the template to consider and TARGS is the list of arguments of
10285 perform_typedefs_access_check (tree tmpl
, tree targs
)
10287 location_t saved_location
;
10289 qualified_typedef_usage_t
*iter
;
10292 || (!CLASS_TYPE_P (tmpl
)
10293 && TREE_CODE (tmpl
) != FUNCTION_DECL
))
10296 saved_location
= input_location
;
10297 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (tmpl
), i
, iter
)
10299 tree type_decl
= iter
->typedef_decl
;
10300 tree type_scope
= iter
->context
;
10302 if (!type_decl
|| !type_scope
|| !CLASS_TYPE_P (type_scope
))
10305 if (uses_template_parms (type_decl
))
10306 type_decl
= tsubst (type_decl
, targs
, tf_error
, NULL_TREE
);
10307 if (uses_template_parms (type_scope
))
10308 type_scope
= tsubst (type_scope
, targs
, tf_error
, NULL_TREE
);
10310 /* Make access check error messages point to the location
10311 of the use of the typedef. */
10312 input_location
= iter
->locus
;
10313 perform_or_defer_access_check (TYPE_BINFO (type_scope
),
10314 type_decl
, type_decl
,
10315 tf_warning_or_error
);
10317 input_location
= saved_location
;
10321 instantiate_class_template_1 (tree type
)
10323 tree templ
, args
, pattern
, t
, member
;
10327 unsigned int saved_maximum_field_alignment
;
10330 if (type
== error_mark_node
)
10331 return error_mark_node
;
10333 if (COMPLETE_OR_OPEN_TYPE_P (type
)
10334 || uses_template_parms (type
))
10337 /* Figure out which template is being instantiated. */
10338 templ
= most_general_template (CLASSTYPE_TI_TEMPLATE (type
));
10339 gcc_assert (TREE_CODE (templ
) == TEMPLATE_DECL
);
10341 /* Determine what specialization of the original template to
10343 t
= most_specialized_partial_spec (type
, tf_warning_or_error
);
10344 if (t
== error_mark_node
)
10346 TYPE_BEING_DEFINED (type
) = 1;
10347 return error_mark_node
;
10351 /* This TYPE is actually an instantiation of a partial
10352 specialization. We replace the innermost set of ARGS with
10353 the arguments appropriate for substitution. For example,
10356 template <class T> struct S {};
10357 template <class T> struct S<T*> {};
10359 and supposing that we are instantiating S<int*>, ARGS will
10360 presently be {int*} -- but we need {int}. */
10361 pattern
= TREE_TYPE (t
);
10362 args
= TREE_PURPOSE (t
);
10366 pattern
= TREE_TYPE (templ
);
10367 args
= CLASSTYPE_TI_ARGS (type
);
10370 /* If the template we're instantiating is incomplete, then clearly
10371 there's nothing we can do. */
10372 if (!COMPLETE_TYPE_P (pattern
))
10375 /* If we've recursively instantiated too many templates, stop. */
10376 if (! push_tinst_level (type
))
10379 /* Now we're really doing the instantiation. Mark the type as in
10380 the process of being defined. */
10381 TYPE_BEING_DEFINED (type
) = 1;
10383 /* We may be in the middle of deferred access check. Disable
10385 push_deferring_access_checks (dk_no_deferred
);
10387 int saved_unevaluated_operand
= cp_unevaluated_operand
;
10388 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
10390 fn_context
= decl_function_context (TYPE_MAIN_DECL (type
));
10391 /* Also avoid push_to_top_level for a lambda in an NSDMI. */
10392 if (!fn_context
&& LAMBDA_TYPE_P (type
) && TYPE_CLASS_SCOPE_P (type
))
10393 fn_context
= error_mark_node
;
10395 push_to_top_level ();
10398 cp_unevaluated_operand
= 0;
10399 c_inhibit_evaluation_warnings
= 0;
10401 /* Use #pragma pack from the template context. */
10402 saved_maximum_field_alignment
= maximum_field_alignment
;
10403 maximum_field_alignment
= TYPE_PRECISION (pattern
);
10405 SET_CLASSTYPE_INTERFACE_UNKNOWN (type
);
10407 /* Set the input location to the most specialized template definition.
10408 This is needed if tsubsting causes an error. */
10409 typedecl
= TYPE_MAIN_DECL (pattern
);
10410 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (type
)) =
10411 DECL_SOURCE_LOCATION (typedecl
);
10413 TYPE_PACKED (type
) = TYPE_PACKED (pattern
);
10414 SET_TYPE_ALIGN (type
, TYPE_ALIGN (pattern
));
10415 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (pattern
);
10416 CLASSTYPE_NON_AGGREGATE (type
) = CLASSTYPE_NON_AGGREGATE (pattern
);
10417 if (ANON_AGGR_TYPE_P (pattern
))
10418 SET_ANON_AGGR_TYPE_P (type
);
10419 if (CLASSTYPE_VISIBILITY_SPECIFIED (pattern
))
10421 CLASSTYPE_VISIBILITY_SPECIFIED (type
) = 1;
10422 CLASSTYPE_VISIBILITY (type
) = CLASSTYPE_VISIBILITY (pattern
);
10423 /* Adjust visibility for template arguments. */
10424 determine_visibility (TYPE_MAIN_DECL (type
));
10426 if (CLASS_TYPE_P (type
))
10427 CLASSTYPE_FINAL (type
) = CLASSTYPE_FINAL (pattern
);
10429 pbinfo
= TYPE_BINFO (pattern
);
10431 /* We should never instantiate a nested class before its enclosing
10432 class; we need to look up the nested class by name before we can
10433 instantiate it, and that lookup should instantiate the enclosing
10435 gcc_assert (!DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern
))
10436 || COMPLETE_OR_OPEN_TYPE_P (TYPE_CONTEXT (type
)));
10438 base_list
= NULL_TREE
;
10439 if (BINFO_N_BASE_BINFOS (pbinfo
))
10445 /* We must enter the scope containing the type, as that is where
10446 the accessibility of types named in dependent bases are
10448 pushed_scope
= push_scope (CP_TYPE_CONTEXT (type
));
10450 /* Substitute into each of the bases to determine the actual
10452 for (i
= 0; BINFO_BASE_ITERATE (pbinfo
, i
, pbase_binfo
); i
++)
10455 tree access
= BINFO_BASE_ACCESS (pbinfo
, i
);
10456 tree expanded_bases
= NULL_TREE
;
10459 if (PACK_EXPANSION_P (BINFO_TYPE (pbase_binfo
)))
10462 tsubst_pack_expansion (BINFO_TYPE (pbase_binfo
),
10463 args
, tf_error
, NULL_TREE
);
10464 if (expanded_bases
== error_mark_node
)
10467 len
= TREE_VEC_LENGTH (expanded_bases
);
10470 for (idx
= 0; idx
< len
; idx
++)
10472 if (expanded_bases
)
10473 /* Extract the already-expanded base class. */
10474 base
= TREE_VEC_ELT (expanded_bases
, idx
);
10476 /* Substitute to figure out the base class. */
10477 base
= tsubst (BINFO_TYPE (pbase_binfo
), args
, tf_error
,
10480 if (base
== error_mark_node
)
10483 base_list
= tree_cons (access
, base
, base_list
);
10484 if (BINFO_VIRTUAL_P (pbase_binfo
))
10485 TREE_TYPE (base_list
) = integer_type_node
;
10489 /* The list is now in reverse order; correct that. */
10490 base_list
= nreverse (base_list
);
10493 pop_scope (pushed_scope
);
10495 /* Now call xref_basetypes to set up all the base-class
10497 xref_basetypes (type
, base_list
);
10499 apply_late_template_attributes (&type
, TYPE_ATTRIBUTES (pattern
),
10500 (int) ATTR_FLAG_TYPE_IN_PLACE
,
10501 args
, tf_error
, NULL_TREE
);
10502 fixup_attribute_variants (type
);
10504 /* Now that our base classes are set up, enter the scope of the
10505 class, so that name lookups into base classes, etc. will work
10506 correctly. This is precisely analogous to what we do in
10507 begin_class_definition when defining an ordinary non-template
10508 class, except we also need to push the enclosing classes. */
10509 push_nested_class (type
);
10511 /* Now members are processed in the order of declaration. */
10512 for (member
= CLASSTYPE_DECL_LIST (pattern
);
10513 member
; member
= TREE_CHAIN (member
))
10515 tree t
= TREE_VALUE (member
);
10517 if (TREE_PURPOSE (member
))
10521 /* Build new CLASSTYPE_NESTED_UTDS. */
10524 bool class_template_p
;
10526 class_template_p
= (TREE_CODE (t
) != ENUMERAL_TYPE
10527 && TYPE_LANG_SPECIFIC (t
)
10528 && CLASSTYPE_IS_TEMPLATE (t
));
10529 /* If the member is a class template, then -- even after
10530 substitution -- there may be dependent types in the
10531 template argument list for the class. We increment
10532 PROCESSING_TEMPLATE_DECL so that dependent_type_p, as
10533 that function will assume that no types are dependent
10534 when outside of a template. */
10535 if (class_template_p
)
10536 ++processing_template_decl
;
10537 newtag
= tsubst (t
, args
, tf_error
, NULL_TREE
);
10538 if (class_template_p
)
10539 --processing_template_decl
;
10540 if (newtag
== error_mark_node
)
10543 if (TREE_CODE (newtag
) != ENUMERAL_TYPE
)
10545 tree name
= TYPE_IDENTIFIER (t
);
10547 if (class_template_p
)
10548 /* Unfortunately, lookup_template_class sets
10549 CLASSTYPE_IMPLICIT_INSTANTIATION for a partial
10550 instantiation (i.e., for the type of a member
10551 template class nested within a template class.)
10552 This behavior is required for
10553 maybe_process_partial_specialization to work
10554 correctly, but is not accurate in this case;
10555 the TAG is not an instantiation of anything.
10556 (The corresponding TEMPLATE_DECL is an
10557 instantiation, but the TYPE is not.) */
10558 CLASSTYPE_USE_TEMPLATE (newtag
) = 0;
10560 /* Now, we call pushtag to put this NEWTAG into the scope of
10561 TYPE. We first set up the IDENTIFIER_TYPE_VALUE to avoid
10562 pushtag calling push_template_decl. We don't have to do
10563 this for enums because it will already have been done in
10566 SET_IDENTIFIER_TYPE_VALUE (name
, newtag
);
10567 pushtag (name
, newtag
, /*tag_scope=*/ts_current
);
10570 else if (DECL_DECLARES_FUNCTION_P (t
))
10574 if (TREE_CODE (t
) == TEMPLATE_DECL
)
10575 ++processing_template_decl
;
10576 r
= tsubst (t
, args
, tf_error
, NULL_TREE
);
10577 if (TREE_CODE (t
) == TEMPLATE_DECL
)
10578 --processing_template_decl
;
10579 set_current_access_from_decl (r
);
10580 finish_member_declaration (r
);
10581 /* Instantiate members marked with attribute used. */
10582 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
10584 if (TREE_CODE (r
) == FUNCTION_DECL
10585 && DECL_OMP_DECLARE_REDUCTION_P (r
))
10586 cp_check_omp_declare_reduction (r
);
10588 else if (DECL_CLASS_TEMPLATE_P (t
)
10589 && LAMBDA_TYPE_P (TREE_TYPE (t
)))
10590 /* A closure type for a lambda in a default argument for a
10591 member template. Ignore it; it will be instantiated with
10592 the default argument. */;
10595 /* Build new TYPE_FIELDS. */
10596 if (TREE_CODE (t
) == STATIC_ASSERT
)
10600 ++c_inhibit_evaluation_warnings
;
10602 tsubst_expr (STATIC_ASSERT_CONDITION (t
), args
,
10603 tf_warning_or_error
, NULL_TREE
,
10604 /*integral_constant_expression_p=*/true);
10605 --c_inhibit_evaluation_warnings
;
10607 finish_static_assert (condition
,
10608 STATIC_ASSERT_MESSAGE (t
),
10609 STATIC_ASSERT_SOURCE_LOCATION (t
),
10610 /*member_p=*/true);
10612 else if (TREE_CODE (t
) != CONST_DECL
)
10615 tree vec
= NULL_TREE
;
10618 /* The file and line for this declaration, to
10619 assist in error message reporting. Since we
10620 called push_tinst_level above, we don't need to
10622 input_location
= DECL_SOURCE_LOCATION (t
);
10624 if (TREE_CODE (t
) == TEMPLATE_DECL
)
10625 ++processing_template_decl
;
10626 r
= tsubst (t
, args
, tf_warning_or_error
, NULL_TREE
);
10627 if (TREE_CODE (t
) == TEMPLATE_DECL
)
10628 --processing_template_decl
;
10630 if (TREE_CODE (r
) == TREE_VEC
)
10632 /* A capture pack became multiple fields. */
10634 len
= TREE_VEC_LENGTH (vec
);
10637 for (int i
= 0; i
< len
; ++i
)
10640 r
= TREE_VEC_ELT (vec
, i
);
10645 [t]he initialization (and any associated
10646 side-effects) of a static data member does
10647 not occur unless the static data member is
10648 itself used in a way that requires the
10649 definition of the static data member to
10652 Therefore, we do not substitute into the
10653 initialized for the static data member here. */
10654 finish_static_data_member_decl
10656 /*init=*/NULL_TREE
,
10657 /*init_const_expr_p=*/false,
10658 /*asmspec_tree=*/NULL_TREE
,
10660 /* Instantiate members marked with attribute used. */
10661 if (r
!= error_mark_node
&& DECL_PRESERVE_P (r
))
10664 else if (TREE_CODE (r
) == FIELD_DECL
)
10666 /* Determine whether R has a valid type and can be
10667 completed later. If R is invalid, then its type
10668 is replaced by error_mark_node. */
10669 tree rtype
= TREE_TYPE (r
);
10670 if (can_complete_type_without_circularity (rtype
))
10671 complete_type (rtype
);
10673 if (!complete_or_array_type_p (rtype
))
10675 /* If R's type couldn't be completed and
10676 it isn't a flexible array member (whose
10677 type is incomplete by definition) give
10679 cxx_incomplete_type_error (r
, rtype
);
10680 TREE_TYPE (r
) = error_mark_node
;
10684 /* If it is a TYPE_DECL for a class-scoped ENUMERAL_TYPE,
10685 such a thing will already have been added to the field
10686 list by tsubst_enum in finish_member_declaration in the
10687 CLASSTYPE_NESTED_UTDS case above. */
10688 if (!(TREE_CODE (r
) == TYPE_DECL
10689 && TREE_CODE (TREE_TYPE (r
)) == ENUMERAL_TYPE
10690 && DECL_ARTIFICIAL (r
)))
10692 set_current_access_from_decl (r
);
10693 finish_member_declaration (r
);
10701 if (TYPE_P (t
) || DECL_CLASS_TEMPLATE_P (t
)
10702 || DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
10704 /* Build new CLASSTYPE_FRIEND_CLASSES. */
10706 tree friend_type
= t
;
10707 bool adjust_processing_template_decl
= false;
10709 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
10711 /* template <class T> friend class C; */
10712 friend_type
= tsubst_friend_class (friend_type
, args
);
10713 adjust_processing_template_decl
= true;
10715 else if (TREE_CODE (friend_type
) == UNBOUND_CLASS_TEMPLATE
)
10717 /* template <class T> friend class C::D; */
10718 friend_type
= tsubst (friend_type
, args
,
10719 tf_warning_or_error
, NULL_TREE
);
10720 if (TREE_CODE (friend_type
) == TEMPLATE_DECL
)
10721 friend_type
= TREE_TYPE (friend_type
);
10722 adjust_processing_template_decl
= true;
10724 else if (TREE_CODE (friend_type
) == TYPENAME_TYPE
10725 || TREE_CODE (friend_type
) == TEMPLATE_TYPE_PARM
)
10727 /* This could be either
10731 when dependent_type_p is false or
10733 template <class U> friend class T::C;
10736 /* Bump processing_template_decl in case this is something like
10737 template <class T> friend struct A<T>::B. */
10738 ++processing_template_decl
;
10739 friend_type
= tsubst (friend_type
, args
,
10740 tf_warning_or_error
, NULL_TREE
);
10741 if (dependent_type_p (friend_type
))
10742 adjust_processing_template_decl
= true;
10743 --processing_template_decl
;
10745 else if (TREE_CODE (friend_type
) != BOUND_TEMPLATE_TEMPLATE_PARM
10746 && !CLASSTYPE_USE_TEMPLATE (friend_type
)
10747 && TYPE_HIDDEN_P (friend_type
))
10751 where C hasn't been declared yet. Let's lookup name
10752 from namespace scope directly, bypassing any name that
10753 come from dependent base class. */
10754 tree ns
= decl_namespace_context (TYPE_MAIN_DECL (friend_type
));
10756 /* The call to xref_tag_from_type does injection for friend
10758 push_nested_namespace (ns
);
10760 xref_tag_from_type (friend_type
, NULL_TREE
,
10761 /*tag_scope=*/ts_current
);
10762 pop_nested_namespace (ns
);
10764 else if (uses_template_parms (friend_type
))
10765 /* friend class C<T>; */
10766 friend_type
= tsubst (friend_type
, args
,
10767 tf_warning_or_error
, NULL_TREE
);
10772 where C is already declared or
10774 friend class C<int>;
10776 We don't have to do anything in these cases. */
10778 if (adjust_processing_template_decl
)
10779 /* Trick make_friend_class into realizing that the friend
10780 we're adding is a template, not an ordinary class. It's
10781 important that we use make_friend_class since it will
10782 perform some error-checking and output cross-reference
10784 ++processing_template_decl
;
10786 if (friend_type
!= error_mark_node
)
10787 make_friend_class (type
, friend_type
, /*complain=*/false);
10789 if (adjust_processing_template_decl
)
10790 --processing_template_decl
;
10794 /* Build new DECL_FRIENDLIST. */
10797 /* The file and line for this declaration, to
10798 assist in error message reporting. Since we
10799 called push_tinst_level above, we don't need to
10801 input_location
= DECL_SOURCE_LOCATION (t
);
10803 if (TREE_CODE (t
) == TEMPLATE_DECL
)
10805 ++processing_template_decl
;
10806 push_deferring_access_checks (dk_no_check
);
10809 r
= tsubst_friend_function (t
, args
);
10810 add_friend (type
, r
, /*complain=*/false);
10811 if (TREE_CODE (t
) == TEMPLATE_DECL
)
10813 pop_deferring_access_checks ();
10814 --processing_template_decl
;
10822 /* Restore these before substituting into the lambda capture
10824 cp_unevaluated_operand
= saved_unevaluated_operand
;
10825 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
10828 if (tree expr
= CLASSTYPE_LAMBDA_EXPR (type
))
10830 tree decl
= lambda_function (type
);
10833 if (cxx_dialect
>= cxx17
)
10834 CLASSTYPE_LITERAL_P (type
) = true;
10836 if (!DECL_TEMPLATE_INFO (decl
)
10837 || DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (decl
)) != decl
)
10839 /* Set function_depth to avoid garbage collection. */
10841 instantiate_decl (decl
, /*defer_ok=*/false, false);
10845 /* We need to instantiate the capture list from the template
10846 after we've instantiated the closure members, but before we
10847 consider adding the conversion op. Also keep any captures
10848 that may have been added during instantiation of the op(). */
10849 tree tmpl_expr
= CLASSTYPE_LAMBDA_EXPR (pattern
);
10851 = tsubst_copy_and_build (LAMBDA_EXPR_CAPTURE_LIST (tmpl_expr
),
10852 args
, tf_warning_or_error
, NULL_TREE
,
10855 LAMBDA_EXPR_CAPTURE_LIST (expr
)
10856 = chainon (tmpl_cap
, nreverse (LAMBDA_EXPR_CAPTURE_LIST (expr
)));
10858 maybe_add_lambda_conv_op (type
);
10861 gcc_assert (errorcount
);
10864 /* Set the file and line number information to whatever is given for
10865 the class itself. This puts error messages involving generated
10866 implicit functions at a predictable point, and the same point
10867 that would be used for non-template classes. */
10868 input_location
= DECL_SOURCE_LOCATION (typedecl
);
10870 unreverse_member_declarations (type
);
10871 finish_struct_1 (type
);
10872 TYPE_BEING_DEFINED (type
) = 0;
10874 /* We don't instantiate default arguments for member functions. 14.7.1:
10876 The implicit instantiation of a class template specialization causes
10877 the implicit instantiation of the declarations, but not of the
10878 definitions or default arguments, of the class member functions,
10879 member classes, static data members and member templates.... */
10881 /* Some typedefs referenced from within the template code need to be access
10882 checked at template instantiation time, i.e now. These types were
10883 added to the template at parsing time. Let's get those and perform
10884 the access checks then. */
10885 perform_typedefs_access_check (pattern
, args
);
10886 perform_deferred_access_checks (tf_warning_or_error
);
10887 pop_nested_class ();
10888 maximum_field_alignment
= saved_maximum_field_alignment
;
10890 pop_from_top_level ();
10891 pop_deferring_access_checks ();
10892 pop_tinst_level ();
10894 /* The vtable for a template class can be emitted in any translation
10895 unit in which the class is instantiated. When there is no key
10896 method, however, finish_struct_1 will already have added TYPE to
10897 the keyed_classes. */
10898 if (TYPE_CONTAINS_VPTR_P (type
) && CLASSTYPE_KEY_METHOD (type
))
10899 vec_safe_push (keyed_classes
, type
);
10904 /* Wrapper for instantiate_class_template_1. */
10907 instantiate_class_template (tree type
)
10910 timevar_push (TV_TEMPLATE_INST
);
10911 ret
= instantiate_class_template_1 (type
);
10912 timevar_pop (TV_TEMPLATE_INST
);
10917 tsubst_template_arg (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
10923 else if (TYPE_P (t
))
10924 r
= tsubst (t
, args
, complain
, in_decl
);
10927 if (!(complain
& tf_warning
))
10928 ++c_inhibit_evaluation_warnings
;
10929 r
= tsubst_expr (t
, args
, complain
, in_decl
,
10930 /*integral_constant_expression_p=*/true);
10931 if (!(complain
& tf_warning
))
10932 --c_inhibit_evaluation_warnings
;
10937 /* Given a function parameter pack TMPL_PARM and some function parameters
10938 instantiated from it at *SPEC_P, return a NONTYPE_ARGUMENT_PACK of them
10939 and set *SPEC_P to point at the next point in the list. */
10942 extract_fnparm_pack (tree tmpl_parm
, tree
*spec_p
)
10944 /* Collect all of the extra "packed" parameters into an
10947 tree argpack
= make_node (NONTYPE_ARGUMENT_PACK
);
10948 tree spec_parm
= *spec_p
;
10951 for (len
= 0; spec_parm
; ++len
, spec_parm
= TREE_CHAIN (spec_parm
))
10953 && !function_parameter_expanded_from_pack_p (spec_parm
, tmpl_parm
))
10956 /* Fill in PARMVEC and PARMTYPEVEC with all of the parameters. */
10957 parmvec
= make_tree_vec (len
);
10958 spec_parm
= *spec_p
;
10959 for (i
= 0; i
< len
; i
++, spec_parm
= DECL_CHAIN (spec_parm
))
10960 TREE_VEC_ELT (parmvec
, i
) = spec_parm
;
10962 /* Build the argument packs. */
10963 SET_ARGUMENT_PACK_ARGS (argpack
, parmvec
);
10964 *spec_p
= spec_parm
;
10969 /* Give a chain SPEC_PARM of PARM_DECLs, pack them into a
10970 NONTYPE_ARGUMENT_PACK. */
10973 make_fnparm_pack (tree spec_parm
)
10975 return extract_fnparm_pack (NULL_TREE
, &spec_parm
);
10978 /* Return 1 if the Ith element of the argument pack ARG_PACK is a
10979 pack expansion with no extra args, 2 if it has extra args, or 0
10980 if it is not a pack expansion. */
10983 argument_pack_element_is_expansion_p (tree arg_pack
, int i
)
10985 tree vec
= ARGUMENT_PACK_ARGS (arg_pack
);
10986 if (i
>= TREE_VEC_LENGTH (vec
))
10988 tree elt
= TREE_VEC_ELT (vec
, i
);
10990 /* A decl pack is itself an expansion. */
10991 elt
= TREE_TYPE (elt
);
10992 if (!PACK_EXPANSION_P (elt
))
10994 if (PACK_EXPANSION_EXTRA_ARGS (elt
))
11000 /* Creates and return an ARGUMENT_PACK_SELECT tree node. */
11003 make_argument_pack_select (tree arg_pack
, unsigned index
)
11005 tree aps
= make_node (ARGUMENT_PACK_SELECT
);
11007 ARGUMENT_PACK_SELECT_FROM_PACK (aps
) = arg_pack
;
11008 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
11013 /* This is a subroutine of tsubst_pack_expansion.
11015 It returns TRUE if we need to use the PACK_EXPANSION_EXTRA_ARGS
11016 mechanism to store the (non complete list of) arguments of the
11017 substitution and return a non substituted pack expansion, in order
11018 to wait for when we have enough arguments to really perform the
11022 use_pack_expansion_extra_args_p (tree parm_packs
,
11024 bool has_empty_arg
)
11026 /* If one pack has an expansion and another pack has a normal
11027 argument or if one pack has an empty argument and an another
11028 one hasn't then tsubst_pack_expansion cannot perform the
11029 substitution and need to fall back on the
11030 PACK_EXPANSION_EXTRA mechanism. */
11031 if (parm_packs
== NULL_TREE
)
11033 else if (has_empty_arg
)
11036 bool has_expansion_arg
= false;
11037 for (int i
= 0 ; i
< arg_pack_len
; ++i
)
11039 bool has_non_expansion_arg
= false;
11040 for (tree parm_pack
= parm_packs
;
11042 parm_pack
= TREE_CHAIN (parm_pack
))
11044 tree arg
= TREE_VALUE (parm_pack
);
11046 int exp
= argument_pack_element_is_expansion_p (arg
, i
);
11048 /* We can't substitute a pack expansion with extra args into
11052 has_expansion_arg
= true;
11054 has_non_expansion_arg
= true;
11057 if (has_expansion_arg
&& has_non_expansion_arg
)
11063 /* [temp.variadic]/6 says that:
11065 The instantiation of a pack expansion [...]
11066 produces a list E1,E2, ..., En, where N is the number of elements
11067 in the pack expansion parameters.
11069 This subroutine of tsubst_pack_expansion produces one of these Ei.
11071 PATTERN is the pattern of the pack expansion. PARM_PACKS is a
11072 TREE_LIST in which each TREE_PURPOSE is a parameter pack of
11073 PATTERN, and each TREE_VALUE is its corresponding argument pack.
11074 INDEX is the index 'i' of the element Ei to produce. ARGS,
11075 COMPLAIN, and IN_DECL are the same parameters as for the
11076 tsubst_pack_expansion function.
11078 The function returns the resulting Ei upon successful completion,
11079 or error_mark_node.
11081 Note that this function possibly modifies the ARGS parameter, so
11082 it's the responsibility of the caller to restore it. */
11085 gen_elem_of_pack_expansion_instantiation (tree pattern
,
11088 tree args
/* This parm gets
11090 tsubst_flags_t complain
,
11094 bool ith_elem_is_expansion
= false;
11096 /* For each parameter pack, change the substitution of the parameter
11097 pack to the ith argument in its argument pack, then expand the
11099 for (tree pack
= parm_packs
; pack
; pack
= TREE_CHAIN (pack
))
11101 tree parm
= TREE_PURPOSE (pack
);
11102 tree arg_pack
= TREE_VALUE (pack
);
11103 tree aps
; /* instance of ARGUMENT_PACK_SELECT. */
11105 ith_elem_is_expansion
|=
11106 argument_pack_element_is_expansion_p (arg_pack
, index
);
11108 /* Select the Ith argument from the pack. */
11109 if (TREE_CODE (parm
) == PARM_DECL
11110 || TREE_CODE (parm
) == FIELD_DECL
)
11114 aps
= make_argument_pack_select (arg_pack
, index
);
11115 if (!mark_used (parm
, complain
) && !(complain
& tf_error
))
11116 return error_mark_node
;
11117 register_local_specialization (aps
, parm
);
11120 aps
= retrieve_local_specialization (parm
);
11125 template_parm_level_and_index (parm
, &level
, &idx
);
11129 aps
= make_argument_pack_select (arg_pack
, index
);
11130 /* Update the corresponding argument. */
11131 TMPL_ARG (args
, level
, idx
) = aps
;
11134 /* Re-use the ARGUMENT_PACK_SELECT. */
11135 aps
= TMPL_ARG (args
, level
, idx
);
11137 ARGUMENT_PACK_SELECT_INDEX (aps
) = index
;
11140 /* Substitute into the PATTERN with the (possibly altered)
11142 if (pattern
== in_decl
)
11143 /* Expanding a fixed parameter pack from
11144 coerce_template_parameter_pack. */
11145 t
= tsubst_decl (pattern
, args
, complain
);
11146 else if (pattern
== error_mark_node
)
11147 t
= error_mark_node
;
11148 else if (constraint_p (pattern
))
11150 if (processing_template_decl
)
11151 t
= tsubst_constraint (pattern
, args
, complain
, in_decl
);
11153 t
= (constraints_satisfied_p (pattern
, args
)
11154 ? boolean_true_node
: boolean_false_node
);
11156 else if (!TYPE_P (pattern
))
11157 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
11158 /*integral_constant_expression_p=*/false);
11160 t
= tsubst (pattern
, args
, complain
, in_decl
);
11162 /* If the Ith argument pack element is a pack expansion, then
11163 the Ith element resulting from the substituting is going to
11164 be a pack expansion as well. */
11165 if (ith_elem_is_expansion
)
11166 t
= make_pack_expansion (t
);
11171 /* When the unexpanded parameter pack in a fold expression expands to an empty
11172 sequence, the value of the expression is as follows; the program is
11173 ill-formed if the operator is not listed in this table.
11180 expand_empty_fold (tree t
, tsubst_flags_t complain
)
11182 tree_code code
= (tree_code
)TREE_INT_CST_LOW (TREE_OPERAND (t
, 0));
11183 if (!FOLD_EXPR_MODIFY_P (t
))
11186 case TRUTH_ANDIF_EXPR
:
11187 return boolean_true_node
;
11188 case TRUTH_ORIF_EXPR
:
11189 return boolean_false_node
;
11190 case COMPOUND_EXPR
:
11196 if (complain
& tf_error
)
11197 error_at (location_of (t
),
11198 "fold of empty expansion over %O", code
);
11199 return error_mark_node
;
11202 /* Given a fold-expression T and a current LEFT and RIGHT operand,
11203 form an expression that combines the two terms using the
11207 fold_expression (tree t
, tree left
, tree right
, tsubst_flags_t complain
)
11209 tree op
= FOLD_EXPR_OP (t
);
11210 tree_code code
= (tree_code
)TREE_INT_CST_LOW (op
);
11212 // Handle compound assignment operators.
11213 if (FOLD_EXPR_MODIFY_P (t
))
11214 return build_x_modify_expr (input_location
, left
, code
, right
, complain
);
11218 case COMPOUND_EXPR
:
11219 return build_x_compound_expr (input_location
, left
, right
, complain
);
11221 return build_m_component_ref (left
, right
, complain
);
11223 return build_x_binary_op (input_location
, code
,
11224 left
, TREE_CODE (left
),
11225 right
, TREE_CODE (right
),
11231 /* Substitute ARGS into the pack of a fold expression T. */
11234 tsubst_fold_expr_pack (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11236 return tsubst_pack_expansion (FOLD_EXPR_PACK (t
), args
, complain
, in_decl
);
11239 /* Substitute ARGS into the pack of a fold expression T. */
11242 tsubst_fold_expr_init (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11244 return tsubst_expr (FOLD_EXPR_INIT (t
), args
, complain
, in_decl
, false);
11247 /* Expand a PACK of arguments into a grouped as left fold.
11248 Given a pack containing elements A0, A1, ..., An and an
11249 operator @, this builds the expression:
11251 ((A0 @ A1) @ A2) ... @ An
11253 Note that PACK must not be empty.
11255 The operator is defined by the original fold expression T. */
11258 expand_left_fold (tree t
, tree pack
, tsubst_flags_t complain
)
11260 tree left
= TREE_VEC_ELT (pack
, 0);
11261 for (int i
= 1; i
< TREE_VEC_LENGTH (pack
); ++i
)
11263 tree right
= TREE_VEC_ELT (pack
, i
);
11264 left
= fold_expression (t
, left
, right
, complain
);
11269 /* Substitute into a unary left fold expression. */
11272 tsubst_unary_left_fold (tree t
, tree args
, tsubst_flags_t complain
,
11275 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
11276 if (pack
== error_mark_node
)
11277 return error_mark_node
;
11278 if (PACK_EXPANSION_P (pack
))
11280 tree r
= copy_node (t
);
11281 FOLD_EXPR_PACK (r
) = pack
;
11284 if (TREE_VEC_LENGTH (pack
) == 0)
11285 return expand_empty_fold (t
, complain
);
11287 return expand_left_fold (t
, pack
, complain
);
11290 /* Substitute into a binary left fold expression.
11292 Do ths by building a single (non-empty) vector of argumnts and
11293 building the expression from those elements. */
11296 tsubst_binary_left_fold (tree t
, tree args
, tsubst_flags_t complain
,
11299 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
11300 if (pack
== error_mark_node
)
11301 return error_mark_node
;
11302 tree init
= tsubst_fold_expr_init (t
, args
, complain
, in_decl
);
11303 if (init
== error_mark_node
)
11304 return error_mark_node
;
11306 if (PACK_EXPANSION_P (pack
))
11308 tree r
= copy_node (t
);
11309 FOLD_EXPR_PACK (r
) = pack
;
11310 FOLD_EXPR_INIT (r
) = init
;
11314 tree vec
= make_tree_vec (TREE_VEC_LENGTH (pack
) + 1);
11315 TREE_VEC_ELT (vec
, 0) = init
;
11316 for (int i
= 0; i
< TREE_VEC_LENGTH (pack
); ++i
)
11317 TREE_VEC_ELT (vec
, i
+ 1) = TREE_VEC_ELT (pack
, i
);
11319 return expand_left_fold (t
, vec
, complain
);
11322 /* Expand a PACK of arguments into a grouped as right fold.
11323 Given a pack containing elementns A0, A1, ..., and an
11324 operator @, this builds the expression:
11326 A0@ ... (An-2 @ (An-1 @ An))
11328 Note that PACK must not be empty.
11330 The operator is defined by the original fold expression T. */
11333 expand_right_fold (tree t
, tree pack
, tsubst_flags_t complain
)
11335 // Build the expression.
11336 int n
= TREE_VEC_LENGTH (pack
);
11337 tree right
= TREE_VEC_ELT (pack
, n
- 1);
11338 for (--n
; n
!= 0; --n
)
11340 tree left
= TREE_VEC_ELT (pack
, n
- 1);
11341 right
= fold_expression (t
, left
, right
, complain
);
11346 /* Substitute into a unary right fold expression. */
11349 tsubst_unary_right_fold (tree t
, tree args
, tsubst_flags_t complain
,
11352 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
11353 if (pack
== error_mark_node
)
11354 return error_mark_node
;
11355 if (PACK_EXPANSION_P (pack
))
11357 tree r
= copy_node (t
);
11358 FOLD_EXPR_PACK (r
) = pack
;
11361 if (TREE_VEC_LENGTH (pack
) == 0)
11362 return expand_empty_fold (t
, complain
);
11364 return expand_right_fold (t
, pack
, complain
);
11367 /* Substitute into a binary right fold expression.
11369 Do ths by building a single (non-empty) vector of arguments and
11370 building the expression from those elements. */
11373 tsubst_binary_right_fold (tree t
, tree args
, tsubst_flags_t complain
,
11376 tree pack
= tsubst_fold_expr_pack (t
, args
, complain
, in_decl
);
11377 if (pack
== error_mark_node
)
11378 return error_mark_node
;
11379 tree init
= tsubst_fold_expr_init (t
, args
, complain
, in_decl
);
11380 if (init
== error_mark_node
)
11381 return error_mark_node
;
11383 if (PACK_EXPANSION_P (pack
))
11385 tree r
= copy_node (t
);
11386 FOLD_EXPR_PACK (r
) = pack
;
11387 FOLD_EXPR_INIT (r
) = init
;
11391 int n
= TREE_VEC_LENGTH (pack
);
11392 tree vec
= make_tree_vec (n
+ 1);
11393 for (int i
= 0; i
< n
; ++i
)
11394 TREE_VEC_ELT (vec
, i
) = TREE_VEC_ELT (pack
, i
);
11395 TREE_VEC_ELT (vec
, n
) = init
;
11397 return expand_right_fold (t
, vec
, complain
);
11401 /* Substitute ARGS into T, which is an pack expansion
11402 (i.e. TYPE_PACK_EXPANSION or EXPR_PACK_EXPANSION). Returns a
11403 TREE_VEC with the substituted arguments, a PACK_EXPANSION_* node
11404 (if only a partial substitution could be performed) or
11405 ERROR_MARK_NODE if there was an error. */
11407 tsubst_pack_expansion (tree t
, tree args
, tsubst_flags_t complain
,
11411 tree pack
, packs
= NULL_TREE
;
11412 bool unsubstituted_packs
= false;
11415 hash_map
<tree
, tree
> *saved_local_specializations
= NULL
;
11416 bool need_local_specializations
= false;
11419 gcc_assert (PACK_EXPANSION_P (t
));
11420 pattern
= PACK_EXPANSION_PATTERN (t
);
11422 /* Add in any args remembered from an earlier partial instantiation. */
11423 args
= add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (t
), args
);
11425 levels
= TMPL_ARGS_DEPTH (args
);
11427 /* Determine the argument packs that will instantiate the parameter
11428 packs used in the expansion expression. While we're at it,
11429 compute the number of arguments to be expanded and make sure it
11431 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (t
); pack
;
11432 pack
= TREE_CHAIN (pack
))
11434 tree parm_pack
= TREE_VALUE (pack
);
11435 tree arg_pack
= NULL_TREE
;
11436 tree orig_arg
= NULL_TREE
;
11439 if (TREE_CODE (parm_pack
) == BASES
)
11441 gcc_assert (parm_pack
== pattern
);
11442 if (BASES_DIRECT (parm_pack
))
11443 return calculate_direct_bases (tsubst_expr (BASES_TYPE (parm_pack
),
11444 args
, complain
, in_decl
, false));
11446 return calculate_bases (tsubst_expr (BASES_TYPE (parm_pack
),
11447 args
, complain
, in_decl
, false));
11449 else if (builtin_pack_call_p (parm_pack
))
11451 /* ??? Support use in other patterns. */
11452 gcc_assert (parm_pack
== pattern
);
11453 return expand_builtin_pack_call (parm_pack
, args
,
11454 complain
, in_decl
);
11456 else if (TREE_CODE (parm_pack
) == PARM_DECL
)
11458 /* We know we have correct local_specializations if this
11459 expansion is at function scope, or if we're dealing with a
11460 local parameter in a requires expression; for the latter,
11461 tsubst_requires_expr set it up appropriately. */
11462 if (PACK_EXPANSION_LOCAL_P (t
) || CONSTRAINT_VAR_P (parm_pack
))
11463 arg_pack
= retrieve_local_specialization (parm_pack
);
11465 /* We can't rely on local_specializations for a parameter
11466 name used later in a function declaration (such as in a
11467 late-specified return type). Even if it exists, it might
11468 have the wrong value for a recursive call. */
11469 need_local_specializations
= true;
11473 /* This parameter pack was used in an unevaluated context. Just
11474 make a dummy decl, since it's only used for its type. */
11475 arg_pack
= tsubst_decl (parm_pack
, args
, complain
);
11476 if (arg_pack
&& DECL_PACK_P (arg_pack
))
11477 /* Partial instantiation of the parm_pack, we can't build
11478 up an argument pack yet. */
11479 arg_pack
= NULL_TREE
;
11481 arg_pack
= make_fnparm_pack (arg_pack
);
11484 else if (TREE_CODE (parm_pack
) == FIELD_DECL
)
11485 arg_pack
= tsubst_copy (parm_pack
, args
, complain
, in_decl
);
11489 template_parm_level_and_index (parm_pack
, &level
, &idx
);
11491 if (level
<= levels
)
11492 arg_pack
= TMPL_ARG (args
, level
, idx
);
11495 orig_arg
= arg_pack
;
11496 if (arg_pack
&& TREE_CODE (arg_pack
) == ARGUMENT_PACK_SELECT
)
11497 arg_pack
= ARGUMENT_PACK_SELECT_FROM_PACK (arg_pack
);
11499 if (arg_pack
&& !ARGUMENT_PACK_P (arg_pack
))
11500 /* This can only happen if we forget to expand an argument
11501 pack somewhere else. Just return an error, silently. */
11503 result
= make_tree_vec (1);
11504 TREE_VEC_ELT (result
, 0) = error_mark_node
;
11511 TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg_pack
));
11513 /* Don't bother trying to do a partial substitution with
11514 incomplete packs; we'll try again after deduction. */
11515 if (ARGUMENT_PACK_INCOMPLETE_P (arg_pack
))
11520 else if (len
!= my_len
)
11522 if (!(complain
& tf_error
))
11523 /* Fail quietly. */;
11524 else if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
)
11525 error ("mismatched argument pack lengths while expanding %qT",
11528 error ("mismatched argument pack lengths while expanding %qE",
11530 return error_mark_node
;
11533 /* Keep track of the parameter packs and their corresponding
11535 packs
= tree_cons (parm_pack
, arg_pack
, packs
);
11536 TREE_TYPE (packs
) = orig_arg
;
11540 /* We can't substitute for this parameter pack. We use a flag as
11541 well as the missing_level counter because function parameter
11542 packs don't have a level. */
11543 gcc_assert (processing_template_decl
);
11544 unsubstituted_packs
= true;
11548 /* If the expansion is just T..., return the matching argument pack, unless
11549 we need to call convert_from_reference on all the elements. This is an
11550 important optimization; see c++/68422. */
11551 if (!unsubstituted_packs
11552 && TREE_PURPOSE (packs
) == pattern
)
11554 tree args
= ARGUMENT_PACK_ARGS (TREE_VALUE (packs
));
11555 /* Types need no adjustment, nor does sizeof..., and if we still have
11556 some pack expansion args we won't do anything yet. */
11557 if (TREE_CODE (t
) == TYPE_PACK_EXPANSION
11558 || PACK_EXPANSION_SIZEOF_P (t
)
11559 || pack_expansion_args_count (args
))
11561 /* Also optimize expression pack expansions if we can tell that the
11562 elements won't have reference type. */
11563 tree type
= TREE_TYPE (pattern
);
11564 if (type
&& TREE_CODE (type
) != REFERENCE_TYPE
11565 && !PACK_EXPANSION_P (type
)
11566 && !WILDCARD_TYPE_P (type
))
11568 /* Otherwise use the normal path so we get convert_from_reference. */
11571 /* We cannot expand this expansion expression, because we don't have
11572 all of the argument packs we need. */
11573 if (use_pack_expansion_extra_args_p (packs
, len
, unsubstituted_packs
))
11575 /* We got some full packs, but we can't substitute them in until we
11576 have values for all the packs. So remember these until then. */
11578 t
= make_pack_expansion (pattern
);
11579 PACK_EXPANSION_EXTRA_ARGS (t
) = args
;
11582 else if (unsubstituted_packs
)
11584 /* There were no real arguments, we're just replacing a parameter
11585 pack with another version of itself. Substitute into the
11586 pattern and return a PACK_EXPANSION_*. The caller will need to
11588 if (TREE_CODE (t
) == EXPR_PACK_EXPANSION
)
11589 t
= tsubst_expr (pattern
, args
, complain
, in_decl
,
11590 /*integral_constant_expression_p=*/false);
11592 t
= tsubst (pattern
, args
, complain
, in_decl
);
11593 t
= make_pack_expansion (t
);
11597 gcc_assert (len
>= 0);
11599 if (need_local_specializations
)
11601 /* We're in a late-specified return type, so create our own local
11602 specializations map; the current map is either NULL or (in the
11603 case of recursive unification) might have bindings that we don't
11604 want to use or alter. */
11605 saved_local_specializations
= local_specializations
;
11606 local_specializations
= new hash_map
<tree
, tree
>;
11609 /* For each argument in each argument pack, substitute into the
11611 result
= make_tree_vec (len
);
11612 tree elem_args
= copy_template_args (args
);
11613 for (i
= 0; i
< len
; ++i
)
11615 t
= gen_elem_of_pack_expansion_instantiation (pattern
, packs
,
11617 elem_args
, complain
,
11619 TREE_VEC_ELT (result
, i
) = t
;
11620 if (t
== error_mark_node
)
11622 result
= error_mark_node
;
11627 /* Update ARGS to restore the substitution from parameter packs to
11628 their argument packs. */
11629 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
11631 tree parm
= TREE_PURPOSE (pack
);
11633 if (TREE_CODE (parm
) == PARM_DECL
11634 || TREE_CODE (parm
) == FIELD_DECL
)
11635 register_local_specialization (TREE_TYPE (pack
), parm
);
11640 if (TREE_VALUE (pack
) == NULL_TREE
)
11643 template_parm_level_and_index (parm
, &level
, &idx
);
11645 /* Update the corresponding argument. */
11646 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
11647 TREE_VEC_ELT (TREE_VEC_ELT (args
, level
-1 ), idx
) =
11650 TREE_VEC_ELT (args
, idx
) = TREE_TYPE (pack
);
11654 if (need_local_specializations
)
11656 delete local_specializations
;
11657 local_specializations
= saved_local_specializations
;
11660 /* If the dependent pack arguments were such that we end up with only a
11661 single pack expansion again, there's no need to keep it in a TREE_VEC. */
11662 if (len
== 1 && TREE_CODE (result
) == TREE_VEC
11663 && PACK_EXPANSION_P (TREE_VEC_ELT (result
, 0)))
11664 return TREE_VEC_ELT (result
, 0);
11669 /* Given PARM_DECL PARM, find the corresponding PARM_DECL in the template
11670 TMPL. We do this using DECL_PARM_INDEX, which should work even with
11671 parameter packs; all parms generated from a function parameter pack will
11672 have the same DECL_PARM_INDEX. */
11675 get_pattern_parm (tree parm
, tree tmpl
)
11677 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
11680 if (DECL_ARTIFICIAL (parm
))
11682 for (patparm
= DECL_ARGUMENTS (pattern
);
11683 patparm
; patparm
= DECL_CHAIN (patparm
))
11684 if (DECL_ARTIFICIAL (patparm
)
11685 && DECL_NAME (parm
) == DECL_NAME (patparm
))
11690 patparm
= FUNCTION_FIRST_USER_PARM (DECL_TEMPLATE_RESULT (tmpl
));
11691 patparm
= chain_index (DECL_PARM_INDEX (parm
)-1, patparm
);
11692 gcc_assert (DECL_PARM_INDEX (patparm
)
11693 == DECL_PARM_INDEX (parm
));
11699 /* Make an argument pack out of the TREE_VEC VEC. */
11702 make_argument_pack (tree vec
)
11705 tree elt
= TREE_VEC_ELT (vec
, 0);
11707 pack
= cxx_make_type (TYPE_ARGUMENT_PACK
);
11710 pack
= make_node (NONTYPE_ARGUMENT_PACK
);
11711 TREE_CONSTANT (pack
) = 1;
11713 SET_ARGUMENT_PACK_ARGS (pack
, vec
);
11717 /* Return an exact copy of template args T that can be modified
11721 copy_template_args (tree t
)
11723 if (t
== error_mark_node
)
11726 int len
= TREE_VEC_LENGTH (t
);
11727 tree new_vec
= make_tree_vec (len
);
11729 for (int i
= 0; i
< len
; ++i
)
11731 tree elt
= TREE_VEC_ELT (t
, i
);
11732 if (elt
&& TREE_CODE (elt
) == TREE_VEC
)
11733 elt
= copy_template_args (elt
);
11734 TREE_VEC_ELT (new_vec
, i
) = elt
;
11737 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_vec
)
11738 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
11743 /* Substitute ARGS into the vector or list of template arguments T. */
11746 tsubst_template_args (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
11749 int len
, need_new
= 0, i
, expanded_len_adjust
= 0, out
;
11752 if (t
== error_mark_node
)
11753 return error_mark_node
;
11755 len
= TREE_VEC_LENGTH (t
);
11756 elts
= XALLOCAVEC (tree
, len
);
11758 for (i
= 0; i
< len
; i
++)
11760 tree orig_arg
= TREE_VEC_ELT (t
, i
);
11763 if (TREE_CODE (orig_arg
) == TREE_VEC
)
11764 new_arg
= tsubst_template_args (orig_arg
, args
, complain
, in_decl
);
11765 else if (PACK_EXPANSION_P (orig_arg
))
11767 /* Substitute into an expansion expression. */
11768 new_arg
= tsubst_pack_expansion (orig_arg
, args
, complain
, in_decl
);
11770 if (TREE_CODE (new_arg
) == TREE_VEC
)
11771 /* Add to the expanded length adjustment the number of
11772 expanded arguments. We subtract one from this
11773 measurement, because the argument pack expression
11774 itself is already counted as 1 in
11775 LEN. EXPANDED_LEN_ADJUST can actually be negative, if
11776 the argument pack is empty. */
11777 expanded_len_adjust
+= TREE_VEC_LENGTH (new_arg
) - 1;
11779 else if (ARGUMENT_PACK_P (orig_arg
))
11781 /* Substitute into each of the arguments. */
11782 new_arg
= TYPE_P (orig_arg
)
11783 ? cxx_make_type (TREE_CODE (orig_arg
))
11784 : make_node (TREE_CODE (orig_arg
));
11786 tree pack_args
= tsubst_template_args (ARGUMENT_PACK_ARGS (orig_arg
),
11787 args
, complain
, in_decl
);
11788 if (pack_args
== error_mark_node
)
11789 new_arg
= error_mark_node
;
11791 SET_ARGUMENT_PACK_ARGS (new_arg
, pack_args
);
11793 if (TREE_CODE (new_arg
) == NONTYPE_ARGUMENT_PACK
)
11794 TREE_CONSTANT (new_arg
) = TREE_CONSTANT (orig_arg
);
11797 new_arg
= tsubst_template_arg (orig_arg
, args
, complain
, in_decl
);
11799 if (new_arg
== error_mark_node
)
11800 return error_mark_node
;
11803 if (new_arg
!= orig_arg
)
11810 /* Make space for the expanded arguments coming from template
11812 t
= make_tree_vec (len
+ expanded_len_adjust
);
11813 /* ORIG_T can contain TREE_VECs. That happens if ORIG_T contains the
11814 arguments for a member template.
11815 In that case each TREE_VEC in ORIG_T represents a level of template
11816 arguments, and ORIG_T won't carry any non defaulted argument count.
11817 It will rather be the nested TREE_VECs that will carry one.
11818 In other words, ORIG_T carries a non defaulted argument count only
11819 if it doesn't contain any nested TREE_VEC. */
11820 if (NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
))
11822 int count
= GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (orig_t
);
11823 count
+= expanded_len_adjust
;
11824 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
, count
);
11826 for (i
= 0, out
= 0; i
< len
; i
++)
11828 if ((PACK_EXPANSION_P (TREE_VEC_ELT (orig_t
, i
))
11829 || ARGUMENT_PACK_P (TREE_VEC_ELT (orig_t
, i
)))
11830 && TREE_CODE (elts
[i
]) == TREE_VEC
)
11834 /* Now expand the template argument pack "in place". */
11835 for (idx
= 0; idx
< TREE_VEC_LENGTH (elts
[i
]); idx
++, out
++)
11836 TREE_VEC_ELT (t
, out
) = TREE_VEC_ELT (elts
[i
], idx
);
11840 TREE_VEC_ELT (t
, out
) = elts
[i
];
11848 /* Substitute ARGS into one level PARMS of template parameters. */
11851 tsubst_template_parms_level (tree parms
, tree args
, tsubst_flags_t complain
)
11853 if (parms
== error_mark_node
)
11854 return error_mark_node
;
11856 tree new_vec
= make_tree_vec (TREE_VEC_LENGTH (parms
));
11858 for (int i
= 0; i
< TREE_VEC_LENGTH (new_vec
); ++i
)
11860 tree tuple
= TREE_VEC_ELT (parms
, i
);
11862 if (tuple
== error_mark_node
)
11865 TREE_VEC_ELT (new_vec
, i
) =
11866 tsubst_template_parm (tuple
, args
, complain
);
11872 /* Return the result of substituting ARGS into the template parameters
11873 given by PARMS. If there are m levels of ARGS and m + n levels of
11874 PARMS, then the result will contain n levels of PARMS. For
11875 example, if PARMS is `template <class T> template <class U>
11876 template <T*, U, class V>' and ARGS is {{int}, {double}} then the
11877 result will be `template <int*, double, class V>'. */
11880 tsubst_template_parms (tree parms
, tree args
, tsubst_flags_t complain
)
11882 tree r
= NULL_TREE
;
11885 /* When substituting into a template, we must set
11886 PROCESSING_TEMPLATE_DECL as the template parameters may be
11887 dependent if they are based on one-another, and the dependency
11888 predicates are short-circuit outside of templates. */
11889 ++processing_template_decl
;
11891 for (new_parms
= &r
;
11892 parms
&& TMPL_PARMS_DEPTH (parms
) > TMPL_ARGS_DEPTH (args
);
11893 new_parms
= &(TREE_CHAIN (*new_parms
)),
11894 parms
= TREE_CHAIN (parms
))
11896 tree new_vec
= tsubst_template_parms_level (TREE_VALUE (parms
),
11899 tree_cons (size_int (TMPL_PARMS_DEPTH (parms
)
11900 - TMPL_ARGS_DEPTH (args
)),
11901 new_vec
, NULL_TREE
);
11904 --processing_template_decl
;
11909 /* Return the result of substituting ARGS into one template parameter
11910 given by T. T Must be a TREE_LIST which TREE_VALUE is the template
11911 parameter and which TREE_PURPOSE is the default argument of the
11912 template parameter. */
11915 tsubst_template_parm (tree t
, tree args
, tsubst_flags_t complain
)
11917 tree default_value
, parm_decl
;
11919 if (args
== NULL_TREE
11921 || t
== error_mark_node
)
11924 gcc_assert (TREE_CODE (t
) == TREE_LIST
);
11926 default_value
= TREE_PURPOSE (t
);
11927 parm_decl
= TREE_VALUE (t
);
11929 parm_decl
= tsubst (parm_decl
, args
, complain
, NULL_TREE
);
11930 if (TREE_CODE (parm_decl
) == PARM_DECL
11931 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl
), complain
))
11932 parm_decl
= error_mark_node
;
11933 default_value
= tsubst_template_arg (default_value
, args
,
11934 complain
, NULL_TREE
);
11936 return build_tree_list (default_value
, parm_decl
);
11939 /* Substitute the ARGS into the indicated aggregate (or enumeration)
11940 type T. If T is not an aggregate or enumeration type, it is
11941 handled as if by tsubst. IN_DECL is as for tsubst. If
11942 ENTERING_SCOPE is nonzero, T is the context for a template which
11943 we are presently tsubst'ing. Return the substituted value. */
11946 tsubst_aggr_type (tree t
,
11948 tsubst_flags_t complain
,
11950 int entering_scope
)
11952 if (t
== NULL_TREE
)
11955 switch (TREE_CODE (t
))
11958 if (TYPE_PTRMEMFUNC_P (t
))
11959 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t
), args
, complain
, in_decl
);
11961 /* Fall through. */
11962 case ENUMERAL_TYPE
:
11964 if (TYPE_TEMPLATE_INFO (t
) && uses_template_parms (t
))
11969 int saved_unevaluated_operand
;
11970 int saved_inhibit_evaluation_warnings
;
11972 /* In "sizeof(X<I>)" we need to evaluate "I". */
11973 saved_unevaluated_operand
= cp_unevaluated_operand
;
11974 cp_unevaluated_operand
= 0;
11975 saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
11976 c_inhibit_evaluation_warnings
= 0;
11978 /* First, determine the context for the type we are looking
11980 context
= TYPE_CONTEXT (t
);
11981 if (context
&& TYPE_P (context
))
11983 context
= tsubst_aggr_type (context
, args
, complain
,
11984 in_decl
, /*entering_scope=*/1);
11985 /* If context is a nested class inside a class template,
11986 it may still need to be instantiated (c++/33959). */
11987 context
= complete_type (context
);
11990 /* Then, figure out what arguments are appropriate for the
11991 type we are trying to find. For example, given:
11993 template <class T> struct S;
11994 template <class T, class U> void f(T, U) { S<U> su; }
11996 and supposing that we are instantiating f<int, double>,
11997 then our ARGS will be {int, double}, but, when looking up
11998 S we only want {double}. */
11999 argvec
= tsubst_template_args (TYPE_TI_ARGS (t
), args
,
12000 complain
, in_decl
);
12001 if (argvec
== error_mark_node
)
12002 r
= error_mark_node
;
12005 r
= lookup_template_class (t
, argvec
, in_decl
, context
,
12006 entering_scope
, complain
);
12007 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
12010 cp_unevaluated_operand
= saved_unevaluated_operand
;
12011 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
12016 /* This is not a template type, so there's nothing to do. */
12020 return tsubst (t
, args
, complain
, in_decl
);
12024 static GTY(()) hash_map
<tree
, tree
> *defarg_inst
;
12026 /* Substitute into the default argument ARG (a default argument for
12027 FN), which has the indicated TYPE. */
12030 tsubst_default_argument (tree fn
, int parmnum
, tree type
, tree arg
,
12031 tsubst_flags_t complain
)
12033 tree saved_class_ptr
= NULL_TREE
;
12034 tree saved_class_ref
= NULL_TREE
;
12035 int errs
= errorcount
+ sorrycount
;
12037 /* This can happen in invalid code. */
12038 if (TREE_CODE (arg
) == DEFAULT_ARG
)
12041 tree parm
= FUNCTION_FIRST_USER_PARM (fn
);
12042 parm
= chain_index (parmnum
, parm
);
12043 tree parmtype
= TREE_TYPE (parm
);
12044 if (DECL_BY_REFERENCE (parm
))
12045 parmtype
= TREE_TYPE (parmtype
);
12046 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, parmtype
));
12049 if (defarg_inst
&& (slot
= defarg_inst
->get (parm
)))
12052 /* This default argument came from a template. Instantiate the
12053 default argument here, not in tsubst. In the case of
12062 we must be careful to do name lookup in the scope of S<T>,
12063 rather than in the current class. */
12064 push_access_scope (fn
);
12065 /* The "this" pointer is not valid in a default argument. */
12068 saved_class_ptr
= current_class_ptr
;
12069 cp_function_chain
->x_current_class_ptr
= NULL_TREE
;
12070 saved_class_ref
= current_class_ref
;
12071 cp_function_chain
->x_current_class_ref
= NULL_TREE
;
12074 start_lambda_scope (parm
);
12076 push_deferring_access_checks(dk_no_deferred
);
12077 /* The default argument expression may cause implicitly defined
12078 member functions to be synthesized, which will result in garbage
12079 collection. We must treat this situation as if we were within
12080 the body of function so as to avoid collecting live data on the
12083 arg
= tsubst_expr (arg
, DECL_TI_ARGS (fn
),
12084 complain
, NULL_TREE
,
12085 /*integral_constant_expression_p=*/false);
12087 pop_deferring_access_checks();
12089 finish_lambda_scope ();
12091 /* Restore the "this" pointer. */
12094 cp_function_chain
->x_current_class_ptr
= saved_class_ptr
;
12095 cp_function_chain
->x_current_class_ref
= saved_class_ref
;
12098 if (errorcount
+sorrycount
> errs
12099 && (complain
& tf_warning_or_error
))
12100 inform (input_location
,
12101 " when instantiating default argument for call to %qD", fn
);
12103 /* Make sure the default argument is reasonable. */
12104 arg
= check_default_argument (type
, arg
, complain
);
12106 pop_access_scope (fn
);
12108 if (arg
!= error_mark_node
&& !cp_unevaluated_operand
)
12111 defarg_inst
= hash_map
<tree
,tree
>::create_ggc (37);
12112 defarg_inst
->put (parm
, arg
);
12118 /* Substitute into all the default arguments for FN. */
12121 tsubst_default_arguments (tree fn
, tsubst_flags_t complain
)
12126 tmpl_args
= DECL_TI_ARGS (fn
);
12128 /* If this function is not yet instantiated, we certainly don't need
12129 its default arguments. */
12130 if (uses_template_parms (tmpl_args
))
12132 /* Don't do this again for clones. */
12133 if (DECL_CLONED_FUNCTION_P (fn
))
12137 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
12139 arg
= TREE_CHAIN (arg
), ++i
)
12140 if (TREE_PURPOSE (arg
))
12141 TREE_PURPOSE (arg
) = tsubst_default_argument (fn
, i
,
12143 TREE_PURPOSE (arg
),
12147 /* Subroutine of tsubst_decl for the case when T is a FUNCTION_DECL. */
12150 tsubst_function_decl (tree t
, tree args
, tsubst_flags_t complain
,
12151 tree lambda_fntype
)
12153 tree gen_tmpl
, argvec
;
12154 hashval_t hash
= 0;
12157 /* Nobody should be tsubst'ing into non-template functions. */
12158 gcc_assert (DECL_TEMPLATE_INFO (t
) != NULL_TREE
);
12160 if (TREE_CODE (DECL_TI_TEMPLATE (t
)) == TEMPLATE_DECL
)
12162 /* If T is not dependent, just return it. */
12163 if (!uses_template_parms (DECL_TI_ARGS (t
)))
12166 /* Calculate the most general template of which R is a
12167 specialization, and the complete set of arguments used to
12169 gen_tmpl
= most_general_template (DECL_TI_TEMPLATE (t
));
12170 argvec
= tsubst_template_args (DECL_TI_ARGS
12171 (DECL_TEMPLATE_RESULT
12172 (DECL_TI_TEMPLATE (t
))),
12173 args
, complain
, in_decl
);
12174 if (argvec
== error_mark_node
)
12175 return error_mark_node
;
12177 /* Check to see if we already have this specialization. */
12178 if (!lambda_fntype
)
12180 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
12181 if (tree spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
))
12185 /* We can see more levels of arguments than parameters if
12186 there was a specialization of a member template, like
12189 template <class T> struct S { template <class U> void f(); }
12190 template <> template <class U> void S<int>::f(U);
12192 Here, we'll be substituting into the specialization,
12193 because that's where we can find the code we actually
12194 want to generate, but we'll have enough arguments for
12195 the most general template.
12197 We also deal with the peculiar case:
12199 template <class T> struct S {
12200 template <class U> friend void f();
12202 template <class U> void f() {}
12204 template void f<double>();
12206 Here, the ARGS for the instantiation of will be {int,
12207 double}. But, we only need as many ARGS as there are
12208 levels of template parameters in CODE_PATTERN. We are
12209 careful not to get fooled into reducing the ARGS in
12212 template <class T> struct S { template <class U> void f(U); }
12213 template <class T> template <> void S<T>::f(int) {}
12215 which we can spot because the pattern will be a
12216 specialization in this case. */
12217 int args_depth
= TMPL_ARGS_DEPTH (args
);
12219 TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (t
)));
12221 if (args_depth
> parms_depth
&& !DECL_TEMPLATE_SPECIALIZATION (t
))
12222 args
= get_innermost_template_args (args
, parms_depth
);
12226 /* This special case arises when we have something like this:
12228 template <class T> struct S {
12229 friend void f<int>(int, double);
12232 Here, the DECL_TI_TEMPLATE for the friend declaration
12233 will be an IDENTIFIER_NODE. We are being called from
12234 tsubst_friend_function, and we want only to create a
12235 new decl (R) with appropriate types so that we can call
12236 determine_specialization. */
12237 gen_tmpl
= NULL_TREE
;
12238 argvec
= NULL_TREE
;
12241 tree closure
= (lambda_fntype
? TYPE_METHOD_BASETYPE (lambda_fntype
)
12243 tree ctx
= closure
? closure
: DECL_CONTEXT (t
);
12244 bool member
= ctx
&& TYPE_P (ctx
);
12246 if (member
&& !closure
)
12247 ctx
= tsubst_aggr_type (ctx
, args
,
12248 complain
, t
, /*entering_scope=*/1);
12250 tree type
= (lambda_fntype
? lambda_fntype
12251 : tsubst (TREE_TYPE (t
), args
,
12252 complain
| tf_fndecl_type
, in_decl
));
12253 if (type
== error_mark_node
)
12254 return error_mark_node
;
12256 /* If we hit excessive deduction depth, the type is bogus even if
12257 it isn't error_mark_node, so don't build a decl. */
12258 if (excessive_deduction_depth
)
12259 return error_mark_node
;
12261 /* We do NOT check for matching decls pushed separately at this
12262 point, as they may not represent instantiations of this
12263 template, and in any case are considered separate under the
12265 tree r
= copy_decl (t
);
12266 DECL_USE_TEMPLATE (r
) = 0;
12267 TREE_TYPE (r
) = type
;
12268 /* Clear out the mangled name and RTL for the instantiation. */
12269 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
12270 SET_DECL_RTL (r
, NULL
);
12271 /* Leave DECL_INITIAL set on deleted instantiations. */
12272 if (!DECL_DELETED_FN (r
))
12273 DECL_INITIAL (r
) = NULL_TREE
;
12274 DECL_CONTEXT (r
) = ctx
;
12276 /* OpenMP UDRs have the only argument a reference to the declared
12277 type. We want to diagnose if the declared type is a reference,
12278 which is invalid, but as references to references are usually
12279 quietly merged, diagnose it here. */
12280 if (DECL_OMP_DECLARE_REDUCTION_P (t
))
12283 = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (t
))));
12284 argtype
= tsubst (argtype
, args
, complain
, in_decl
);
12285 if (TREE_CODE (argtype
) == REFERENCE_TYPE
)
12286 error_at (DECL_SOURCE_LOCATION (t
),
12287 "reference type %qT in "
12288 "%<#pragma omp declare reduction%>", argtype
);
12289 if (strchr (IDENTIFIER_POINTER (DECL_NAME (t
)), '~') == NULL
)
12290 DECL_NAME (r
) = omp_reduction_id (ERROR_MARK
, DECL_NAME (t
),
12294 if (member
&& DECL_CONV_FN_P (r
))
12295 /* Type-conversion operator. Reconstruct the name, in
12296 case it's the name of one of the template's parameters. */
12297 DECL_NAME (r
) = make_conv_op_name (TREE_TYPE (type
));
12299 tree parms
= DECL_ARGUMENTS (t
);
12301 parms
= DECL_CHAIN (parms
);
12302 parms
= tsubst (parms
, args
, complain
, t
);
12303 for (tree parm
= parms
; parm
; parm
= DECL_CHAIN (parm
))
12304 DECL_CONTEXT (parm
) = r
;
12307 tree tparm
= build_this_parm (r
, closure
, type_memfn_quals (type
));
12308 DECL_CHAIN (tparm
) = parms
;
12311 DECL_ARGUMENTS (r
) = parms
;
12312 DECL_RESULT (r
) = NULL_TREE
;
12314 TREE_STATIC (r
) = 0;
12315 TREE_PUBLIC (r
) = TREE_PUBLIC (t
);
12316 DECL_EXTERNAL (r
) = 1;
12317 /* If this is an instantiation of a function with internal
12318 linkage, we already know what object file linkage will be
12319 assigned to the instantiation. */
12320 DECL_INTERFACE_KNOWN (r
) = !TREE_PUBLIC (r
);
12321 DECL_DEFER_OUTPUT (r
) = 0;
12322 DECL_CHAIN (r
) = NULL_TREE
;
12323 DECL_PENDING_INLINE_INFO (r
) = 0;
12324 DECL_PENDING_INLINE_P (r
) = 0;
12325 DECL_SAVED_TREE (r
) = NULL_TREE
;
12326 DECL_STRUCT_FUNCTION (r
) = NULL
;
12328 /* We'll re-clone as appropriate in instantiate_template. */
12329 DECL_CLONED_FUNCTION (r
) = NULL_TREE
;
12331 /* If we aren't complaining now, return on error before we register
12332 the specialization so that we'll complain eventually. */
12333 if ((complain
& tf_error
) == 0
12334 && IDENTIFIER_ANY_OP_P (DECL_NAME (r
))
12335 && !grok_op_properties (r
, /*complain=*/false))
12336 return error_mark_node
;
12338 /* When instantiating a constrained member, substitute
12339 into the constraints to create a new constraint. */
12340 if (tree ci
= get_constraints (t
))
12343 ci
= tsubst_constraint_info (ci
, argvec
, complain
, NULL_TREE
);
12344 set_constraints (r
, ci
);
12347 /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
12348 this in the special friend case mentioned above where
12349 GEN_TMPL is NULL. */
12350 if (gen_tmpl
&& !closure
)
12352 DECL_TEMPLATE_INFO (r
)
12353 = build_template_info (gen_tmpl
, argvec
);
12354 SET_DECL_IMPLICIT_INSTANTIATION (r
);
12357 = register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
12359 /* We instantiated this while substituting into
12360 the type earlier (template/friend54.C). */
12363 /* We're not supposed to instantiate default arguments
12364 until they are called, for a template. But, for a
12367 template <class T> void f ()
12368 { extern void g(int i = T()); }
12370 we should do the substitution when the template is
12371 instantiated. We handle the member function case in
12372 instantiate_class_template since the default arguments
12373 might refer to other members of the class. */
12375 && !PRIMARY_TEMPLATE_P (gen_tmpl
)
12376 && !uses_template_parms (argvec
))
12377 tsubst_default_arguments (r
, complain
);
12380 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
12382 /* Copy the list of befriending classes. */
12383 for (tree
*friends
= &DECL_BEFRIENDING_CLASSES (r
);
12385 friends
= &TREE_CHAIN (*friends
))
12387 *friends
= copy_node (*friends
);
12388 TREE_VALUE (*friends
)
12389 = tsubst (TREE_VALUE (*friends
), args
, complain
, in_decl
);
12392 if (DECL_CONSTRUCTOR_P (r
) || DECL_DESTRUCTOR_P (r
))
12394 maybe_retrofit_in_chrg (r
);
12395 if (DECL_CONSTRUCTOR_P (r
) && !grok_ctor_properties (ctx
, r
))
12396 return error_mark_node
;
12397 /* If this is an instantiation of a member template, clone it.
12398 If it isn't, that'll be handled by
12399 clone_constructors_and_destructors. */
12400 if (PRIMARY_TEMPLATE_P (gen_tmpl
))
12401 clone_function_decl (r
, /*update_methods=*/false);
12403 else if ((complain
& tf_error
) != 0
12404 && IDENTIFIER_ANY_OP_P (DECL_NAME (r
))
12405 && !grok_op_properties (r
, /*complain=*/true))
12406 return error_mark_node
;
12408 if (DECL_FRIEND_P (t
) && DECL_FRIEND_CONTEXT (t
))
12409 SET_DECL_FRIEND_CONTEXT (r
,
12410 tsubst (DECL_FRIEND_CONTEXT (t
),
12411 args
, complain
, in_decl
));
12413 /* Possibly limit visibility based on template args. */
12414 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
12415 if (DECL_VISIBILITY_SPECIFIED (t
))
12417 DECL_VISIBILITY_SPECIFIED (r
) = 0;
12418 DECL_ATTRIBUTES (r
)
12419 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
12421 determine_visibility (r
);
12422 if (DECL_DEFAULTED_OUTSIDE_CLASS_P (r
)
12423 && !processing_template_decl
)
12424 defaulted_late_check (r
);
12426 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
12427 args
, complain
, in_decl
);
12431 /* Subroutine of tsubst_decl for the case when T is a TEMPLATE_DECL. */
12434 tsubst_template_decl (tree t
, tree args
, tsubst_flags_t complain
,
12435 tree lambda_fntype
)
12437 /* We can get here when processing a member function template,
12438 member class template, or template template parameter. */
12439 tree decl
= DECL_TEMPLATE_RESULT (t
);
12445 hashval_t hash
= 0;
12447 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
12449 /* Template template parameter is treated here. */
12450 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12451 if (new_type
== error_mark_node
)
12452 r
= error_mark_node
;
12453 /* If we get a real template back, return it. This can happen in
12454 the context of most_specialized_partial_spec. */
12455 else if (TREE_CODE (new_type
) == TEMPLATE_DECL
)
12458 /* The new TEMPLATE_DECL was built in
12459 reduce_template_parm_level. */
12460 r
= TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (new_type
);
12464 if (!lambda_fntype
)
12466 /* We might already have an instance of this template.
12467 The ARGS are for the surrounding class type, so the
12468 full args contain the tsubst'd args for the context,
12469 plus the innermost args from the template decl. */
12470 tmpl_args
= DECL_CLASS_TEMPLATE_P (t
)
12471 ? CLASSTYPE_TI_ARGS (TREE_TYPE (t
))
12472 : DECL_TI_ARGS (DECL_TEMPLATE_RESULT (t
));
12473 /* Because this is a template, the arguments will still be
12474 dependent, even after substitution. If
12475 PROCESSING_TEMPLATE_DECL is not set, the dependency
12476 predicates will short-circuit. */
12477 ++processing_template_decl
;
12478 full_args
= tsubst_template_args (tmpl_args
, args
,
12479 complain
, in_decl
);
12480 --processing_template_decl
;
12481 if (full_args
== error_mark_node
)
12482 return error_mark_node
;
12484 /* If this is a default template template argument,
12485 tsubst might not have changed anything. */
12486 if (full_args
== tmpl_args
)
12489 hash
= hash_tmpl_and_args (t
, full_args
);
12490 spec
= retrieve_specialization (t
, full_args
, hash
);
12491 if (spec
!= NULL_TREE
)
12495 /* Make a new template decl. It will be similar to the
12496 original, but will record the current template arguments.
12497 We also create a new function declaration, which is just
12498 like the old one, but points to this new template, rather
12499 than the old one. */
12501 gcc_assert (DECL_LANG_SPECIFIC (r
) != 0);
12502 DECL_CHAIN (r
) = NULL_TREE
;
12504 // Build new template info linking to the original template decl.
12505 if (!lambda_fntype
)
12507 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
12508 SET_DECL_IMPLICIT_INSTANTIATION (r
);
12511 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
12513 /* The template parameters for this new template are all the
12514 template parameters for the old template, except the
12515 outermost level of parameters. */
12516 DECL_TEMPLATE_PARMS (r
)
12517 = tsubst_template_parms (DECL_TEMPLATE_PARMS (t
), args
,
12520 if (TREE_CODE (decl
) == TYPE_DECL
12521 && !TYPE_DECL_ALIAS_P (decl
))
12524 ++processing_template_decl
;
12525 new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12526 --processing_template_decl
;
12527 if (new_type
== error_mark_node
)
12528 return error_mark_node
;
12530 TREE_TYPE (r
) = new_type
;
12531 /* For a partial specialization, we need to keep pointing to
12532 the primary template. */
12533 if (!DECL_TEMPLATE_SPECIALIZATION (t
))
12534 CLASSTYPE_TI_TEMPLATE (new_type
) = r
;
12535 DECL_TEMPLATE_RESULT (r
) = TYPE_MAIN_DECL (new_type
);
12536 DECL_TI_ARGS (r
) = CLASSTYPE_TI_ARGS (new_type
);
12537 DECL_CONTEXT (r
) = TYPE_CONTEXT (new_type
);
12542 ++processing_template_decl
;
12543 if (TREE_CODE (decl
) == FUNCTION_DECL
)
12544 new_decl
= tsubst_function_decl (decl
, args
, complain
, lambda_fntype
);
12546 new_decl
= tsubst (decl
, args
, complain
, in_decl
);
12547 --processing_template_decl
;
12548 if (new_decl
== error_mark_node
)
12549 return error_mark_node
;
12551 DECL_TEMPLATE_RESULT (r
) = new_decl
;
12552 TREE_TYPE (r
) = TREE_TYPE (new_decl
);
12553 DECL_CONTEXT (r
) = DECL_CONTEXT (new_decl
);
12556 tree args
= template_parms_to_args (DECL_TEMPLATE_PARMS (r
));
12557 DECL_TEMPLATE_INFO (new_decl
) = build_template_info (r
, args
);
12561 DECL_TI_TEMPLATE (new_decl
) = r
;
12562 DECL_TI_ARGS (r
) = DECL_TI_ARGS (new_decl
);
12566 DECL_TEMPLATE_INSTANTIATIONS (r
) = NULL_TREE
;
12567 DECL_TEMPLATE_SPECIALIZATIONS (r
) = NULL_TREE
;
12569 if (PRIMARY_TEMPLATE_P (t
))
12570 DECL_PRIMARY_TEMPLATE (r
) = r
;
12572 if (TREE_CODE (decl
) != TYPE_DECL
&& !VAR_P (decl
)
12574 /* Record this non-type partial instantiation. */
12575 register_specialization (r
, t
,
12576 DECL_TI_ARGS (DECL_TEMPLATE_RESULT (r
)),
12582 /* True if FN is the op() for a lambda in an uninstantiated template. */
12585 lambda_fn_in_template_p (tree fn
)
12587 if (!fn
|| !LAMBDA_FUNCTION_P (fn
))
12589 tree closure
= DECL_CONTEXT (fn
);
12590 return CLASSTYPE_TEMPLATE_INFO (closure
) != NULL_TREE
;
12593 /* True if FN is the op() for a lambda regenerated from a lambda in an
12594 uninstantiated template. */
12597 regenerated_lambda_fn_p (tree fn
)
12599 return (LAMBDA_FUNCTION_P (fn
)
12600 && !DECL_TEMPLATE_INSTANTIATION (fn
));
12603 /* We're instantiating a variable from template function TCTX. Return the
12604 corresponding current enclosing scope. This gets complicated because lambda
12605 functions in templates are regenerated rather than instantiated, but generic
12606 lambda functions are subsequently instantiated. */
12609 enclosing_instantiation_of (tree tctx
)
12611 tree fn
= current_function_decl
;
12612 int lambda_count
= 0;
12614 for (; tctx
&& lambda_fn_in_template_p (tctx
);
12615 tctx
= decl_function_context (tctx
))
12617 for (; fn
; fn
= decl_function_context (fn
))
12620 int flambda_count
= 0;
12621 for (; fn
&& regenerated_lambda_fn_p (fn
);
12622 fn
= decl_function_context (fn
))
12624 if (DECL_TEMPLATE_INFO (fn
)
12625 ? most_general_template (fn
) != most_general_template (tctx
)
12631 while (flambda_count
-- > lambda_count
)
12632 fn
= decl_function_context (fn
);
12636 gcc_unreachable ();
12639 /* Substitute the ARGS into the T, which is a _DECL. Return the
12640 result of the substitution. Issue error and warning messages under
12641 control of COMPLAIN. */
12644 tsubst_decl (tree t
, tree args
, tsubst_flags_t complain
)
12646 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
12647 location_t saved_loc
;
12648 tree r
= NULL_TREE
;
12650 hashval_t hash
= 0;
12652 /* Set the filename and linenumber to improve error-reporting. */
12653 saved_loc
= input_location
;
12654 input_location
= DECL_SOURCE_LOCATION (t
);
12656 switch (TREE_CODE (t
))
12658 case TEMPLATE_DECL
:
12659 r
= tsubst_template_decl (t
, args
, complain
, /*lambda*/NULL_TREE
);
12662 case FUNCTION_DECL
:
12663 r
= tsubst_function_decl (t
, args
, complain
, /*lambda*/NULL_TREE
);
12668 tree type
= NULL_TREE
;
12670 tree expanded_types
= NULL_TREE
;
12671 tree prev_r
= NULL_TREE
;
12672 tree first_r
= NULL_TREE
;
12674 if (DECL_PACK_P (t
))
12676 /* If there is a local specialization that isn't a
12677 parameter pack, it means that we're doing a "simple"
12678 substitution from inside tsubst_pack_expansion. Just
12679 return the local specialization (which will be a single
12681 tree spec
= retrieve_local_specialization (t
);
12683 && TREE_CODE (spec
) == PARM_DECL
12684 && TREE_CODE (TREE_TYPE (spec
)) != TYPE_PACK_EXPANSION
)
12687 /* Expand the TYPE_PACK_EXPANSION that provides the types for
12688 the parameters in this function parameter pack. */
12689 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
12690 complain
, in_decl
);
12691 if (TREE_CODE (expanded_types
) == TREE_VEC
)
12693 len
= TREE_VEC_LENGTH (expanded_types
);
12695 /* Zero-length parameter packs are boring. Just substitute
12698 RETURN (tsubst (TREE_CHAIN (t
), args
, complain
,
12703 /* All we did was update the type. Make a note of that. */
12704 type
= expanded_types
;
12705 expanded_types
= NULL_TREE
;
12709 /* Loop through all of the parameters we'll build. When T is
12710 a function parameter pack, LEN is the number of expanded
12711 types in EXPANDED_TYPES; otherwise, LEN is 1. */
12713 for (i
= 0; i
< len
; ++i
)
12717 if (DECL_TEMPLATE_PARM_P (t
))
12718 SET_DECL_TEMPLATE_PARM_P (r
);
12720 if (expanded_types
)
12721 /* We're on the Ith parameter of the function parameter
12724 /* Get the Ith type. */
12725 type
= TREE_VEC_ELT (expanded_types
, i
);
12727 /* Rename the parameter to include the index. */
12729 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
12732 /* We're dealing with a normal parameter. */
12733 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12735 type
= type_decays_to (type
);
12736 TREE_TYPE (r
) = type
;
12737 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
12739 if (DECL_INITIAL (r
))
12741 if (TREE_CODE (DECL_INITIAL (r
)) != TEMPLATE_PARM_INDEX
)
12742 DECL_INITIAL (r
) = TREE_TYPE (r
);
12744 DECL_INITIAL (r
) = tsubst (DECL_INITIAL (r
), args
,
12745 complain
, in_decl
);
12748 DECL_CONTEXT (r
) = NULL_TREE
;
12750 if (!DECL_TEMPLATE_PARM_P (r
))
12751 DECL_ARG_TYPE (r
) = type_passed_as (type
);
12753 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
12754 args
, complain
, in_decl
);
12756 /* Keep track of the first new parameter we
12757 generate. That's what will be returned to the
12762 /* Build a proper chain of parameters when substituting
12763 into a function parameter pack. */
12765 DECL_CHAIN (prev_r
) = r
;
12768 /* If cp_unevaluated_operand is set, we're just looking for a
12769 single dummy parameter, so don't keep going. */
12770 if (DECL_CHAIN (t
) && !cp_unevaluated_operand
)
12771 DECL_CHAIN (r
) = tsubst (DECL_CHAIN (t
), args
,
12772 complain
, DECL_CHAIN (t
));
12774 /* FIRST_R contains the start of the chain we've built. */
12781 tree type
= NULL_TREE
;
12782 tree vec
= NULL_TREE
;
12783 tree expanded_types
= NULL_TREE
;
12786 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
12788 /* This field is a lambda capture pack. Return a TREE_VEC of
12789 the expanded fields to instantiate_class_template_1 and
12790 store them in the specializations hash table as a
12791 NONTYPE_ARGUMENT_PACK so that tsubst_copy can find them. */
12792 expanded_types
= tsubst_pack_expansion (TREE_TYPE (t
), args
,
12793 complain
, in_decl
);
12794 if (TREE_CODE (expanded_types
) == TREE_VEC
)
12796 len
= TREE_VEC_LENGTH (expanded_types
);
12797 vec
= make_tree_vec (len
);
12801 /* All we did was update the type. Make a note of that. */
12802 type
= expanded_types
;
12803 expanded_types
= NULL_TREE
;
12807 for (int i
= 0; i
< len
; ++i
)
12810 if (expanded_types
)
12812 type
= TREE_VEC_ELT (expanded_types
, i
);
12814 = make_ith_pack_parameter_name (DECL_NAME (r
), i
);
12817 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12819 if (type
== error_mark_node
)
12820 RETURN (error_mark_node
);
12821 TREE_TYPE (r
) = type
;
12822 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
12824 if (DECL_C_BIT_FIELD (r
))
12825 /* For bit-fields, DECL_BIT_FIELD_REPRESENTATIVE gives the
12827 DECL_BIT_FIELD_REPRESENTATIVE (r
)
12828 = tsubst_expr (DECL_BIT_FIELD_REPRESENTATIVE (t
), args
,
12830 /*integral_constant_expression_p=*/true);
12831 if (DECL_INITIAL (t
))
12833 /* Set up DECL_TEMPLATE_INFO so that we can get at the
12834 NSDMI in perform_member_init. Still set DECL_INITIAL
12835 so that we know there is one. */
12836 DECL_INITIAL (r
) = void_node
;
12837 gcc_assert (DECL_LANG_SPECIFIC (r
) == NULL
);
12838 retrofit_lang_decl (r
);
12839 DECL_TEMPLATE_INFO (r
) = build_template_info (t
, args
);
12841 /* We don't have to set DECL_CONTEXT here; it is set by
12842 finish_member_declaration. */
12843 DECL_CHAIN (r
) = NULL_TREE
;
12845 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
), 0,
12846 args
, complain
, in_decl
);
12849 TREE_VEC_ELT (vec
, i
) = r
;
12855 tree pack
= make_node (NONTYPE_ARGUMENT_PACK
);
12856 SET_ARGUMENT_PACK_ARGS (pack
, vec
);
12857 register_specialization (pack
, t
, args
, false, 0);
12863 /* We reach here only for member using decls. We also need to check
12864 uses_template_parms because DECL_DEPENDENT_P is not set for a
12865 using-declaration that designates a member of the current
12866 instantiation (c++/53549). */
12867 if (DECL_DEPENDENT_P (t
)
12868 || uses_template_parms (USING_DECL_SCOPE (t
)))
12870 tree scope
= USING_DECL_SCOPE (t
);
12871 tree name
= tsubst_copy (DECL_NAME (t
), args
, complain
, in_decl
);
12872 if (PACK_EXPANSION_P (scope
))
12874 tree vec
= tsubst_pack_expansion (scope
, args
, complain
, in_decl
);
12875 int len
= TREE_VEC_LENGTH (vec
);
12876 r
= make_tree_vec (len
);
12877 for (int i
= 0; i
< len
; ++i
)
12879 tree escope
= TREE_VEC_ELT (vec
, i
);
12880 tree elt
= do_class_using_decl (escope
, name
);
12883 r
= error_mark_node
;
12888 TREE_PROTECTED (elt
) = TREE_PROTECTED (t
);
12889 TREE_PRIVATE (elt
) = TREE_PRIVATE (t
);
12891 TREE_VEC_ELT (r
, i
) = elt
;
12896 tree inst_scope
= tsubst_copy (USING_DECL_SCOPE (t
), args
,
12897 complain
, in_decl
);
12898 r
= do_class_using_decl (inst_scope
, name
);
12900 r
= error_mark_node
;
12903 TREE_PROTECTED (r
) = TREE_PROTECTED (t
);
12904 TREE_PRIVATE (r
) = TREE_PRIVATE (t
);
12911 DECL_CHAIN (r
) = NULL_TREE
;
12918 tree argvec
= NULL_TREE
;
12919 tree gen_tmpl
= NULL_TREE
;
12921 tree tmpl
= NULL_TREE
;
12923 tree type
= NULL_TREE
;
12926 if (TREE_TYPE (t
) == error_mark_node
)
12927 RETURN (error_mark_node
);
12929 if (TREE_CODE (t
) == TYPE_DECL
12930 && t
== TYPE_MAIN_DECL (TREE_TYPE (t
)))
12932 /* If this is the canonical decl, we don't have to
12933 mess with instantiations, and often we can't (for
12934 typename, template type parms and such). Note that
12935 TYPE_NAME is not correct for the above test if
12936 we've copied the type for a typedef. */
12937 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
12938 if (type
== error_mark_node
)
12939 RETURN (error_mark_node
);
12940 r
= TYPE_NAME (type
);
12944 /* Check to see if we already have the specialization we
12947 if (DECL_CLASS_SCOPE_P (t
) || DECL_NAMESPACE_SCOPE_P (t
))
12949 /* T is a static data member or namespace-scope entity.
12950 We have to substitute into namespace-scope variables
12951 (not just variable templates) because of cases like:
12953 template <class T> void f() { extern T t; }
12955 where the entity referenced is not known until
12956 instantiation time. */
12958 ctx
= DECL_CONTEXT (t
);
12959 if (DECL_CLASS_SCOPE_P (t
))
12961 ctx
= tsubst_aggr_type (ctx
, args
,
12963 in_decl
, /*entering_scope=*/1);
12964 /* If CTX is unchanged, then T is in fact the
12965 specialization we want. That situation occurs when
12966 referencing a static data member within in its own
12967 class. We can use pointer equality, rather than
12968 same_type_p, because DECL_CONTEXT is always
12970 if (ctx
== DECL_CONTEXT (t
)
12971 /* ... unless T is a member template; in which
12972 case our caller can be willing to create a
12973 specialization of that template represented
12975 && !(DECL_TI_TEMPLATE (t
)
12976 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
12982 tmpl
= DECL_TI_TEMPLATE (t
);
12983 gen_tmpl
= most_general_template (tmpl
);
12984 argvec
= tsubst (DECL_TI_ARGS (t
), args
, complain
, in_decl
);
12985 if (argvec
!= error_mark_node
)
12986 argvec
= (coerce_innermost_template_parms
12987 (DECL_TEMPLATE_PARMS (gen_tmpl
),
12988 argvec
, t
, complain
,
12989 /*all*/true, /*defarg*/true));
12990 if (argvec
== error_mark_node
)
12991 RETURN (error_mark_node
);
12992 hash
= hash_tmpl_and_args (gen_tmpl
, argvec
);
12993 spec
= retrieve_specialization (gen_tmpl
, argvec
, hash
);
12998 /* A local variable. */
13000 /* Subsequent calls to pushdecl will fill this in. */
13002 /* Unless this is a reference to a static variable from an
13003 enclosing function, in which case we need to fill it in now. */
13004 if (TREE_STATIC (t
))
13006 tree fn
= enclosing_instantiation_of (DECL_CONTEXT (t
));
13007 if (fn
!= current_function_decl
)
13010 spec
= retrieve_local_specialization (t
);
13012 /* If we already have the specialization we need, there is
13013 nothing more to do. */
13020 /* Create a new node for the specialization we need. */
13022 if (type
== NULL_TREE
)
13024 if (is_typedef_decl (t
))
13025 type
= DECL_ORIGINAL_TYPE (t
);
13027 type
= TREE_TYPE (t
);
13029 && VAR_HAD_UNKNOWN_BOUND (t
)
13030 && type
!= error_mark_node
)
13031 type
= strip_array_domain (type
);
13032 tree sub_args
= args
;
13033 if (tree auto_node
= type_uses_auto (type
))
13035 /* Mask off any template args past the variable's context so we
13036 don't replace the auto with an unrelated argument. */
13037 int nouter
= TEMPLATE_TYPE_LEVEL (auto_node
) - 1;
13038 int extra
= TMPL_ARGS_DEPTH (args
) - nouter
;
13040 /* This should never happen with the new lambda instantiation
13041 model, but keep the handling just in case. */
13042 gcc_assert (!CHECKING_P
),
13043 sub_args
= strip_innermost_template_args (args
, extra
);
13045 type
= tsubst (type
, sub_args
, complain
, in_decl
);
13049 /* Even if the original location is out of scope, the
13050 newly substituted one is not. */
13051 DECL_DEAD_FOR_LOCAL (r
) = 0;
13052 DECL_INITIALIZED_P (r
) = 0;
13053 DECL_TEMPLATE_INSTANTIATED (r
) = 0;
13054 if (type
== error_mark_node
)
13055 RETURN (error_mark_node
);
13056 if (TREE_CODE (type
) == FUNCTION_TYPE
)
13058 /* It may seem that this case cannot occur, since:
13063 declares a function, not a variable. However:
13066 template <typename T> void g() { T t; }
13067 template void g<f>();
13069 is an attempt to declare a variable with function
13071 error ("variable %qD has function type",
13072 /* R is not yet sufficiently initialized, so we
13073 just use its name. */
13075 RETURN (error_mark_node
);
13077 type
= complete_type (type
);
13078 /* Wait until cp_finish_decl to set this again, to handle
13079 circular dependency (template/instantiate6.C). */
13080 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
) = 0;
13081 type
= check_var_type (DECL_NAME (r
), type
);
13083 if (DECL_HAS_VALUE_EXPR_P (t
))
13085 tree ve
= DECL_VALUE_EXPR (t
);
13086 ve
= tsubst_expr (ve
, args
, complain
, in_decl
,
13087 /*constant_expression_p=*/false);
13088 if (REFERENCE_REF_P (ve
))
13090 gcc_assert (TREE_CODE (type
) == REFERENCE_TYPE
);
13091 ve
= TREE_OPERAND (ve
, 0);
13093 SET_DECL_VALUE_EXPR (r
, ve
);
13095 if (CP_DECL_THREAD_LOCAL_P (r
)
13096 && !processing_template_decl
)
13097 set_decl_tls_model (r
, decl_default_tls_model (r
));
13099 else if (DECL_SELF_REFERENCE_P (t
))
13100 SET_DECL_SELF_REFERENCE_P (r
);
13101 TREE_TYPE (r
) = type
;
13102 cp_apply_type_quals_to_decl (cp_type_quals (type
), r
);
13103 DECL_CONTEXT (r
) = ctx
;
13104 /* Clear out the mangled name and RTL for the instantiation. */
13105 SET_DECL_ASSEMBLER_NAME (r
, NULL_TREE
);
13106 if (CODE_CONTAINS_STRUCT (TREE_CODE (t
), TS_DECL_WRTL
))
13107 SET_DECL_RTL (r
, NULL
);
13108 /* The initializer must not be expanded until it is required;
13109 see [temp.inst]. */
13110 DECL_INITIAL (r
) = NULL_TREE
;
13111 DECL_SIZE (r
) = DECL_SIZE_UNIT (r
) = 0;
13114 SET_DECL_MODE (r
, VOIDmode
);
13116 /* Possibly limit visibility based on template args. */
13117 DECL_VISIBILITY (r
) = VISIBILITY_DEFAULT
;
13118 if (DECL_VISIBILITY_SPECIFIED (t
))
13120 DECL_VISIBILITY_SPECIFIED (r
) = 0;
13121 DECL_ATTRIBUTES (r
)
13122 = remove_attribute ("visibility", DECL_ATTRIBUTES (r
));
13124 determine_visibility (r
);
13129 /* A static data member declaration is always marked
13130 external when it is declared in-class, even if an
13131 initializer is present. We mimic the non-template
13132 processing here. */
13133 DECL_EXTERNAL (r
) = 1;
13134 if (DECL_NAMESPACE_SCOPE_P (t
))
13135 DECL_NOT_REALLY_EXTERN (r
) = 1;
13137 DECL_TEMPLATE_INFO (r
) = build_template_info (tmpl
, argvec
);
13138 SET_DECL_IMPLICIT_INSTANTIATION (r
);
13139 register_specialization (r
, gen_tmpl
, argvec
, false, hash
);
13143 if (DECL_LANG_SPECIFIC (r
))
13144 DECL_TEMPLATE_INFO (r
) = NULL_TREE
;
13145 if (!cp_unevaluated_operand
)
13146 register_local_specialization (r
, t
);
13149 DECL_CHAIN (r
) = NULL_TREE
;
13151 apply_late_template_attributes (&r
, DECL_ATTRIBUTES (r
),
13153 args
, complain
, in_decl
);
13155 /* Preserve a typedef that names a type. */
13156 if (is_typedef_decl (r
) && type
!= error_mark_node
)
13158 DECL_ORIGINAL_TYPE (r
) = NULL_TREE
;
13159 set_underlying_type (r
);
13160 if (TYPE_DECL_ALIAS_P (r
))
13161 /* An alias template specialization can be dependent
13162 even if its underlying type is not. */
13163 TYPE_DEPENDENT_P_VALID (TREE_TYPE (r
)) = false;
13166 layout_decl (r
, 0);
13171 gcc_unreachable ();
13176 /* Restore the file and line information. */
13177 input_location
= saved_loc
;
13182 /* Substitute into the ARG_TYPES of a function type.
13183 If END is a TREE_CHAIN, leave it and any following types
13187 tsubst_arg_types (tree arg_types
,
13190 tsubst_flags_t complain
,
13193 tree remaining_arg_types
;
13194 tree type
= NULL_TREE
;
13196 tree expanded_args
= NULL_TREE
;
13199 if (!arg_types
|| arg_types
== void_list_node
|| arg_types
== end
)
13202 remaining_arg_types
= tsubst_arg_types (TREE_CHAIN (arg_types
),
13203 args
, end
, complain
, in_decl
);
13204 if (remaining_arg_types
== error_mark_node
)
13205 return error_mark_node
;
13207 if (PACK_EXPANSION_P (TREE_VALUE (arg_types
)))
13209 /* For a pack expansion, perform substitution on the
13210 entire expression. Later on, we'll handle the arguments
13212 expanded_args
= tsubst_pack_expansion (TREE_VALUE (arg_types
),
13213 args
, complain
, in_decl
);
13215 if (TREE_CODE (expanded_args
) == TREE_VEC
)
13216 /* So that we'll spin through the parameters, one by one. */
13217 i
= TREE_VEC_LENGTH (expanded_args
);
13220 /* We only partially substituted into the parameter
13221 pack. Our type is TYPE_PACK_EXPANSION. */
13222 type
= expanded_args
;
13223 expanded_args
= NULL_TREE
;
13231 type
= TREE_VEC_ELT (expanded_args
, i
);
13233 type
= tsubst (TREE_VALUE (arg_types
), args
, complain
, in_decl
);
13235 if (type
== error_mark_node
)
13236 return error_mark_node
;
13237 if (VOID_TYPE_P (type
))
13239 if (complain
& tf_error
)
13241 error ("invalid parameter type %qT", type
);
13243 error ("in declaration %q+D", in_decl
);
13245 return error_mark_node
;
13248 if (abstract_virtuals_error_sfinae (ACU_PARM
, type
, complain
))
13249 return error_mark_node
;
13251 /* Do array-to-pointer, function-to-pointer conversion, and ignore
13252 top-level qualifiers as required. */
13253 type
= cv_unqualified (type_decays_to (type
));
13255 /* We do not substitute into default arguments here. The standard
13256 mandates that they be instantiated only when needed, which is
13257 done in build_over_call. */
13258 default_arg
= TREE_PURPOSE (arg_types
);
13260 /* Except that we do substitute default arguments under tsubst_lambda_expr,
13261 since the new op() won't have any associated template arguments for us
13262 to refer to later. */
13263 if (lambda_fn_in_template_p (in_decl
))
13264 default_arg
= tsubst_copy_and_build (default_arg
, args
, complain
, in_decl
,
13265 false/*fn*/, false/*constexpr*/);
13267 if (default_arg
&& TREE_CODE (default_arg
) == DEFAULT_ARG
)
13269 /* We've instantiated a template before its default arguments
13270 have been parsed. This can happen for a nested template
13271 class, and is not an error unless we require the default
13272 argument in a call of this function. */
13273 remaining_arg_types
=
13274 tree_cons (default_arg
, type
, remaining_arg_types
);
13275 vec_safe_push (DEFARG_INSTANTIATIONS(default_arg
), remaining_arg_types
);
13278 remaining_arg_types
=
13279 hash_tree_cons (default_arg
, type
, remaining_arg_types
);
13282 return remaining_arg_types
;
13285 /* Substitute into a FUNCTION_TYPE or METHOD_TYPE. This routine does
13286 *not* handle the exception-specification for FNTYPE, because the
13287 initial substitution of explicitly provided template parameters
13288 during argument deduction forbids substitution into the
13289 exception-specification:
13293 All references in the function type of the function template to the
13294 corresponding template parameters are replaced by the specified tem-
13295 plate argument values. If a substitution in a template parameter or
13296 in the function type of the function template results in an invalid
13297 type, type deduction fails. [Note: The equivalent substitution in
13298 exception specifications is done only when the function is instanti-
13299 ated, at which point a program is ill-formed if the substitution
13300 results in an invalid type.] */
13303 tsubst_function_type (tree t
,
13305 tsubst_flags_t complain
,
13309 tree arg_types
= NULL_TREE
;
13312 /* The TYPE_CONTEXT is not used for function/method types. */
13313 gcc_assert (TYPE_CONTEXT (t
) == NULL_TREE
);
13315 /* DR 1227: Mixing immediate and non-immediate contexts in deduction
13317 bool late_return_type_p
= TYPE_HAS_LATE_RETURN_TYPE (t
);
13319 if (late_return_type_p
)
13321 /* Substitute the argument types. */
13322 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
13323 complain
, in_decl
);
13324 if (arg_types
== error_mark_node
)
13325 return error_mark_node
;
13327 tree save_ccp
= current_class_ptr
;
13328 tree save_ccr
= current_class_ref
;
13329 tree this_type
= (TREE_CODE (t
) == METHOD_TYPE
13330 ? TREE_TYPE (TREE_VALUE (arg_types
)) : NULL_TREE
);
13331 bool do_inject
= this_type
&& CLASS_TYPE_P (this_type
);
13334 /* DR 1207: 'this' is in scope in the trailing return type. */
13335 inject_this_parameter (this_type
, cp_type_quals (this_type
));
13338 /* Substitute the return type. */
13339 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13343 current_class_ptr
= save_ccp
;
13344 current_class_ref
= save_ccr
;
13348 /* Substitute the return type. */
13349 return_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
13351 if (return_type
== error_mark_node
)
13352 return error_mark_node
;
13353 /* DR 486 clarifies that creation of a function type with an
13354 invalid return type is a deduction failure. */
13355 if (TREE_CODE (return_type
) == ARRAY_TYPE
13356 || TREE_CODE (return_type
) == FUNCTION_TYPE
)
13358 if (complain
& tf_error
)
13360 if (TREE_CODE (return_type
) == ARRAY_TYPE
)
13361 error ("function returning an array");
13363 error ("function returning a function");
13365 return error_mark_node
;
13368 if (abstract_virtuals_error_sfinae (ACU_RETURN
, return_type
, complain
))
13369 return error_mark_node
;
13371 if (!late_return_type_p
)
13373 /* Substitute the argument types. */
13374 arg_types
= tsubst_arg_types (TYPE_ARG_TYPES (t
), args
, NULL_TREE
,
13375 complain
, in_decl
);
13376 if (arg_types
== error_mark_node
)
13377 return error_mark_node
;
13380 /* Construct a new type node and return it. */
13381 if (TREE_CODE (t
) == FUNCTION_TYPE
)
13383 fntype
= build_function_type (return_type
, arg_types
);
13384 fntype
= apply_memfn_quals (fntype
,
13385 type_memfn_quals (t
),
13386 type_memfn_rqual (t
));
13390 tree r
= TREE_TYPE (TREE_VALUE (arg_types
));
13391 /* Don't pick up extra function qualifiers from the basetype. */
13392 r
= cp_build_qualified_type_real (r
, type_memfn_quals (t
), complain
);
13393 if (! MAYBE_CLASS_TYPE_P (r
))
13397 Type deduction may fail for any of the following
13400 -- Attempting to create "pointer to member of T" when T
13401 is not a class type. */
13402 if (complain
& tf_error
)
13403 error ("creating pointer to member function of non-class type %qT",
13405 return error_mark_node
;
13408 fntype
= build_method_type_directly (r
, return_type
,
13409 TREE_CHAIN (arg_types
));
13410 fntype
= build_ref_qualified_type (fntype
, type_memfn_rqual (t
));
13412 fntype
= cp_build_type_attribute_variant (fntype
, TYPE_ATTRIBUTES (t
));
13414 if (late_return_type_p
)
13415 TYPE_HAS_LATE_RETURN_TYPE (fntype
) = 1;
13420 /* FNTYPE is a FUNCTION_TYPE or METHOD_TYPE. Substitute the template
13421 ARGS into that specification, and return the substituted
13422 specification. If there is no specification, return NULL_TREE. */
13425 tsubst_exception_specification (tree fntype
,
13427 tsubst_flags_t complain
,
13434 specs
= TYPE_RAISES_EXCEPTIONS (fntype
);
13435 new_specs
= NULL_TREE
;
13436 if (specs
&& TREE_PURPOSE (specs
))
13438 /* A noexcept-specifier. */
13439 tree expr
= TREE_PURPOSE (specs
);
13440 if (TREE_CODE (expr
) == INTEGER_CST
)
13444 /* Defer instantiation of noexcept-specifiers to avoid
13445 excessive instantiations (c++/49107). */
13446 new_specs
= make_node (DEFERRED_NOEXCEPT
);
13447 if (DEFERRED_NOEXCEPT_SPEC_P (specs
))
13449 /* We already partially instantiated this member template,
13450 so combine the new args with the old. */
13451 DEFERRED_NOEXCEPT_PATTERN (new_specs
)
13452 = DEFERRED_NOEXCEPT_PATTERN (expr
);
13453 DEFERRED_NOEXCEPT_ARGS (new_specs
)
13454 = add_to_template_args (DEFERRED_NOEXCEPT_ARGS (expr
), args
);
13458 DEFERRED_NOEXCEPT_PATTERN (new_specs
) = expr
;
13459 DEFERRED_NOEXCEPT_ARGS (new_specs
) = args
;
13463 new_specs
= tsubst_copy_and_build
13464 (expr
, args
, complain
, in_decl
, /*function_p=*/false,
13465 /*integral_constant_expression_p=*/true);
13466 new_specs
= build_noexcept_spec (new_specs
, complain
);
13470 if (! TREE_VALUE (specs
))
13477 tree expanded_specs
= NULL_TREE
;
13479 if (PACK_EXPANSION_P (TREE_VALUE (specs
)))
13481 /* Expand the pack expansion type. */
13482 expanded_specs
= tsubst_pack_expansion (TREE_VALUE (specs
),
13486 if (expanded_specs
== error_mark_node
)
13487 return error_mark_node
;
13488 else if (TREE_CODE (expanded_specs
) == TREE_VEC
)
13489 len
= TREE_VEC_LENGTH (expanded_specs
);
13492 /* We're substituting into a member template, so
13493 we got a TYPE_PACK_EXPANSION back. Add that
13494 expansion and move on. */
13495 gcc_assert (TREE_CODE (expanded_specs
)
13496 == TYPE_PACK_EXPANSION
);
13497 new_specs
= add_exception_specifier (new_specs
,
13500 specs
= TREE_CHAIN (specs
);
13505 for (i
= 0; i
< len
; ++i
)
13507 if (expanded_specs
)
13508 spec
= TREE_VEC_ELT (expanded_specs
, i
);
13510 spec
= tsubst (TREE_VALUE (specs
), args
, complain
, in_decl
);
13511 if (spec
== error_mark_node
)
13513 new_specs
= add_exception_specifier (new_specs
, spec
,
13517 specs
= TREE_CHAIN (specs
);
13523 /* Take the tree structure T and replace template parameters used
13524 therein with the argument vector ARGS. IN_DECL is an associated
13525 decl for diagnostics. If an error occurs, returns ERROR_MARK_NODE.
13526 Issue error and warning messages under control of COMPLAIN. Note
13527 that we must be relatively non-tolerant of extensions here, in
13528 order to preserve conformance; if we allow substitutions that
13529 should not be allowed, we may allow argument deductions that should
13530 not succeed, and therefore report ambiguous overload situations
13531 where there are none. In theory, we could allow the substitution,
13532 but indicate that it should have failed, and allow our caller to
13533 make sure that the right thing happens, but we don't try to do this
13536 This function is used for dealing with types, decls and the like;
13537 for expressions, use tsubst_expr or tsubst_copy. */
13540 tsubst (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
13542 enum tree_code code
;
13543 tree type
, r
= NULL_TREE
;
13545 if (t
== NULL_TREE
|| t
== error_mark_node
13546 || t
== integer_type_node
13547 || t
== void_type_node
13548 || t
== char_type_node
13549 || t
== unknown_type_node
13550 || TREE_CODE (t
) == NAMESPACE_DECL
13551 || TREE_CODE (t
) == TRANSLATION_UNIT_DECL
)
13555 return tsubst_decl (t
, args
, complain
);
13557 if (args
== NULL_TREE
)
13560 code
= TREE_CODE (t
);
13562 if (code
== IDENTIFIER_NODE
)
13563 type
= IDENTIFIER_TYPE_VALUE (t
);
13565 type
= TREE_TYPE (t
);
13567 gcc_assert (type
!= unknown_type_node
);
13569 /* Reuse typedefs. We need to do this to handle dependent attributes,
13570 such as attribute aligned. */
13572 && typedef_variant_p (t
))
13574 tree decl
= TYPE_NAME (t
);
13576 if (alias_template_specialization_p (t
))
13578 /* DECL represents an alias template and we want to
13580 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
13581 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
13582 r
= instantiate_alias_template (tmpl
, gen_args
, complain
);
13584 else if (DECL_CLASS_SCOPE_P (decl
)
13585 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl
))
13586 && uses_template_parms (DECL_CONTEXT (decl
)))
13588 tree tmpl
= most_general_template (DECL_TI_TEMPLATE (decl
));
13589 tree gen_args
= tsubst (DECL_TI_ARGS (decl
), args
, complain
, in_decl
);
13590 r
= retrieve_specialization (tmpl
, gen_args
, 0);
13592 else if (DECL_FUNCTION_SCOPE_P (decl
)
13593 && DECL_TEMPLATE_INFO (DECL_CONTEXT (decl
))
13594 && uses_template_parms (DECL_TI_ARGS (DECL_CONTEXT (decl
))))
13595 r
= retrieve_local_specialization (decl
);
13597 /* The typedef is from a non-template context. */
13603 r
= cp_build_qualified_type_real
13604 (r
, cp_type_quals (t
) | cp_type_quals (r
),
13605 complain
| tf_ignore_bad_quals
);
13610 /* We don't have an instantiation yet, so drop the typedef. */
13611 int quals
= cp_type_quals (t
);
13612 t
= DECL_ORIGINAL_TYPE (decl
);
13613 t
= cp_build_qualified_type_real (t
, quals
,
13614 complain
| tf_ignore_bad_quals
);
13618 bool fndecl_type
= (complain
& tf_fndecl_type
);
13619 complain
&= ~tf_fndecl_type
;
13622 && code
!= TYPENAME_TYPE
13623 && code
!= TEMPLATE_TYPE_PARM
13624 && code
!= TEMPLATE_PARM_INDEX
13625 && code
!= IDENTIFIER_NODE
13626 && code
!= FUNCTION_TYPE
13627 && code
!= METHOD_TYPE
)
13628 type
= tsubst (type
, args
, complain
, in_decl
);
13629 if (type
== error_mark_node
)
13630 return error_mark_node
;
13636 case ENUMERAL_TYPE
:
13637 return tsubst_aggr_type (t
, args
, complain
, in_decl
,
13638 /*entering_scope=*/0);
13641 case IDENTIFIER_NODE
:
13652 if (t
== integer_type_node
)
13655 if (TREE_CODE (TYPE_MIN_VALUE (t
)) == INTEGER_CST
13656 && TREE_CODE (TYPE_MAX_VALUE (t
)) == INTEGER_CST
)
13660 tree max
, omax
= TREE_OPERAND (TYPE_MAX_VALUE (t
), 0);
13662 max
= tsubst_expr (omax
, args
, complain
, in_decl
,
13663 /*integral_constant_expression_p=*/false);
13665 /* Fix up type of the magic NOP_EXPR with TREE_SIDE_EFFECTS if
13667 if (TREE_CODE (max
) == NOP_EXPR
13668 && TREE_SIDE_EFFECTS (omax
)
13669 && !TREE_TYPE (max
))
13670 TREE_TYPE (max
) = TREE_TYPE (TREE_OPERAND (max
, 0));
13672 /* If we're in a partial instantiation, preserve the magic NOP_EXPR
13673 with TREE_SIDE_EFFECTS that indicates this is not an integral
13674 constant expression. */
13675 if (processing_template_decl
13676 && TREE_SIDE_EFFECTS (omax
) && TREE_CODE (omax
) == NOP_EXPR
)
13678 gcc_assert (TREE_CODE (max
) == NOP_EXPR
);
13679 TREE_SIDE_EFFECTS (max
) = 1;
13682 return compute_array_index_type (NULL_TREE
, max
, complain
);
13685 case TEMPLATE_TYPE_PARM
:
13686 case TEMPLATE_TEMPLATE_PARM
:
13687 case BOUND_TEMPLATE_TEMPLATE_PARM
:
13688 case TEMPLATE_PARM_INDEX
:
13693 tree arg
= NULL_TREE
;
13695 /* Early in template argument deduction substitution, we don't
13696 want to reduce the level of 'auto', or it will be confused
13697 with a normal template parm in subsequent deduction. */
13698 if (is_auto (t
) && (complain
& tf_partial
))
13703 gcc_assert (TREE_VEC_LENGTH (args
) > 0);
13704 template_parm_level_and_index (t
, &level
, &idx
);
13706 levels
= TMPL_ARGS_DEPTH (args
);
13707 if (level
<= levels
13708 && TREE_VEC_LENGTH (TMPL_ARGS_LEVEL (args
, level
)) > 0)
13710 arg
= TMPL_ARG (args
, level
, idx
);
13712 if (arg
&& TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
13714 /* See through ARGUMENT_PACK_SELECT arguments. */
13715 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
13716 /* If the selected argument is an expansion E, that most
13717 likely means we were called from
13718 gen_elem_of_pack_expansion_instantiation during the
13719 substituting of pack an argument pack (which Ith
13720 element is a pack expansion, where I is
13721 ARGUMENT_PACK_SELECT_INDEX) into a pack expansion.
13722 In this case, the Ith element resulting from this
13723 substituting is going to be a pack expansion, which
13724 pattern is the pattern of E. Let's return the
13726 gen_elem_of_pack_expansion_instantiation will
13727 build the resulting pack expansion from it. */
13728 if (PACK_EXPANSION_P (arg
))
13730 /* Make sure we aren't throwing away arg info. */
13731 gcc_assert (!PACK_EXPANSION_EXTRA_ARGS (arg
));
13732 arg
= PACK_EXPANSION_PATTERN (arg
);
13737 if (arg
== error_mark_node
)
13738 return error_mark_node
;
13739 else if (arg
!= NULL_TREE
)
13741 if (ARGUMENT_PACK_P (arg
))
13742 /* If ARG is an argument pack, we don't actually want to
13743 perform a substitution here, because substitutions
13744 for argument packs are only done
13745 element-by-element. We can get to this point when
13746 substituting the type of a non-type template
13747 parameter pack, when that type actually contains
13748 template parameter packs from an outer template, e.g.,
13750 template<typename... Types> struct A {
13751 template<Types... Values> struct B { };
13755 if (code
== TEMPLATE_TYPE_PARM
)
13758 gcc_assert (TYPE_P (arg
));
13760 quals
= cp_type_quals (arg
) | cp_type_quals (t
);
13762 return cp_build_qualified_type_real
13763 (arg
, quals
, complain
| tf_ignore_bad_quals
);
13765 else if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
13767 /* We are processing a type constructed from a
13768 template template parameter. */
13769 tree argvec
= tsubst (TYPE_TI_ARGS (t
),
13770 args
, complain
, in_decl
);
13771 if (argvec
== error_mark_node
)
13772 return error_mark_node
;
13774 gcc_assert (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
13775 || TREE_CODE (arg
) == TEMPLATE_DECL
13776 || TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
);
13778 if (TREE_CODE (arg
) == UNBOUND_CLASS_TEMPLATE
)
13779 /* Consider this code:
13781 template <template <class> class Template>
13783 template <class Arg> using Bind = Template<Arg>;
13786 template <template <class> class Template, class Arg>
13787 using Instantiate = Template<Arg>; //#0
13789 template <template <class> class Template,
13792 Instantiate<Internal<Template>::template Bind,
13795 When #1 is parsed, the
13796 BOUND_TEMPLATE_TEMPLATE_PARM representing the
13797 parameter `Template' in #0 matches the
13798 UNBOUND_CLASS_TEMPLATE representing the argument
13799 `Internal<Template>::template Bind'; We then want
13800 to assemble the type `Bind<Argument>' that can't
13801 be fully created right now, because
13802 `Internal<Template>' not being complete, the Bind
13803 template cannot be looked up in that context. So
13804 we need to "store" `Bind<Argument>' for later
13805 when the context of Bind becomes complete. Let's
13806 store that in a TYPENAME_TYPE. */
13807 return make_typename_type (TYPE_CONTEXT (arg
),
13808 build_nt (TEMPLATE_ID_EXPR
,
13809 TYPE_IDENTIFIER (arg
),
13814 /* We can get a TEMPLATE_TEMPLATE_PARM here when we
13815 are resolving nested-types in the signature of a
13816 member function templates. Otherwise ARG is a
13817 TEMPLATE_DECL and is the real template to be
13819 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
13820 arg
= TYPE_NAME (arg
);
13822 r
= lookup_template_class (arg
,
13824 DECL_CONTEXT (arg
),
13825 /*entering_scope=*/0,
13827 return cp_build_qualified_type_real
13828 (r
, cp_type_quals (t
) | cp_type_quals (r
), complain
);
13830 else if (code
== TEMPLATE_TEMPLATE_PARM
)
13833 /* TEMPLATE_PARM_INDEX. */
13834 return convert_from_reference (unshare_expr (arg
));
13838 /* This can happen during the attempted tsubst'ing in
13839 unify. This means that we don't yet have any information
13840 about the template parameter in question. */
13843 /* If we get here, we must have been looking at a parm for a
13844 more deeply nested template. Make a new version of this
13845 template parameter, but with a lower level. */
13848 case TEMPLATE_TYPE_PARM
:
13849 case TEMPLATE_TEMPLATE_PARM
:
13850 case BOUND_TEMPLATE_TEMPLATE_PARM
:
13851 if (cp_type_quals (t
))
13853 r
= tsubst (TYPE_MAIN_VARIANT (t
), args
, complain
, in_decl
);
13854 r
= cp_build_qualified_type_real
13855 (r
, cp_type_quals (t
),
13856 complain
| (code
== TEMPLATE_TYPE_PARM
13857 ? tf_ignore_bad_quals
: 0));
13859 else if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
13860 && PLACEHOLDER_TYPE_CONSTRAINTS (t
)
13861 && (r
= (TEMPLATE_PARM_DESCENDANTS
13862 (TEMPLATE_TYPE_PARM_INDEX (t
))))
13863 && (r
= TREE_TYPE (r
))
13864 && !PLACEHOLDER_TYPE_CONSTRAINTS (r
))
13865 /* Break infinite recursion when substituting the constraints
13866 of a constrained placeholder. */;
13870 TEMPLATE_TYPE_PARM_INDEX (r
)
13871 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (t
),
13872 r
, levels
, args
, complain
);
13873 TYPE_STUB_DECL (r
) = TYPE_NAME (r
) = TEMPLATE_TYPE_DECL (r
);
13874 TYPE_MAIN_VARIANT (r
) = r
;
13875 TYPE_POINTER_TO (r
) = NULL_TREE
;
13876 TYPE_REFERENCE_TO (r
) = NULL_TREE
;
13878 if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
13880 /* Propagate constraints on placeholders. */
13881 if (tree constr
= PLACEHOLDER_TYPE_CONSTRAINTS (t
))
13882 PLACEHOLDER_TYPE_CONSTRAINTS (r
)
13883 = tsubst_constraint (constr
, args
, complain
, in_decl
);
13884 else if (tree pl
= CLASS_PLACEHOLDER_TEMPLATE (t
))
13886 if (DECL_TEMPLATE_TEMPLATE_PARM_P (pl
))
13887 pl
= tsubst (pl
, args
, complain
, in_decl
);
13888 CLASS_PLACEHOLDER_TEMPLATE (r
) = pl
;
13892 if (TREE_CODE (r
) == TEMPLATE_TEMPLATE_PARM
)
13893 /* We have reduced the level of the template
13894 template parameter, but not the levels of its
13895 template parameters, so canonical_type_parameter
13896 will not be able to find the canonical template
13897 template parameter for this level. Thus, we
13898 require structural equality checking to compare
13899 TEMPLATE_TEMPLATE_PARMs. */
13900 SET_TYPE_STRUCTURAL_EQUALITY (r
);
13901 else if (TYPE_STRUCTURAL_EQUALITY_P (t
))
13902 SET_TYPE_STRUCTURAL_EQUALITY (r
);
13904 TYPE_CANONICAL (r
) = canonical_type_parameter (r
);
13906 if (code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
13908 tree tinfo
= TYPE_TEMPLATE_INFO (t
);
13909 /* We might need to substitute into the types of non-type
13910 template parameters. */
13911 tree tmpl
= tsubst (TI_TEMPLATE (tinfo
), args
,
13912 complain
, in_decl
);
13913 if (tmpl
== error_mark_node
)
13914 return error_mark_node
;
13915 tree argvec
= tsubst (TI_ARGS (tinfo
), args
,
13916 complain
, in_decl
);
13917 if (argvec
== error_mark_node
)
13918 return error_mark_node
;
13920 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (r
)
13921 = build_template_info (tmpl
, argvec
);
13926 case TEMPLATE_PARM_INDEX
:
13927 /* OK, now substitute the type of the non-type parameter. We
13928 couldn't do it earlier because it might be an auto parameter,
13929 and we wouldn't need to if we had an argument. */
13930 type
= tsubst (type
, args
, complain
, in_decl
);
13931 if (type
== error_mark_node
)
13932 return error_mark_node
;
13933 r
= reduce_template_parm_level (t
, type
, levels
, args
, complain
);
13937 gcc_unreachable ();
13945 tree purpose
, value
, chain
;
13947 if (t
== void_list_node
)
13950 purpose
= TREE_PURPOSE (t
);
13953 purpose
= tsubst (purpose
, args
, complain
, in_decl
);
13954 if (purpose
== error_mark_node
)
13955 return error_mark_node
;
13957 value
= TREE_VALUE (t
);
13960 value
= tsubst (value
, args
, complain
, in_decl
);
13961 if (value
== error_mark_node
)
13962 return error_mark_node
;
13964 chain
= TREE_CHAIN (t
);
13965 if (chain
&& chain
!= void_type_node
)
13967 chain
= tsubst (chain
, args
, complain
, in_decl
);
13968 if (chain
== error_mark_node
)
13969 return error_mark_node
;
13971 if (purpose
== TREE_PURPOSE (t
)
13972 && value
== TREE_VALUE (t
)
13973 && chain
== TREE_CHAIN (t
))
13975 return hash_tree_cons (purpose
, value
, chain
);
13979 /* We should never be tsubsting a binfo. */
13980 gcc_unreachable ();
13983 /* A vector of template arguments. */
13984 gcc_assert (!type
);
13985 return tsubst_template_args (t
, args
, complain
, in_decl
);
13988 case REFERENCE_TYPE
:
13990 if (type
== TREE_TYPE (t
) && TREE_CODE (type
) != METHOD_TYPE
)
13995 Type deduction may fail for any of the following
13998 -- Attempting to create a pointer to reference type.
13999 -- Attempting to create a reference to a reference type or
14000 a reference to void.
14002 Core issue 106 says that creating a reference to a reference
14003 during instantiation is no longer a cause for failure. We
14004 only enforce this check in strict C++98 mode. */
14005 if ((TREE_CODE (type
) == REFERENCE_TYPE
14006 && (((cxx_dialect
== cxx98
) && flag_iso
) || code
!= REFERENCE_TYPE
))
14007 || (code
== REFERENCE_TYPE
&& VOID_TYPE_P (type
)))
14009 static location_t last_loc
;
14011 /* We keep track of the last time we issued this error
14012 message to avoid spewing a ton of messages during a
14013 single bad template instantiation. */
14014 if (complain
& tf_error
14015 && last_loc
!= input_location
)
14017 if (VOID_TYPE_P (type
))
14018 error ("forming reference to void");
14019 else if (code
== POINTER_TYPE
)
14020 error ("forming pointer to reference type %qT", type
);
14022 error ("forming reference to reference type %qT", type
);
14023 last_loc
= input_location
;
14026 return error_mark_node
;
14028 else if (TREE_CODE (type
) == FUNCTION_TYPE
14029 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
14030 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
14032 if (complain
& tf_error
)
14034 if (code
== POINTER_TYPE
)
14035 error ("forming pointer to qualified function type %qT",
14038 error ("forming reference to qualified function type %qT",
14041 return error_mark_node
;
14043 else if (code
== POINTER_TYPE
)
14045 r
= build_pointer_type (type
);
14046 if (TREE_CODE (type
) == METHOD_TYPE
)
14047 r
= build_ptrmemfunc_type (r
);
14049 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
14050 /* In C++0x, during template argument substitution, when there is an
14051 attempt to create a reference to a reference type, reference
14052 collapsing is applied as described in [14.3.1/4 temp.arg.type]:
14054 "If a template-argument for a template-parameter T names a type
14055 that is a reference to a type A, an attempt to create the type
14056 'lvalue reference to cv T' creates the type 'lvalue reference to
14057 A,' while an attempt to create the type type rvalue reference to
14058 cv T' creates the type T"
14060 r
= cp_build_reference_type
14062 TYPE_REF_IS_RVALUE (t
) && TYPE_REF_IS_RVALUE (type
));
14064 r
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
14065 r
= cp_build_qualified_type_real (r
, cp_type_quals (t
), complain
);
14067 if (r
!= error_mark_node
)
14068 /* Will this ever be needed for TYPE_..._TO values? */
14075 r
= tsubst (TYPE_OFFSET_BASETYPE (t
), args
, complain
, in_decl
);
14076 if (r
== error_mark_node
|| !MAYBE_CLASS_TYPE_P (r
))
14080 Type deduction may fail for any of the following
14083 -- Attempting to create "pointer to member of T" when T
14084 is not a class type. */
14085 if (complain
& tf_error
)
14086 error ("creating pointer to member of non-class type %qT", r
);
14087 return error_mark_node
;
14089 if (TREE_CODE (type
) == REFERENCE_TYPE
)
14091 if (complain
& tf_error
)
14092 error ("creating pointer to member reference type %qT", type
);
14093 return error_mark_node
;
14095 if (VOID_TYPE_P (type
))
14097 if (complain
& tf_error
)
14098 error ("creating pointer to member of type void");
14099 return error_mark_node
;
14101 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
14102 if (TREE_CODE (type
) == FUNCTION_TYPE
)
14104 /* The type of the implicit object parameter gets its
14105 cv-qualifiers from the FUNCTION_TYPE. */
14108 = build_memfn_type (type
, r
, type_memfn_quals (type
),
14109 type_memfn_rqual (type
));
14110 memptr
= build_ptrmemfunc_type (build_pointer_type (method_type
));
14111 return cp_build_qualified_type_real (memptr
, cp_type_quals (t
),
14115 return cp_build_qualified_type_real (build_ptrmem_type (r
, type
),
14119 case FUNCTION_TYPE
:
14124 fntype
= tsubst_function_type (t
, args
, complain
, in_decl
);
14125 if (fntype
== error_mark_node
)
14126 return error_mark_node
;
14128 /* Substitute the exception specification. */
14129 specs
= tsubst_exception_specification (t
, args
, complain
, in_decl
,
14130 /*defer_ok*/fndecl_type
);
14131 if (specs
== error_mark_node
)
14132 return error_mark_node
;
14134 fntype
= build_exception_variant (fntype
, specs
);
14139 tree domain
= tsubst (TYPE_DOMAIN (t
), args
, complain
, in_decl
);
14140 if (domain
== error_mark_node
)
14141 return error_mark_node
;
14143 /* As an optimization, we avoid regenerating the array type if
14144 it will obviously be the same as T. */
14145 if (type
== TREE_TYPE (t
) && domain
== TYPE_DOMAIN (t
))
14148 /* These checks should match the ones in create_array_type_for_decl.
14152 The deduction may fail for any of the following reasons:
14154 -- Attempting to create an array with an element type that
14155 is void, a function type, or a reference type, or [DR337]
14156 an abstract class type. */
14157 if (VOID_TYPE_P (type
)
14158 || TREE_CODE (type
) == FUNCTION_TYPE
14159 || (TREE_CODE (type
) == ARRAY_TYPE
14160 && TYPE_DOMAIN (type
) == NULL_TREE
)
14161 || TREE_CODE (type
) == REFERENCE_TYPE
)
14163 if (complain
& tf_error
)
14164 error ("creating array of %qT", type
);
14165 return error_mark_node
;
14168 if (abstract_virtuals_error_sfinae (ACU_ARRAY
, type
, complain
))
14169 return error_mark_node
;
14171 r
= build_cplus_array_type (type
, domain
);
14173 if (TYPE_USER_ALIGN (t
))
14175 SET_TYPE_ALIGN (r
, TYPE_ALIGN (t
));
14176 TYPE_USER_ALIGN (r
) = 1;
14182 case TYPENAME_TYPE
:
14184 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
14185 in_decl
, /*entering_scope=*/1);
14186 if (ctx
== error_mark_node
)
14187 return error_mark_node
;
14189 tree f
= tsubst_copy (TYPENAME_TYPE_FULLNAME (t
), args
,
14190 complain
, in_decl
);
14191 if (f
== error_mark_node
)
14192 return error_mark_node
;
14194 if (!MAYBE_CLASS_TYPE_P (ctx
))
14196 if (complain
& tf_error
)
14197 error ("%qT is not a class, struct, or union type", ctx
);
14198 return error_mark_node
;
14200 else if (!uses_template_parms (ctx
) && !TYPE_BEING_DEFINED (ctx
))
14202 /* Normally, make_typename_type does not require that the CTX
14203 have complete type in order to allow things like:
14205 template <class T> struct S { typename S<T>::X Y; };
14207 But, such constructs have already been resolved by this
14208 point, so here CTX really should have complete type, unless
14209 it's a partial instantiation. */
14210 ctx
= complete_type (ctx
);
14211 if (!COMPLETE_TYPE_P (ctx
))
14213 if (complain
& tf_error
)
14214 cxx_incomplete_type_error (NULL_TREE
, ctx
);
14215 return error_mark_node
;
14219 f
= make_typename_type (ctx
, f
, typename_type
,
14220 complain
| tf_keep_type_decl
);
14221 if (f
== error_mark_node
)
14223 if (TREE_CODE (f
) == TYPE_DECL
)
14225 complain
|= tf_ignore_bad_quals
;
14229 if (TREE_CODE (f
) != TYPENAME_TYPE
)
14231 if (TYPENAME_IS_ENUM_P (t
) && TREE_CODE (f
) != ENUMERAL_TYPE
)
14233 if (complain
& tf_error
)
14234 error ("%qT resolves to %qT, which is not an enumeration type",
14237 return error_mark_node
;
14239 else if (TYPENAME_IS_CLASS_P (t
) && !CLASS_TYPE_P (f
))
14241 if (complain
& tf_error
)
14242 error ("%qT resolves to %qT, which is is not a class type",
14245 return error_mark_node
;
14249 return cp_build_qualified_type_real
14250 (f
, cp_type_quals (f
) | cp_type_quals (t
), complain
);
14253 case UNBOUND_CLASS_TEMPLATE
:
14255 tree ctx
= tsubst_aggr_type (TYPE_CONTEXT (t
), args
, complain
,
14256 in_decl
, /*entering_scope=*/1);
14257 tree name
= TYPE_IDENTIFIER (t
);
14258 tree parm_list
= DECL_TEMPLATE_PARMS (TYPE_NAME (t
));
14260 if (ctx
== error_mark_node
|| name
== error_mark_node
)
14261 return error_mark_node
;
14264 parm_list
= tsubst_template_parms (parm_list
, args
, complain
);
14265 return make_unbound_class_template (ctx
, name
, parm_list
, complain
);
14272 ++cp_unevaluated_operand
;
14273 ++c_inhibit_evaluation_warnings
;
14275 type
= tsubst_expr (TYPEOF_TYPE_EXPR (t
), args
,
14277 /*integral_constant_expression_p=*/false);
14279 --cp_unevaluated_operand
;
14280 --c_inhibit_evaluation_warnings
;
14282 type
= finish_typeof (type
);
14283 return cp_build_qualified_type_real (type
,
14285 | cp_type_quals (type
),
14289 case DECLTYPE_TYPE
:
14293 ++cp_unevaluated_operand
;
14294 ++c_inhibit_evaluation_warnings
;
14296 type
= tsubst_copy_and_build (DECLTYPE_TYPE_EXPR (t
), args
,
14297 complain
|tf_decltype
, in_decl
,
14298 /*function_p*/false,
14299 /*integral_constant_expression*/false);
14301 if (DECLTYPE_FOR_INIT_CAPTURE (t
))
14303 if (type
== NULL_TREE
)
14305 if (complain
& tf_error
)
14306 error ("empty initializer in lambda init-capture");
14307 type
= error_mark_node
;
14309 else if (TREE_CODE (type
) == TREE_LIST
)
14310 type
= build_x_compound_expr_from_list (type
, ELK_INIT
, complain
);
14313 --cp_unevaluated_operand
;
14314 --c_inhibit_evaluation_warnings
;
14316 if (DECLTYPE_FOR_LAMBDA_CAPTURE (t
))
14317 type
= lambda_capture_field_type (type
,
14318 DECLTYPE_FOR_INIT_CAPTURE (t
),
14319 DECLTYPE_FOR_REF_CAPTURE (t
));
14320 else if (DECLTYPE_FOR_LAMBDA_PROXY (t
))
14321 type
= lambda_proxy_type (type
);
14324 bool id
= DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
);
14325 if (id
&& TREE_CODE (DECLTYPE_TYPE_EXPR (t
)) == BIT_NOT_EXPR
14327 /* In a template ~id could be either a complement expression
14328 or an unqualified-id naming a destructor; if instantiating
14329 it produces an expression, it's not an id-expression or
14332 type
= finish_decltype_type (type
, id
, complain
);
14334 return cp_build_qualified_type_real (type
,
14336 | cp_type_quals (type
),
14337 complain
| tf_ignore_bad_quals
);
14340 case UNDERLYING_TYPE
:
14342 tree type
= tsubst (UNDERLYING_TYPE_TYPE (t
), args
,
14343 complain
, in_decl
);
14344 return finish_underlying_type (type
);
14347 case TYPE_ARGUMENT_PACK
:
14348 case NONTYPE_ARGUMENT_PACK
:
14352 if (code
== NONTYPE_ARGUMENT_PACK
)
14353 r
= make_node (code
);
14355 r
= cxx_make_type (code
);
14357 tree pack_args
= ARGUMENT_PACK_ARGS (t
);
14358 pack_args
= tsubst_template_args (pack_args
, args
, complain
, in_decl
);
14359 SET_ARGUMENT_PACK_ARGS (r
, pack_args
);
14377 /* We should use one of the expression tsubsts for these codes. */
14378 gcc_unreachable ();
14381 sorry ("use of %qs in template", get_tree_code_name (code
));
14382 return error_mark_node
;
14386 /* tsubst a BASELINK. OBJECT_TYPE, if non-NULL, is the type of the
14387 expression on the left-hand side of the "." or "->" operator. A
14388 baselink indicates a function from a base class. Both the
14389 BASELINK_ACCESS_BINFO and the base class referenced may indicate
14390 bases of the template class, rather than the instantiated class.
14391 In addition, lookups that were not ambiguous before may be
14392 ambiguous now. Therefore, we perform the lookup again. */
14395 tsubst_baselink (tree baselink
, tree object_type
,
14396 tree args
, tsubst_flags_t complain
, tree in_decl
)
14398 bool qualified
= BASELINK_QUALIFIED_P (baselink
);
14400 tree qualifying_scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink
));
14401 qualifying_scope
= tsubst (qualifying_scope
, args
, complain
, in_decl
);
14403 tree optype
= BASELINK_OPTYPE (baselink
);
14404 optype
= tsubst (optype
, args
, complain
, in_decl
);
14406 tree template_args
= NULL_TREE
;
14407 bool template_id_p
= false;
14408 tree fns
= BASELINK_FUNCTIONS (baselink
);
14409 if (TREE_CODE (fns
) == TEMPLATE_ID_EXPR
)
14411 template_id_p
= true;
14412 template_args
= TREE_OPERAND (fns
, 1);
14413 fns
= TREE_OPERAND (fns
, 0);
14415 template_args
= tsubst_template_args (template_args
, args
,
14416 complain
, in_decl
);
14419 tree name
= OVL_NAME (fns
);
14420 if (IDENTIFIER_CONV_OP_P (name
))
14421 name
= make_conv_op_name (optype
);
14423 baselink
= lookup_fnfields (qualifying_scope
, name
, /*protect=*/1);
14426 if ((complain
& tf_error
) && constructor_name_p (name
, qualifying_scope
))
14427 error ("cannot call constructor %<%T::%D%> directly",
14428 qualifying_scope
, name
);
14429 return error_mark_node
;
14432 /* If lookup found a single function, mark it as used at this point.
14433 (If it lookup found multiple functions the one selected later by
14434 overload resolution will be marked as used at that point.) */
14435 if (BASELINK_P (baselink
))
14436 fns
= BASELINK_FUNCTIONS (baselink
);
14437 if (!template_id_p
&& !really_overloaded_fn (fns
)
14438 && !mark_used (OVL_FIRST (fns
), complain
) && !(complain
& tf_error
))
14439 return error_mark_node
;
14441 if (BASELINK_P (baselink
))
14443 /* Add back the template arguments, if present. */
14445 BASELINK_FUNCTIONS (baselink
)
14446 = build2 (TEMPLATE_ID_EXPR
, unknown_type_node
,
14447 BASELINK_FUNCTIONS (baselink
), template_args
);
14449 /* Update the conversion operator type. */
14450 BASELINK_OPTYPE (baselink
) = optype
;
14454 object_type
= current_class_type
;
14456 if (qualified
|| name
== complete_dtor_identifier
)
14458 baselink
= adjust_result_of_qualified_name_lookup (baselink
,
14462 /* We need to call adjust_result_of_qualified_name_lookup in case the
14463 destructor names a base class, but we unset BASELINK_QUALIFIED_P
14464 so that we still get virtual function binding. */
14465 BASELINK_QUALIFIED_P (baselink
) = false;
14471 /* Like tsubst_expr for a SCOPE_REF, given by QUALIFIED_ID. DONE is
14472 true if the qualified-id will be a postfix-expression in-and-of
14473 itself; false if more of the postfix-expression follows the
14474 QUALIFIED_ID. ADDRESS_P is true if the qualified-id is the operand
14478 tsubst_qualified_id (tree qualified_id
, tree args
,
14479 tsubst_flags_t complain
, tree in_decl
,
14480 bool done
, bool address_p
)
14486 tree template_args
;
14487 location_t loc
= UNKNOWN_LOCATION
;
14489 gcc_assert (TREE_CODE (qualified_id
) == SCOPE_REF
);
14491 /* Figure out what name to look up. */
14492 name
= TREE_OPERAND (qualified_id
, 1);
14493 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
14495 is_template
= true;
14496 loc
= EXPR_LOCATION (name
);
14497 template_args
= TREE_OPERAND (name
, 1);
14499 template_args
= tsubst_template_args (template_args
, args
,
14500 complain
, in_decl
);
14501 if (template_args
== error_mark_node
)
14502 return error_mark_node
;
14503 name
= TREE_OPERAND (name
, 0);
14507 is_template
= false;
14508 template_args
= NULL_TREE
;
14511 /* Substitute into the qualifying scope. When there are no ARGS, we
14512 are just trying to simplify a non-dependent expression. In that
14513 case the qualifying scope may be dependent, and, in any case,
14514 substituting will not help. */
14515 scope
= TREE_OPERAND (qualified_id
, 0);
14518 scope
= tsubst (scope
, args
, complain
, in_decl
);
14519 expr
= tsubst_copy (name
, args
, complain
, in_decl
);
14524 if (dependent_scope_p (scope
))
14527 expr
= build_min_nt_loc (loc
, TEMPLATE_ID_EXPR
, expr
, template_args
);
14528 tree r
= build_qualified_name (NULL_TREE
, scope
, expr
,
14529 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
));
14530 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (qualified_id
);
14534 if (!BASELINK_P (name
) && !DECL_P (expr
))
14536 if (TREE_CODE (expr
) == BIT_NOT_EXPR
)
14538 /* A BIT_NOT_EXPR is used to represent a destructor. */
14539 if (!check_dtor_name (scope
, TREE_OPERAND (expr
, 0)))
14541 error ("qualifying type %qT does not match destructor name ~%qT",
14542 scope
, TREE_OPERAND (expr
, 0));
14543 expr
= error_mark_node
;
14546 expr
= lookup_qualified_name (scope
, complete_dtor_identifier
,
14547 /*is_type_p=*/0, false);
14550 expr
= lookup_qualified_name (scope
, expr
, /*is_type_p=*/0, false);
14551 if (TREE_CODE (TREE_CODE (expr
) == TEMPLATE_DECL
14552 ? DECL_TEMPLATE_RESULT (expr
) : expr
) == TYPE_DECL
)
14554 if (complain
& tf_error
)
14556 error ("dependent-name %qE is parsed as a non-type, but "
14557 "instantiation yields a type", qualified_id
);
14558 inform (input_location
, "say %<typename %E%> if a type is meant", qualified_id
);
14560 return error_mark_node
;
14566 check_accessibility_of_qualified_id (expr
, /*object_type=*/NULL_TREE
,
14568 /* Remember that there was a reference to this entity. */
14569 if (!mark_used (expr
, complain
) && !(complain
& tf_error
))
14570 return error_mark_node
;
14573 if (expr
== error_mark_node
|| TREE_CODE (expr
) == TREE_LIST
)
14575 if (complain
& tf_error
)
14576 qualified_name_lookup_error (scope
,
14577 TREE_OPERAND (qualified_id
, 1),
14578 expr
, input_location
);
14579 return error_mark_node
;
14584 if (variable_template_p (expr
))
14585 expr
= lookup_and_finish_template_variable (expr
, template_args
,
14588 expr
= lookup_template_function (expr
, template_args
);
14591 if (expr
== error_mark_node
&& complain
& tf_error
)
14592 qualified_name_lookup_error (scope
, TREE_OPERAND (qualified_id
, 1),
14593 expr
, input_location
);
14594 else if (TYPE_P (scope
))
14596 expr
= (adjust_result_of_qualified_name_lookup
14597 (expr
, scope
, current_nonlambda_class_type ()));
14598 expr
= (finish_qualified_id_expr
14599 (scope
, expr
, done
, address_p
&& PTRMEM_OK_P (qualified_id
),
14600 QUALIFIED_NAME_IS_TEMPLATE (qualified_id
),
14601 /*template_arg_p=*/false, complain
));
14604 /* Expressions do not generally have reference type. */
14605 if (TREE_CODE (expr
) != SCOPE_REF
14606 /* However, if we're about to form a pointer-to-member, we just
14607 want the referenced member referenced. */
14608 && TREE_CODE (expr
) != OFFSET_REF
)
14609 expr
= convert_from_reference (expr
);
14611 if (REF_PARENTHESIZED_P (qualified_id
))
14612 expr
= force_paren_expr (expr
);
14617 /* tsubst the initializer for a VAR_DECL. INIT is the unsubstituted
14618 initializer, DECL is the substituted VAR_DECL. Other arguments are as
14622 tsubst_init (tree init
, tree decl
, tree args
,
14623 tsubst_flags_t complain
, tree in_decl
)
14628 init
= tsubst_expr (init
, args
, complain
, in_decl
, false);
14630 if (!init
&& TREE_TYPE (decl
) != error_mark_node
)
14632 /* If we had an initializer but it
14633 instantiated to nothing,
14634 value-initialize the object. This will
14635 only occur when the initializer was a
14636 pack expansion where the parameter packs
14637 used in that expansion were of length
14639 init
= build_value_init (TREE_TYPE (decl
),
14641 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
14642 init
= get_target_expr_sfinae (init
, complain
);
14643 if (TREE_CODE (init
) == TARGET_EXPR
)
14644 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
14650 /* Like tsubst, but deals with expressions. This function just replaces
14651 template parms; to finish processing the resultant expression, use
14652 tsubst_copy_and_build or tsubst_expr. */
14655 tsubst_copy (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
14657 enum tree_code code
;
14660 if (t
== NULL_TREE
|| t
== error_mark_node
|| args
== NULL_TREE
)
14663 code
= TREE_CODE (t
);
14668 r
= retrieve_local_specialization (t
);
14670 if (r
== NULL_TREE
)
14672 /* We get here for a use of 'this' in an NSDMI. */
14673 if (DECL_NAME (t
) == this_identifier
&& current_class_ptr
)
14674 return current_class_ptr
;
14676 /* This can happen for a parameter name used later in a function
14677 declaration (such as in a late-specified return type). Just
14678 make a dummy decl, since it's only used for its type. */
14679 gcc_assert (cp_unevaluated_operand
!= 0);
14680 r
= tsubst_decl (t
, args
, complain
);
14681 /* Give it the template pattern as its context; its true context
14682 hasn't been instantiated yet and this is good enough for
14684 DECL_CONTEXT (r
) = DECL_CONTEXT (t
);
14687 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
14688 r
= ARGUMENT_PACK_SELECT_ARG (r
);
14689 if (!mark_used (r
, complain
) && !(complain
& tf_error
))
14690 return error_mark_node
;
14698 if (DECL_TEMPLATE_PARM_P (t
))
14699 return tsubst_copy (DECL_INITIAL (t
), args
, complain
, in_decl
);
14700 /* There is no need to substitute into namespace-scope
14702 if (DECL_NAMESPACE_SCOPE_P (t
))
14704 /* If ARGS is NULL, then T is known to be non-dependent. */
14705 if (args
== NULL_TREE
)
14706 return scalar_constant_value (t
);
14708 /* Unfortunately, we cannot just call lookup_name here.
14711 template <int I> int f() {
14713 struct S { void g() { E e = a; } };
14716 When we instantiate f<7>::S::g(), say, lookup_name is not
14717 clever enough to find f<7>::a. */
14719 = tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
14720 /*entering_scope=*/0);
14722 for (v
= TYPE_VALUES (enum_type
);
14724 v
= TREE_CHAIN (v
))
14725 if (TREE_PURPOSE (v
) == DECL_NAME (t
))
14726 return TREE_VALUE (v
);
14728 /* We didn't find the name. That should never happen; if
14729 name-lookup found it during preliminary parsing, we
14730 should find it again here during instantiation. */
14731 gcc_unreachable ();
14736 if (PACK_EXPANSION_P (TREE_TYPE (t
)))
14738 /* Check for a local specialization set up by
14739 tsubst_pack_expansion. */
14740 if (tree r
= retrieve_local_specialization (t
))
14742 if (TREE_CODE (r
) == ARGUMENT_PACK_SELECT
)
14743 r
= ARGUMENT_PACK_SELECT_ARG (r
);
14747 /* When retrieving a capture pack from a generic lambda, remove the
14748 lambda call op's own template argument list from ARGS. Only the
14749 template arguments active for the closure type should be used to
14750 retrieve the pack specialization. */
14751 if (LAMBDA_FUNCTION_P (current_function_decl
)
14752 && (template_class_depth (DECL_CONTEXT (t
))
14753 != TMPL_ARGS_DEPTH (args
)))
14754 args
= strip_innermost_template_args (args
, 1);
14756 /* Otherwise return the full NONTYPE_ARGUMENT_PACK that
14757 tsubst_decl put in the hash table. */
14758 return retrieve_specialization (t
, args
, 0);
14761 if (DECL_CONTEXT (t
))
14765 ctx
= tsubst_aggr_type (DECL_CONTEXT (t
), args
, complain
, in_decl
,
14766 /*entering_scope=*/1);
14767 if (ctx
!= DECL_CONTEXT (t
))
14769 tree r
= lookup_field (ctx
, DECL_NAME (t
), 0, false);
14772 if (complain
& tf_error
)
14773 error ("using invalid field %qD", t
);
14774 return error_mark_node
;
14783 case FUNCTION_DECL
:
14784 if (DECL_LANG_SPECIFIC (t
) && DECL_TEMPLATE_INFO (t
))
14785 r
= tsubst (t
, args
, complain
, in_decl
);
14786 else if (local_variable_p (t
)
14787 && uses_template_parms (DECL_CONTEXT (t
)))
14789 r
= retrieve_local_specialization (t
);
14790 if (r
== NULL_TREE
)
14792 /* First try name lookup to find the instantiation. */
14793 r
= lookup_name (DECL_NAME (t
));
14794 if (r
&& !is_capture_proxy (r
))
14796 /* Make sure that the one we found is the one we want. */
14797 tree ctx
= enclosing_instantiation_of (DECL_CONTEXT (t
));
14798 if (ctx
!= DECL_CONTEXT (r
))
14806 /* This can happen for a variable used in a
14807 late-specified return type of a local lambda, or for a
14808 local static or constant. Building a new VAR_DECL
14809 should be OK in all those cases. */
14810 r
= tsubst_decl (t
, args
, complain
);
14811 if (local_specializations
)
14812 /* Avoid infinite recursion (79640). */
14813 register_local_specialization (r
, t
);
14814 if (decl_maybe_constant_var_p (r
))
14816 /* We can't call cp_finish_decl, so handle the
14817 initializer by hand. */
14818 tree init
= tsubst_init (DECL_INITIAL (t
), r
, args
,
14819 complain
, in_decl
);
14820 if (!processing_template_decl
)
14821 init
= maybe_constant_init (init
);
14822 if (processing_template_decl
14823 ? potential_constant_expression (init
)
14824 : reduced_constant_expression_p (init
))
14825 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (r
)
14826 = TREE_CONSTANT (r
) = true;
14827 DECL_INITIAL (r
) = init
;
14828 if (tree auto_node
= type_uses_auto (TREE_TYPE (r
)))
14830 = do_auto_deduction (TREE_TYPE (r
), init
, auto_node
,
14831 complain
, adc_variable_type
);
14833 gcc_assert (cp_unevaluated_operand
|| TREE_STATIC (r
)
14834 || decl_constant_var_p (r
)
14835 || errorcount
|| sorrycount
);
14836 if (!processing_template_decl
14837 && !TREE_STATIC (r
))
14838 r
= process_outer_var_ref (r
, complain
);
14840 /* Remember this for subsequent uses. */
14841 if (local_specializations
)
14842 register_local_specialization (r
, t
);
14847 if (!mark_used (r
, complain
))
14848 return error_mark_node
;
14851 case NAMESPACE_DECL
:
14855 /* An OVERLOAD will always be a non-dependent overload set; an
14856 overload set from function scope will just be represented with an
14857 IDENTIFIER_NODE, and from class scope with a BASELINK. */
14858 gcc_assert (!uses_template_parms (t
));
14859 /* We must have marked any lookups as persistent. */
14860 gcc_assert (!OVL_LOOKUP_P (t
) || OVL_USED_P (t
));
14864 return tsubst_baselink (t
, current_nonlambda_class_type (),
14865 args
, complain
, in_decl
);
14867 case TEMPLATE_DECL
:
14868 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
14869 return tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
14870 args
, complain
, in_decl
);
14871 else if (DECL_FUNCTION_TEMPLATE_P (t
) && DECL_MEMBER_TEMPLATE_P (t
))
14872 return tsubst (t
, args
, complain
, in_decl
);
14873 else if (DECL_CLASS_SCOPE_P (t
)
14874 && uses_template_parms (DECL_CONTEXT (t
)))
14876 /* Template template argument like the following example need
14879 template <template <class> class TT> struct C {};
14880 template <class T> struct D {
14881 template <class U> struct E {};
14886 We are processing the template argument `E' in #1 for
14887 the template instantiation #2. Originally, `E' is a
14888 TEMPLATE_DECL with `D<T>' as its DECL_CONTEXT. Now we
14889 have to substitute this with one having context `D<int>'. */
14891 tree context
= tsubst (DECL_CONTEXT (t
), args
, complain
, in_decl
);
14892 if (dependent_scope_p (context
))
14894 /* When rewriting a constructor into a deduction guide, a
14895 non-dependent name can become dependent, so memtmpl<args>
14896 becomes context::template memtmpl<args>. */
14897 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14898 return build_qualified_name (type
, context
, DECL_NAME (t
),
14901 return lookup_field (context
, DECL_NAME(t
), 0, false);
14904 /* Ordinary template template argument. */
14908 case REINTERPRET_CAST_EXPR
:
14909 case CONST_CAST_EXPR
:
14910 case STATIC_CAST_EXPR
:
14911 case DYNAMIC_CAST_EXPR
:
14912 case IMPLICIT_CONV_EXPR
:
14916 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
14917 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
14918 return build1 (code
, type
, op0
);
14922 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0))
14923 || ARGUMENT_PACK_P (TREE_OPERAND (t
, 0)))
14925 tree expanded
, op
= TREE_OPERAND (t
, 0);
14928 if (SIZEOF_EXPR_TYPE_P (t
))
14929 op
= TREE_TYPE (op
);
14931 ++cp_unevaluated_operand
;
14932 ++c_inhibit_evaluation_warnings
;
14933 /* We only want to compute the number of arguments. */
14934 if (PACK_EXPANSION_P (op
))
14935 expanded
= tsubst_pack_expansion (op
, args
, complain
, in_decl
);
14937 expanded
= tsubst_template_args (ARGUMENT_PACK_ARGS (op
),
14938 args
, complain
, in_decl
);
14939 --cp_unevaluated_operand
;
14940 --c_inhibit_evaluation_warnings
;
14942 if (TREE_CODE (expanded
) == TREE_VEC
)
14944 len
= TREE_VEC_LENGTH (expanded
);
14945 /* Set TREE_USED for the benefit of -Wunused. */
14946 for (int i
= 0; i
< len
; i
++)
14947 if (DECL_P (TREE_VEC_ELT (expanded
, i
)))
14948 TREE_USED (TREE_VEC_ELT (expanded
, i
)) = true;
14951 if (expanded
== error_mark_node
)
14952 return error_mark_node
;
14953 else if (PACK_EXPANSION_P (expanded
)
14954 || (TREE_CODE (expanded
) == TREE_VEC
14955 && pack_expansion_args_count (expanded
)))
14958 if (PACK_EXPANSION_P (expanded
))
14960 else if (TREE_VEC_LENGTH (expanded
) == 1)
14961 expanded
= TREE_VEC_ELT (expanded
, 0);
14963 expanded
= make_argument_pack (expanded
);
14965 if (TYPE_P (expanded
))
14966 return cxx_sizeof_or_alignof_type (expanded
, SIZEOF_EXPR
,
14967 complain
& tf_error
);
14969 return cxx_sizeof_or_alignof_expr (expanded
, SIZEOF_EXPR
,
14970 complain
& tf_error
);
14973 return build_int_cst (size_type_node
, len
);
14975 if (SIZEOF_EXPR_TYPE_P (t
))
14977 r
= tsubst (TREE_TYPE (TREE_OPERAND (t
, 0)),
14978 args
, complain
, in_decl
);
14979 r
= build1 (NOP_EXPR
, r
, error_mark_node
);
14980 r
= build1 (SIZEOF_EXPR
,
14981 tsubst (TREE_TYPE (t
), args
, complain
, in_decl
), r
);
14982 SIZEOF_EXPR_TYPE_P (r
) = 1;
14989 case TRUTH_NOT_EXPR
:
14992 case UNARY_PLUS_EXPR
: /* Unary + */
14994 case AT_ENCODE_EXPR
:
14998 case REALPART_EXPR
:
14999 case IMAGPART_EXPR
:
15002 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15003 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15004 return build1 (code
, type
, op0
);
15007 case COMPONENT_REF
:
15012 object
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15013 name
= TREE_OPERAND (t
, 1);
15014 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
15016 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
15017 complain
, in_decl
);
15018 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
15020 else if (TREE_CODE (name
) == SCOPE_REF
15021 && TREE_CODE (TREE_OPERAND (name
, 1)) == BIT_NOT_EXPR
)
15023 tree base
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
15024 complain
, in_decl
);
15025 name
= TREE_OPERAND (name
, 1);
15026 name
= tsubst_copy (TREE_OPERAND (name
, 0), args
,
15027 complain
, in_decl
);
15028 name
= build1 (BIT_NOT_EXPR
, NULL_TREE
, name
);
15029 name
= build_qualified_name (/*type=*/NULL_TREE
,
15031 /*template_p=*/false);
15033 else if (BASELINK_P (name
))
15034 name
= tsubst_baselink (name
,
15035 non_reference (TREE_TYPE (object
)),
15039 name
= tsubst_copy (name
, args
, complain
, in_decl
);
15040 return build_nt (COMPONENT_REF
, object
, name
, NULL_TREE
);
15046 case TRUNC_DIV_EXPR
:
15047 case CEIL_DIV_EXPR
:
15048 case FLOOR_DIV_EXPR
:
15049 case ROUND_DIV_EXPR
:
15050 case EXACT_DIV_EXPR
:
15054 case TRUNC_MOD_EXPR
:
15055 case FLOOR_MOD_EXPR
:
15056 case TRUTH_ANDIF_EXPR
:
15057 case TRUTH_ORIF_EXPR
:
15058 case TRUTH_AND_EXPR
:
15059 case TRUTH_OR_EXPR
:
15072 case COMPOUND_EXPR
:
15075 case PREDECREMENT_EXPR
:
15076 case PREINCREMENT_EXPR
:
15077 case POSTDECREMENT_EXPR
:
15078 case POSTINCREMENT_EXPR
:
15080 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15081 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15082 return build_nt (code
, op0
, op1
);
15087 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15088 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15089 return build_qualified_name (/*type=*/NULL_TREE
, op0
, op1
,
15090 QUALIFIED_NAME_IS_TEMPLATE (t
));
15095 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15096 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15097 return build_nt (ARRAY_REF
, op0
, op1
, NULL_TREE
, NULL_TREE
);
15102 int n
= VL_EXP_OPERAND_LENGTH (t
);
15103 tree result
= build_vl_exp (CALL_EXPR
, n
);
15105 for (i
= 0; i
< n
; i
++)
15106 TREE_OPERAND (t
, i
) = tsubst_copy (TREE_OPERAND (t
, i
), args
,
15107 complain
, in_decl
);
15113 case PSEUDO_DTOR_EXPR
:
15114 case VEC_PERM_EXPR
:
15116 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15117 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15118 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
15119 r
= build_nt (code
, op0
, op1
, op2
);
15120 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
15126 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15127 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15128 tree op2
= tsubst_copy (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
15129 r
= build_nt (code
, op0
, op1
, op2
);
15130 NEW_EXPR_USE_GLOBAL (r
) = NEW_EXPR_USE_GLOBAL (t
);
15136 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15137 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15138 r
= build_nt (code
, op0
, op1
);
15139 DELETE_EXPR_USE_GLOBAL (r
) = DELETE_EXPR_USE_GLOBAL (t
);
15140 DELETE_EXPR_USE_VEC (r
) = DELETE_EXPR_USE_VEC (t
);
15144 case TEMPLATE_ID_EXPR
:
15146 /* Substituted template arguments */
15147 tree fn
= TREE_OPERAND (t
, 0);
15148 tree targs
= TREE_OPERAND (t
, 1);
15150 fn
= tsubst_copy (fn
, args
, complain
, in_decl
);
15152 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
15154 return lookup_template_function (fn
, targs
);
15159 tree purpose
, value
, chain
;
15161 if (t
== void_list_node
)
15164 purpose
= TREE_PURPOSE (t
);
15166 purpose
= tsubst_copy (purpose
, args
, complain
, in_decl
);
15167 value
= TREE_VALUE (t
);
15169 value
= tsubst_copy (value
, args
, complain
, in_decl
);
15170 chain
= TREE_CHAIN (t
);
15171 if (chain
&& chain
!= void_type_node
)
15172 chain
= tsubst_copy (chain
, args
, complain
, in_decl
);
15173 if (purpose
== TREE_PURPOSE (t
)
15174 && value
== TREE_VALUE (t
)
15175 && chain
== TREE_CHAIN (t
))
15177 return tree_cons (purpose
, value
, chain
);
15182 case ENUMERAL_TYPE
:
15184 case TEMPLATE_TYPE_PARM
:
15185 case TEMPLATE_TEMPLATE_PARM
:
15186 case BOUND_TEMPLATE_TEMPLATE_PARM
:
15187 case TEMPLATE_PARM_INDEX
:
15189 case REFERENCE_TYPE
:
15191 case FUNCTION_TYPE
:
15194 case TYPENAME_TYPE
:
15195 case UNBOUND_CLASS_TEMPLATE
:
15197 case DECLTYPE_TYPE
:
15199 return tsubst (t
, args
, complain
, in_decl
);
15203 /* Fall through. */
15204 case IDENTIFIER_NODE
:
15205 if (IDENTIFIER_CONV_OP_P (t
))
15207 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15208 return make_conv_op_name (new_type
);
15214 /* This is handled by tsubst_copy_and_build. */
15215 gcc_unreachable ();
15219 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15220 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15221 return build_x_va_arg (EXPR_LOCATION (t
), op0
, type
);
15224 case CLEANUP_POINT_EXPR
:
15225 /* We shouldn't have built any of these during initial template
15226 generation. Instead, they should be built during instantiation
15227 in response to the saved STMT_IS_FULL_EXPR_P setting. */
15228 gcc_unreachable ();
15232 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15233 tree op0
= tsubst_copy (TREE_OPERAND (t
, 0), args
, complain
, in_decl
);
15234 tree op1
= tsubst_copy (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
15235 r
= build2 (code
, type
, op0
, op1
);
15236 PTRMEM_OK_P (r
) = PTRMEM_OK_P (t
);
15237 if (!mark_used (TREE_OPERAND (r
, 1), complain
)
15238 && !(complain
& tf_error
))
15239 return error_mark_node
;
15243 case EXPR_PACK_EXPANSION
:
15244 error ("invalid use of pack expansion expression");
15245 return error_mark_node
;
15247 case NONTYPE_ARGUMENT_PACK
:
15248 error ("use %<...%> to expand argument pack");
15249 return error_mark_node
;
15252 gcc_checking_assert (t
== void_node
&& VOID_TYPE_P (TREE_TYPE (t
)));
15260 /* Instantiate any typedefs in the type. */
15261 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
15262 r
= fold_convert (type
, t
);
15263 gcc_assert (TREE_CODE (r
) == code
);
15268 /* These can sometimes show up in a partial instantiation, but never
15269 involve template parms. */
15270 gcc_assert (!uses_template_parms (t
));
15273 case UNARY_LEFT_FOLD_EXPR
:
15274 return tsubst_unary_left_fold (t
, args
, complain
, in_decl
);
15275 case UNARY_RIGHT_FOLD_EXPR
:
15276 return tsubst_unary_right_fold (t
, args
, complain
, in_decl
);
15277 case BINARY_LEFT_FOLD_EXPR
:
15278 return tsubst_binary_left_fold (t
, args
, complain
, in_decl
);
15279 case BINARY_RIGHT_FOLD_EXPR
:
15280 return tsubst_binary_right_fold (t
, args
, complain
, in_decl
);
15285 /* We shouldn't get here, but keep going if !flag_checking. */
15287 gcc_unreachable ();
15292 /* Helper function for tsubst_omp_clauses, used for instantiation of
15293 OMP_CLAUSE_DECL of clauses. */
15296 tsubst_omp_clause_decl (tree decl
, tree args
, tsubst_flags_t complain
,
15299 if (decl
== NULL_TREE
)
15302 /* Handle an OpenMP array section represented as a TREE_LIST (or
15303 OMP_CLAUSE_DEPEND_KIND). An OMP_CLAUSE_DEPEND (with a depend
15304 kind of OMP_CLAUSE_DEPEND_SINK) can also be represented as a
15305 TREE_LIST. We can handle it exactly the same as an array section
15306 (purpose, value, and a chain), even though the nomenclature
15307 (low_bound, length, etc) is different. */
15308 if (TREE_CODE (decl
) == TREE_LIST
)
15311 = tsubst_expr (TREE_PURPOSE (decl
), args
, complain
, in_decl
,
15312 /*integral_constant_expression_p=*/false);
15313 tree length
= tsubst_expr (TREE_VALUE (decl
), args
, complain
, in_decl
,
15314 /*integral_constant_expression_p=*/false);
15315 tree chain
= tsubst_omp_clause_decl (TREE_CHAIN (decl
), args
, complain
,
15317 if (TREE_PURPOSE (decl
) == low_bound
15318 && TREE_VALUE (decl
) == length
15319 && TREE_CHAIN (decl
) == chain
)
15321 tree ret
= tree_cons (low_bound
, length
, chain
);
15322 OMP_CLAUSE_DEPEND_SINK_NEGATIVE (ret
)
15323 = OMP_CLAUSE_DEPEND_SINK_NEGATIVE (decl
);
15326 tree ret
= tsubst_expr (decl
, args
, complain
, in_decl
,
15327 /*integral_constant_expression_p=*/false);
15328 /* Undo convert_from_reference tsubst_expr could have called. */
15330 && REFERENCE_REF_P (ret
)
15331 && !REFERENCE_REF_P (decl
))
15332 ret
= TREE_OPERAND (ret
, 0);
15336 /* Like tsubst_copy, but specifically for OpenMP clauses. */
15339 tsubst_omp_clauses (tree clauses
, enum c_omp_region_type ort
,
15340 tree args
, tsubst_flags_t complain
, tree in_decl
)
15342 tree new_clauses
= NULL_TREE
, nc
, oc
;
15343 tree linear_no_step
= NULL_TREE
;
15345 for (oc
= clauses
; oc
; oc
= OMP_CLAUSE_CHAIN (oc
))
15347 nc
= copy_node (oc
);
15348 OMP_CLAUSE_CHAIN (nc
) = new_clauses
;
15351 switch (OMP_CLAUSE_CODE (nc
))
15353 case OMP_CLAUSE_LASTPRIVATE
:
15354 if (OMP_CLAUSE_LASTPRIVATE_STMT (oc
))
15356 OMP_CLAUSE_LASTPRIVATE_STMT (nc
) = push_stmt_list ();
15357 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc
), args
, complain
,
15358 in_decl
, /*integral_constant_expression_p=*/false);
15359 OMP_CLAUSE_LASTPRIVATE_STMT (nc
)
15360 = pop_stmt_list (OMP_CLAUSE_LASTPRIVATE_STMT (nc
));
15363 case OMP_CLAUSE_PRIVATE
:
15364 case OMP_CLAUSE_SHARED
:
15365 case OMP_CLAUSE_FIRSTPRIVATE
:
15366 case OMP_CLAUSE_COPYIN
:
15367 case OMP_CLAUSE_COPYPRIVATE
:
15368 case OMP_CLAUSE_UNIFORM
:
15369 case OMP_CLAUSE_DEPEND
:
15370 case OMP_CLAUSE_FROM
:
15371 case OMP_CLAUSE_TO
:
15372 case OMP_CLAUSE_MAP
:
15373 case OMP_CLAUSE_USE_DEVICE_PTR
:
15374 case OMP_CLAUSE_IS_DEVICE_PTR
:
15375 OMP_CLAUSE_DECL (nc
)
15376 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
15379 case OMP_CLAUSE_TILE
:
15380 case OMP_CLAUSE_IF
:
15381 case OMP_CLAUSE_NUM_THREADS
:
15382 case OMP_CLAUSE_SCHEDULE
:
15383 case OMP_CLAUSE_COLLAPSE
:
15384 case OMP_CLAUSE_FINAL
:
15385 case OMP_CLAUSE_DEVICE
:
15386 case OMP_CLAUSE_DIST_SCHEDULE
:
15387 case OMP_CLAUSE_NUM_TEAMS
:
15388 case OMP_CLAUSE_THREAD_LIMIT
:
15389 case OMP_CLAUSE_SAFELEN
:
15390 case OMP_CLAUSE_SIMDLEN
:
15391 case OMP_CLAUSE_NUM_TASKS
:
15392 case OMP_CLAUSE_GRAINSIZE
:
15393 case OMP_CLAUSE_PRIORITY
:
15394 case OMP_CLAUSE_ORDERED
:
15395 case OMP_CLAUSE_HINT
:
15396 case OMP_CLAUSE_NUM_GANGS
:
15397 case OMP_CLAUSE_NUM_WORKERS
:
15398 case OMP_CLAUSE_VECTOR_LENGTH
:
15399 case OMP_CLAUSE_WORKER
:
15400 case OMP_CLAUSE_VECTOR
:
15401 case OMP_CLAUSE_ASYNC
:
15402 case OMP_CLAUSE_WAIT
:
15403 OMP_CLAUSE_OPERAND (nc
, 0)
15404 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 0), args
, complain
,
15405 in_decl
, /*integral_constant_expression_p=*/false);
15407 case OMP_CLAUSE_REDUCTION
:
15408 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
))
15410 tree placeholder
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (oc
);
15411 if (TREE_CODE (placeholder
) == SCOPE_REF
)
15413 tree scope
= tsubst (TREE_OPERAND (placeholder
, 0), args
,
15414 complain
, in_decl
);
15415 OMP_CLAUSE_REDUCTION_PLACEHOLDER (nc
)
15416 = build_qualified_name (NULL_TREE
, scope
,
15417 TREE_OPERAND (placeholder
, 1),
15421 gcc_assert (identifier_p (placeholder
));
15423 OMP_CLAUSE_DECL (nc
)
15424 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
15427 case OMP_CLAUSE_GANG
:
15428 case OMP_CLAUSE_ALIGNED
:
15429 OMP_CLAUSE_DECL (nc
)
15430 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
15432 OMP_CLAUSE_OPERAND (nc
, 1)
15433 = tsubst_expr (OMP_CLAUSE_OPERAND (oc
, 1), args
, complain
,
15434 in_decl
, /*integral_constant_expression_p=*/false);
15436 case OMP_CLAUSE_LINEAR
:
15437 OMP_CLAUSE_DECL (nc
)
15438 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc
), args
, complain
,
15440 if (OMP_CLAUSE_LINEAR_STEP (oc
) == NULL_TREE
)
15442 gcc_assert (!linear_no_step
);
15443 linear_no_step
= nc
;
15445 else if (OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (oc
))
15446 OMP_CLAUSE_LINEAR_STEP (nc
)
15447 = tsubst_omp_clause_decl (OMP_CLAUSE_LINEAR_STEP (oc
), args
,
15448 complain
, in_decl
);
15450 OMP_CLAUSE_LINEAR_STEP (nc
)
15451 = tsubst_expr (OMP_CLAUSE_LINEAR_STEP (oc
), args
, complain
,
15453 /*integral_constant_expression_p=*/false);
15455 case OMP_CLAUSE_NOWAIT
:
15456 case OMP_CLAUSE_DEFAULT
:
15457 case OMP_CLAUSE_UNTIED
:
15458 case OMP_CLAUSE_MERGEABLE
:
15459 case OMP_CLAUSE_INBRANCH
:
15460 case OMP_CLAUSE_NOTINBRANCH
:
15461 case OMP_CLAUSE_PROC_BIND
:
15462 case OMP_CLAUSE_FOR
:
15463 case OMP_CLAUSE_PARALLEL
:
15464 case OMP_CLAUSE_SECTIONS
:
15465 case OMP_CLAUSE_TASKGROUP
:
15466 case OMP_CLAUSE_NOGROUP
:
15467 case OMP_CLAUSE_THREADS
:
15468 case OMP_CLAUSE_SIMD
:
15469 case OMP_CLAUSE_DEFAULTMAP
:
15470 case OMP_CLAUSE_INDEPENDENT
:
15471 case OMP_CLAUSE_AUTO
:
15472 case OMP_CLAUSE_SEQ
:
15475 gcc_unreachable ();
15477 if ((ort
& C_ORT_OMP_DECLARE_SIMD
) == C_ORT_OMP
)
15478 switch (OMP_CLAUSE_CODE (nc
))
15480 case OMP_CLAUSE_SHARED
:
15481 case OMP_CLAUSE_PRIVATE
:
15482 case OMP_CLAUSE_FIRSTPRIVATE
:
15483 case OMP_CLAUSE_LASTPRIVATE
:
15484 case OMP_CLAUSE_COPYPRIVATE
:
15485 case OMP_CLAUSE_LINEAR
:
15486 case OMP_CLAUSE_REDUCTION
:
15487 case OMP_CLAUSE_USE_DEVICE_PTR
:
15488 case OMP_CLAUSE_IS_DEVICE_PTR
:
15489 /* tsubst_expr on SCOPE_REF results in returning
15490 finish_non_static_data_member result. Undo that here. */
15491 if (TREE_CODE (OMP_CLAUSE_DECL (oc
)) == SCOPE_REF
15492 && (TREE_CODE (TREE_OPERAND (OMP_CLAUSE_DECL (oc
), 1))
15493 == IDENTIFIER_NODE
))
15495 tree t
= OMP_CLAUSE_DECL (nc
);
15498 switch (TREE_CODE (v
))
15500 case COMPONENT_REF
:
15504 case POINTER_PLUS_EXPR
:
15505 v
= TREE_OPERAND (v
, 0);
15508 if (DECL_CONTEXT (v
) == current_function_decl
15509 && DECL_ARTIFICIAL (v
)
15510 && DECL_NAME (v
) == this_identifier
)
15511 OMP_CLAUSE_DECL (nc
) = TREE_OPERAND (t
, 1);
15518 else if (VAR_P (OMP_CLAUSE_DECL (oc
))
15519 && DECL_HAS_VALUE_EXPR_P (OMP_CLAUSE_DECL (oc
))
15520 && DECL_ARTIFICIAL (OMP_CLAUSE_DECL (oc
))
15521 && DECL_LANG_SPECIFIC (OMP_CLAUSE_DECL (oc
))
15522 && DECL_OMP_PRIVATIZED_MEMBER (OMP_CLAUSE_DECL (oc
)))
15524 tree decl
= OMP_CLAUSE_DECL (nc
);
15527 retrofit_lang_decl (decl
);
15528 DECL_OMP_PRIVATIZED_MEMBER (decl
) = 1;
15537 new_clauses
= nreverse (new_clauses
);
15538 if (ort
!= C_ORT_OMP_DECLARE_SIMD
)
15540 new_clauses
= finish_omp_clauses (new_clauses
, ort
);
15541 if (linear_no_step
)
15542 for (nc
= new_clauses
; nc
; nc
= OMP_CLAUSE_CHAIN (nc
))
15543 if (nc
== linear_no_step
)
15545 OMP_CLAUSE_LINEAR_STEP (nc
) = NULL_TREE
;
15549 return new_clauses
;
15552 /* Like tsubst_copy_and_build, but unshare TREE_LIST nodes. */
15555 tsubst_copy_asm_operands (tree t
, tree args
, tsubst_flags_t complain
,
15558 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
15560 tree purpose
, value
, chain
;
15565 if (TREE_CODE (t
) != TREE_LIST
)
15566 return tsubst_copy_and_build (t
, args
, complain
, in_decl
,
15567 /*function_p=*/false,
15568 /*integral_constant_expression_p=*/false);
15570 if (t
== void_list_node
)
15573 purpose
= TREE_PURPOSE (t
);
15575 purpose
= RECUR (purpose
);
15576 value
= TREE_VALUE (t
);
15579 if (TREE_CODE (value
) != LABEL_DECL
)
15580 value
= RECUR (value
);
15583 value
= lookup_label (DECL_NAME (value
));
15584 gcc_assert (TREE_CODE (value
) == LABEL_DECL
);
15585 TREE_USED (value
) = 1;
15588 chain
= TREE_CHAIN (t
);
15589 if (chain
&& chain
!= void_type_node
)
15590 chain
= RECUR (chain
);
15591 return tree_cons (purpose
, value
, chain
);
15595 /* Used to temporarily communicate the list of #pragma omp parallel
15596 clauses to #pragma omp for instantiation if they are combined
15599 static tree
*omp_parallel_combined_clauses
;
15601 /* Substitute one OMP_FOR iterator. */
15604 tsubst_omp_for_iterator (tree t
, int i
, tree declv
, tree orig_declv
,
15605 tree initv
, tree condv
, tree incrv
, tree
*clauses
,
15606 tree args
, tsubst_flags_t complain
, tree in_decl
,
15607 bool integral_constant_expression_p
)
15609 #define RECUR(NODE) \
15610 tsubst_expr ((NODE), args, complain, in_decl, \
15611 integral_constant_expression_p)
15612 tree decl
, init
, cond
, incr
;
15614 init
= TREE_VEC_ELT (OMP_FOR_INIT (t
), i
);
15615 gcc_assert (TREE_CODE (init
) == MODIFY_EXPR
);
15617 if (orig_declv
&& OMP_FOR_ORIG_DECLS (t
))
15619 tree o
= TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (t
), i
);
15620 TREE_VEC_ELT (orig_declv
, i
) = RECUR (o
);
15623 decl
= TREE_OPERAND (init
, 0);
15624 init
= TREE_OPERAND (init
, 1);
15625 tree decl_expr
= NULL_TREE
;
15626 if (init
&& TREE_CODE (init
) == DECL_EXPR
)
15628 /* We need to jump through some hoops to handle declarations in the
15629 init-statement, since we might need to handle auto deduction,
15630 but we need to keep control of initialization. */
15632 init
= DECL_INITIAL (DECL_EXPR_DECL (init
));
15633 decl
= tsubst_decl (decl
, args
, complain
);
15637 if (TREE_CODE (decl
) == SCOPE_REF
)
15639 decl
= RECUR (decl
);
15640 if (TREE_CODE (decl
) == COMPONENT_REF
)
15644 switch (TREE_CODE (v
))
15646 case COMPONENT_REF
:
15650 case POINTER_PLUS_EXPR
:
15651 v
= TREE_OPERAND (v
, 0);
15654 if (DECL_CONTEXT (v
) == current_function_decl
15655 && DECL_ARTIFICIAL (v
)
15656 && DECL_NAME (v
) == this_identifier
)
15658 decl
= TREE_OPERAND (decl
, 1);
15659 decl
= omp_privatize_field (decl
, false);
15669 decl
= RECUR (decl
);
15671 init
= RECUR (init
);
15673 tree auto_node
= type_uses_auto (TREE_TYPE (decl
));
15674 if (auto_node
&& init
)
15676 = do_auto_deduction (TREE_TYPE (decl
), init
, auto_node
);
15678 gcc_assert (!type_dependent_expression_p (decl
));
15680 if (!CLASS_TYPE_P (TREE_TYPE (decl
)))
15684 /* Declare the variable, but don't let that initialize it. */
15685 tree init_sav
= DECL_INITIAL (DECL_EXPR_DECL (decl_expr
));
15686 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = NULL_TREE
;
15688 DECL_INITIAL (DECL_EXPR_DECL (decl_expr
)) = init_sav
;
15691 cond
= RECUR (TREE_VEC_ELT (OMP_FOR_COND (t
), i
));
15692 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
15693 if (TREE_CODE (incr
) == MODIFY_EXPR
)
15695 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
15696 tree rhs
= RECUR (TREE_OPERAND (incr
, 1));
15697 incr
= build_x_modify_expr (EXPR_LOCATION (incr
), lhs
,
15698 NOP_EXPR
, rhs
, complain
);
15701 incr
= RECUR (incr
);
15702 TREE_VEC_ELT (declv
, i
) = decl
;
15703 TREE_VEC_ELT (initv
, i
) = init
;
15704 TREE_VEC_ELT (condv
, i
) = cond
;
15705 TREE_VEC_ELT (incrv
, i
) = incr
;
15711 /* Declare and initialize the variable. */
15719 for (j
= (omp_parallel_combined_clauses
== NULL
? 1 : 0); j
< 2; j
++)
15721 for (pc
= j
? clauses
: omp_parallel_combined_clauses
; *pc
; )
15723 if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_PRIVATE
15724 && OMP_CLAUSE_DECL (*pc
) == decl
)
15726 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_LASTPRIVATE
15727 && OMP_CLAUSE_DECL (*pc
) == decl
)
15731 /* Move lastprivate (decl) clause to OMP_FOR_CLAUSES. */
15733 *pc
= OMP_CLAUSE_CHAIN (c
);
15734 OMP_CLAUSE_CHAIN (c
) = *clauses
;
15737 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_FIRSTPRIVATE
15738 && OMP_CLAUSE_DECL (*pc
) == decl
)
15740 error ("iteration variable %qD should not be firstprivate",
15742 *pc
= OMP_CLAUSE_CHAIN (*pc
);
15744 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_REDUCTION
15745 && OMP_CLAUSE_DECL (*pc
) == decl
)
15747 error ("iteration variable %qD should not be reduction",
15749 *pc
= OMP_CLAUSE_CHAIN (*pc
);
15752 pc
= &OMP_CLAUSE_CHAIN (*pc
);
15757 if (*pc
== NULL_TREE
)
15759 tree c
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
15760 OMP_CLAUSE_DECL (c
) = decl
;
15761 c
= finish_omp_clauses (c
, C_ORT_OMP
);
15764 OMP_CLAUSE_CHAIN (c
) = *clauses
;
15769 cond
= TREE_VEC_ELT (OMP_FOR_COND (t
), i
);
15770 if (COMPARISON_CLASS_P (cond
))
15772 tree op0
= RECUR (TREE_OPERAND (cond
, 0));
15773 tree op1
= RECUR (TREE_OPERAND (cond
, 1));
15774 cond
= build2 (TREE_CODE (cond
), boolean_type_node
, op0
, op1
);
15777 cond
= RECUR (cond
);
15778 incr
= TREE_VEC_ELT (OMP_FOR_INCR (t
), i
);
15779 switch (TREE_CODE (incr
))
15781 case PREINCREMENT_EXPR
:
15782 case PREDECREMENT_EXPR
:
15783 case POSTINCREMENT_EXPR
:
15784 case POSTDECREMENT_EXPR
:
15785 incr
= build2 (TREE_CODE (incr
), TREE_TYPE (decl
),
15786 RECUR (TREE_OPERAND (incr
, 0)), NULL_TREE
);
15789 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
15790 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
15792 tree rhs
= TREE_OPERAND (incr
, 1);
15793 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
15794 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
15795 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
15796 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
15797 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
15801 incr
= RECUR (incr
);
15804 if (TREE_CODE (TREE_OPERAND (incr
, 1)) == PLUS_EXPR
15805 || TREE_CODE (TREE_OPERAND (incr
, 1)) == MINUS_EXPR
)
15807 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
15808 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
15809 build2 (TREE_CODE (TREE_OPERAND (incr
, 1)),
15810 TREE_TYPE (decl
), lhs
,
15811 RECUR (TREE_OPERAND (incr
, 2))));
15813 else if (TREE_CODE (TREE_OPERAND (incr
, 1)) == NOP_EXPR
15814 && (TREE_CODE (TREE_OPERAND (incr
, 2)) == PLUS_EXPR
15815 || (TREE_CODE (TREE_OPERAND (incr
, 2)) == MINUS_EXPR
)))
15817 tree rhs
= TREE_OPERAND (incr
, 2);
15818 tree lhs
= RECUR (TREE_OPERAND (incr
, 0));
15819 tree rhs0
= RECUR (TREE_OPERAND (rhs
, 0));
15820 tree rhs1
= RECUR (TREE_OPERAND (rhs
, 1));
15821 incr
= build2 (MODIFY_EXPR
, TREE_TYPE (decl
), lhs
,
15822 build2 (TREE_CODE (rhs
), TREE_TYPE (decl
),
15826 incr
= RECUR (incr
);
15829 incr
= RECUR (incr
);
15833 TREE_VEC_ELT (declv
, i
) = decl
;
15834 TREE_VEC_ELT (initv
, i
) = init
;
15835 TREE_VEC_ELT (condv
, i
) = cond
;
15836 TREE_VEC_ELT (incrv
, i
) = incr
;
15840 /* Helper function of tsubst_expr, find OMP_TEAMS inside
15841 of OMP_TARGET's body. */
15844 tsubst_find_omp_teams (tree
*tp
, int *walk_subtrees
, void *)
15846 *walk_subtrees
= 0;
15847 switch (TREE_CODE (*tp
))
15852 case STATEMENT_LIST
:
15853 *walk_subtrees
= 1;
15861 /* Helper function for tsubst_expr. For decomposition declaration
15862 artificial base DECL, which is tsubsted PATTERN_DECL, tsubst
15863 also the corresponding decls representing the identifiers
15864 of the decomposition declaration. Return DECL if successful
15865 or error_mark_node otherwise, set *FIRST to the first decl
15866 in the list chained through DECL_CHAIN and *CNT to the number
15870 tsubst_decomp_names (tree decl
, tree pattern_decl
, tree args
,
15871 tsubst_flags_t complain
, tree in_decl
, tree
*first
,
15874 tree decl2
, decl3
, prev
= decl
;
15876 gcc_assert (DECL_NAME (decl
) == NULL_TREE
);
15877 for (decl2
= DECL_CHAIN (pattern_decl
);
15880 && DECL_DECOMPOSITION_P (decl2
)
15881 && DECL_NAME (decl2
);
15882 decl2
= DECL_CHAIN (decl2
))
15884 if (TREE_TYPE (decl2
) == error_mark_node
&& *cnt
== 0)
15886 gcc_assert (errorcount
);
15887 return error_mark_node
;
15890 gcc_assert (DECL_DECOMP_BASE (decl2
) == pattern_decl
);
15891 gcc_assert (DECL_HAS_VALUE_EXPR_P (decl2
));
15892 tree v
= DECL_VALUE_EXPR (decl2
);
15893 DECL_HAS_VALUE_EXPR_P (decl2
) = 0;
15894 SET_DECL_VALUE_EXPR (decl2
, NULL_TREE
);
15895 decl3
= tsubst (decl2
, args
, complain
, in_decl
);
15896 SET_DECL_VALUE_EXPR (decl2
, v
);
15897 DECL_HAS_VALUE_EXPR_P (decl2
) = 1;
15899 DECL_TEMPLATE_INSTANTIATED (decl3
) = 1;
15900 maybe_push_decl (decl3
);
15901 if (error_operand_p (decl3
))
15902 decl
= error_mark_node
;
15903 else if (decl
!= error_mark_node
15904 && DECL_CHAIN (decl3
) != prev
)
15906 gcc_assert (errorcount
);
15907 decl
= error_mark_node
;
15916 /* Like tsubst_copy for expressions, etc. but also does semantic
15920 tsubst_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
,
15921 bool integral_constant_expression_p
)
15923 #define RETURN(EXP) do { r = (EXP); goto out; } while(0)
15924 #define RECUR(NODE) \
15925 tsubst_expr ((NODE), args, complain, in_decl, \
15926 integral_constant_expression_p)
15932 if (t
== NULL_TREE
|| t
== error_mark_node
)
15935 loc
= input_location
;
15936 if (EXPR_HAS_LOCATION (t
))
15937 input_location
= EXPR_LOCATION (t
);
15938 if (STATEMENT_CODE_P (TREE_CODE (t
)))
15939 current_stmt_tree ()->stmts_are_full_exprs_p
= STMT_IS_FULL_EXPR_P (t
);
15941 switch (TREE_CODE (t
))
15943 case STATEMENT_LIST
:
15945 tree_stmt_iterator i
;
15946 for (i
= tsi_start (t
); !tsi_end_p (i
); tsi_next (&i
))
15947 RECUR (tsi_stmt (i
));
15951 case CTOR_INITIALIZER
:
15952 finish_mem_initializers (tsubst_initializer_list
15953 (TREE_OPERAND (t
, 0), args
));
15957 finish_return_stmt (RECUR (TREE_OPERAND (t
, 0)));
15961 tmp
= RECUR (EXPR_STMT_EXPR (t
));
15962 if (EXPR_STMT_STMT_EXPR_RESULT (t
))
15963 finish_stmt_expr_expr (tmp
, cur_stmt_expr
);
15965 finish_expr_stmt (tmp
);
15969 finish_local_using_directive (USING_STMT_NAMESPACE (t
),
15970 /*attribs=*/NULL_TREE
);
15975 tree decl
, pattern_decl
;
15978 pattern_decl
= decl
= DECL_EXPR_DECL (t
);
15979 if (TREE_CODE (decl
) == LABEL_DECL
)
15980 finish_label_decl (DECL_NAME (decl
));
15981 else if (TREE_CODE (decl
) == USING_DECL
)
15983 tree scope
= USING_DECL_SCOPE (decl
);
15984 tree name
= DECL_NAME (decl
);
15986 scope
= tsubst (scope
, args
, complain
, in_decl
);
15987 decl
= lookup_qualified_name (scope
, name
,
15988 /*is_type_p=*/false,
15989 /*complain=*/false);
15990 if (decl
== error_mark_node
|| TREE_CODE (decl
) == TREE_LIST
)
15991 qualified_name_lookup_error (scope
, name
, decl
, input_location
);
15993 finish_local_using_decl (decl
, scope
, name
);
15995 else if (DECL_PACK_P (decl
))
15997 /* Don't build up decls for a variadic capture proxy, we'll
15998 instantiate the elements directly as needed. */
16001 else if (is_capture_proxy (decl
)
16002 && !DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
16004 /* We're in tsubst_lambda_expr, we've already inserted a new
16005 capture proxy, so look it up and register it. */
16006 tree inst
= lookup_name_real (DECL_NAME (decl
), 0, 0,
16007 /*block_p=*/true, 0, LOOKUP_HIDDEN
);
16008 gcc_assert (inst
!= decl
&& is_capture_proxy (inst
));
16009 register_local_specialization (inst
, decl
);
16012 else if (DECL_IMPLICIT_TYPEDEF_P (decl
)
16013 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
16014 /* Don't copy the old closure; we'll create a new one in
16015 tsubst_lambda_expr. */
16019 init
= DECL_INITIAL (decl
);
16020 decl
= tsubst (decl
, args
, complain
, in_decl
);
16021 if (decl
!= error_mark_node
)
16023 /* By marking the declaration as instantiated, we avoid
16024 trying to instantiate it. Since instantiate_decl can't
16025 handle local variables, and since we've already done
16026 all that needs to be done, that's the right thing to
16029 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
16031 && ANON_AGGR_TYPE_P (TREE_TYPE (decl
)))
16032 /* Anonymous aggregates are a special case. */
16033 finish_anon_union (decl
);
16034 else if (is_capture_proxy (DECL_EXPR_DECL (t
)))
16036 DECL_CONTEXT (decl
) = current_function_decl
;
16037 if (DECL_NAME (decl
) == this_identifier
)
16039 tree lam
= DECL_CONTEXT (current_function_decl
);
16040 lam
= CLASSTYPE_LAMBDA_EXPR (lam
);
16041 LAMBDA_EXPR_THIS_CAPTURE (lam
) = decl
;
16043 insert_capture_proxy (decl
);
16045 else if (DECL_IMPLICIT_TYPEDEF_P (t
))
16046 /* We already did a pushtag. */;
16047 else if (TREE_CODE (decl
) == FUNCTION_DECL
16048 && DECL_OMP_DECLARE_REDUCTION_P (decl
)
16049 && DECL_FUNCTION_SCOPE_P (pattern_decl
))
16051 DECL_CONTEXT (decl
) = NULL_TREE
;
16053 DECL_CONTEXT (decl
) = current_function_decl
;
16054 cp_check_omp_declare_reduction (decl
);
16058 int const_init
= false;
16059 maybe_push_decl (decl
);
16061 && DECL_PRETTY_FUNCTION_P (decl
))
16063 /* For __PRETTY_FUNCTION__ we have to adjust the
16065 const char *const name
16066 = cxx_printable_name (current_function_decl
, 2);
16067 init
= cp_fname_init (name
, &TREE_TYPE (decl
));
16070 init
= tsubst_init (init
, decl
, args
, complain
, in_decl
);
16073 const_init
= (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
16075 cp_finish_decl (decl
, init
, const_init
, NULL_TREE
, 0);
16077 && DECL_DECOMPOSITION_P (decl
)
16078 && TREE_TYPE (pattern_decl
) != error_mark_node
)
16082 decl
= tsubst_decomp_names (decl
, pattern_decl
, args
,
16083 complain
, in_decl
, &first
,
16085 if (decl
!= error_mark_node
)
16086 cp_finish_decomp (decl
, first
, cnt
);
16096 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
16097 RECUR (FOR_INIT_STMT (t
));
16098 finish_init_stmt (stmt
);
16099 tmp
= RECUR (FOR_COND (t
));
16100 finish_for_cond (tmp
, stmt
, false);
16101 tmp
= RECUR (FOR_EXPR (t
));
16102 finish_for_expr (tmp
, stmt
);
16103 RECUR (FOR_BODY (t
));
16104 finish_for_stmt (stmt
);
16107 case RANGE_FOR_STMT
:
16110 stmt
= begin_for_stmt (NULL_TREE
, NULL_TREE
);
16111 decl
= RANGE_FOR_DECL (t
);
16112 decl
= tsubst (decl
, args
, complain
, in_decl
);
16113 maybe_push_decl (decl
);
16114 expr
= RECUR (RANGE_FOR_EXPR (t
));
16115 if (VAR_P (decl
) && DECL_DECOMPOSITION_P (decl
))
16119 decl
= tsubst_decomp_names (decl
, RANGE_FOR_DECL (t
), args
,
16120 complain
, in_decl
, &first
, &cnt
);
16121 stmt
= cp_convert_range_for (stmt
, decl
, expr
, first
, cnt
,
16122 RANGE_FOR_IVDEP (t
));
16125 stmt
= cp_convert_range_for (stmt
, decl
, expr
, NULL_TREE
, 0,
16126 RANGE_FOR_IVDEP (t
));
16127 RECUR (RANGE_FOR_BODY (t
));
16128 finish_for_stmt (stmt
);
16133 stmt
= begin_while_stmt ();
16134 tmp
= RECUR (WHILE_COND (t
));
16135 finish_while_stmt_cond (tmp
, stmt
, false);
16136 RECUR (WHILE_BODY (t
));
16137 finish_while_stmt (stmt
);
16141 stmt
= begin_do_stmt ();
16142 RECUR (DO_BODY (t
));
16143 finish_do_body (stmt
);
16144 tmp
= RECUR (DO_COND (t
));
16145 finish_do_stmt (tmp
, stmt
, false);
16149 stmt
= begin_if_stmt ();
16150 IF_STMT_CONSTEXPR_P (stmt
) = IF_STMT_CONSTEXPR_P (t
);
16151 tmp
= RECUR (IF_COND (t
));
16152 tmp
= finish_if_stmt_cond (tmp
, stmt
);
16153 if (IF_STMT_CONSTEXPR_P (t
) && integer_zerop (tmp
))
16154 /* Don't instantiate the THEN_CLAUSE. */;
16157 bool inhibit
= integer_zerop (fold_non_dependent_expr (tmp
));
16159 ++c_inhibit_evaluation_warnings
;
16160 RECUR (THEN_CLAUSE (t
));
16162 --c_inhibit_evaluation_warnings
;
16164 finish_then_clause (stmt
);
16166 if (IF_STMT_CONSTEXPR_P (t
) && integer_nonzerop (tmp
))
16167 /* Don't instantiate the ELSE_CLAUSE. */;
16168 else if (ELSE_CLAUSE (t
))
16170 bool inhibit
= integer_nonzerop (fold_non_dependent_expr (tmp
));
16171 begin_else_clause (stmt
);
16173 ++c_inhibit_evaluation_warnings
;
16174 RECUR (ELSE_CLAUSE (t
));
16176 --c_inhibit_evaluation_warnings
;
16177 finish_else_clause (stmt
);
16180 finish_if_stmt (stmt
);
16184 if (BIND_EXPR_BODY_BLOCK (t
))
16185 stmt
= begin_function_body ();
16187 stmt
= begin_compound_stmt (BIND_EXPR_TRY_BLOCK (t
)
16188 ? BCS_TRY_BLOCK
: 0);
16190 RECUR (BIND_EXPR_BODY (t
));
16192 if (BIND_EXPR_BODY_BLOCK (t
))
16193 finish_function_body (stmt
);
16195 finish_compound_stmt (stmt
);
16199 finish_break_stmt ();
16202 case CONTINUE_STMT
:
16203 finish_continue_stmt ();
16207 stmt
= begin_switch_stmt ();
16208 tmp
= RECUR (SWITCH_STMT_COND (t
));
16209 finish_switch_cond (tmp
, stmt
);
16210 RECUR (SWITCH_STMT_BODY (t
));
16211 finish_switch_stmt (stmt
);
16214 case CASE_LABEL_EXPR
:
16216 tree low
= RECUR (CASE_LOW (t
));
16217 tree high
= RECUR (CASE_HIGH (t
));
16218 tree l
= finish_case_label (EXPR_LOCATION (t
), low
, high
);
16219 if (l
&& TREE_CODE (l
) == CASE_LABEL_EXPR
)
16220 FALLTHROUGH_LABEL_P (CASE_LABEL (l
))
16221 = FALLTHROUGH_LABEL_P (CASE_LABEL (t
));
16227 tree decl
= LABEL_EXPR_LABEL (t
);
16230 label
= finish_label_stmt (DECL_NAME (decl
));
16231 if (TREE_CODE (label
) == LABEL_DECL
)
16232 FALLTHROUGH_LABEL_P (label
) = FALLTHROUGH_LABEL_P (decl
);
16233 if (DECL_ATTRIBUTES (decl
) != NULL_TREE
)
16234 cplus_decl_attributes (&label
, DECL_ATTRIBUTES (decl
), 0);
16239 tmp
= GOTO_DESTINATION (t
);
16240 if (TREE_CODE (tmp
) != LABEL_DECL
)
16241 /* Computed goto's must be tsubst'd into. On the other hand,
16242 non-computed gotos must not be; the identifier in question
16243 will have no binding. */
16246 tmp
= DECL_NAME (tmp
);
16247 finish_goto_stmt (tmp
);
16252 tree string
= RECUR (ASM_STRING (t
));
16253 tree outputs
= tsubst_copy_asm_operands (ASM_OUTPUTS (t
), args
,
16254 complain
, in_decl
);
16255 tree inputs
= tsubst_copy_asm_operands (ASM_INPUTS (t
), args
,
16256 complain
, in_decl
);
16257 tree clobbers
= tsubst_copy_asm_operands (ASM_CLOBBERS (t
), args
,
16258 complain
, in_decl
);
16259 tree labels
= tsubst_copy_asm_operands (ASM_LABELS (t
), args
,
16260 complain
, in_decl
);
16261 tmp
= finish_asm_stmt (ASM_VOLATILE_P (t
), string
, outputs
, inputs
,
16263 tree asm_expr
= tmp
;
16264 if (TREE_CODE (asm_expr
) == CLEANUP_POINT_EXPR
)
16265 asm_expr
= TREE_OPERAND (asm_expr
, 0);
16266 ASM_INPUT_P (asm_expr
) = ASM_INPUT_P (t
);
16273 stmt
= begin_try_block ();
16274 RECUR (TRY_STMTS (t
));
16275 finish_cleanup_try_block (stmt
);
16276 finish_cleanup (RECUR (TRY_HANDLERS (t
)), stmt
);
16280 tree compound_stmt
= NULL_TREE
;
16282 if (FN_TRY_BLOCK_P (t
))
16283 stmt
= begin_function_try_block (&compound_stmt
);
16285 stmt
= begin_try_block ();
16287 RECUR (TRY_STMTS (t
));
16289 if (FN_TRY_BLOCK_P (t
))
16290 finish_function_try_block (stmt
);
16292 finish_try_block (stmt
);
16294 RECUR (TRY_HANDLERS (t
));
16295 if (FN_TRY_BLOCK_P (t
))
16296 finish_function_handler_sequence (stmt
, compound_stmt
);
16298 finish_handler_sequence (stmt
);
16304 tree decl
= HANDLER_PARMS (t
);
16308 decl
= tsubst (decl
, args
, complain
, in_decl
);
16309 /* Prevent instantiate_decl from trying to instantiate
16310 this variable. We've already done all that needs to be
16312 if (decl
!= error_mark_node
)
16313 DECL_TEMPLATE_INSTANTIATED (decl
) = 1;
16315 stmt
= begin_handler ();
16316 finish_handler_parms (decl
, stmt
);
16317 RECUR (HANDLER_BODY (t
));
16318 finish_handler (stmt
);
16323 tmp
= tsubst (TREE_TYPE (t
), args
, complain
, NULL_TREE
);
16324 if (CLASS_TYPE_P (tmp
))
16326 /* Local classes are not independent templates; they are
16327 instantiated along with their containing function. And this
16328 way we don't have to deal with pushing out of one local class
16329 to instantiate a member of another local class. */
16330 /* Closures are handled by the LAMBDA_EXPR. */
16331 gcc_assert (!LAMBDA_TYPE_P (TREE_TYPE (t
)));
16332 complete_type (tmp
);
16333 for (tree fld
= TYPE_FIELDS (tmp
); fld
; fld
= DECL_CHAIN (fld
))
16335 || (TREE_CODE (fld
) == FUNCTION_DECL
16336 && !DECL_ARTIFICIAL (fld
)))
16337 && DECL_TEMPLATE_INSTANTIATION (fld
))
16338 instantiate_decl (fld
, /*defer_ok=*/false,
16339 /*expl_inst_class=*/false);
16343 case STATIC_ASSERT
:
16347 ++c_inhibit_evaluation_warnings
;
16349 tsubst_expr (STATIC_ASSERT_CONDITION (t
),
16352 /*integral_constant_expression_p=*/true);
16353 --c_inhibit_evaluation_warnings
;
16355 finish_static_assert (condition
,
16356 STATIC_ASSERT_MESSAGE (t
),
16357 STATIC_ASSERT_SOURCE_LOCATION (t
),
16358 /*member_p=*/false);
16363 case OACC_PARALLEL
:
16364 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), C_ORT_ACC
, args
, complain
,
16366 stmt
= begin_omp_parallel ();
16367 RECUR (OMP_BODY (t
));
16368 finish_omp_construct (TREE_CODE (t
), stmt
, tmp
);
16372 r
= push_omp_privatization_clauses (OMP_PARALLEL_COMBINED (t
));
16373 tmp
= tsubst_omp_clauses (OMP_PARALLEL_CLAUSES (t
), C_ORT_OMP
, args
,
16374 complain
, in_decl
);
16375 if (OMP_PARALLEL_COMBINED (t
))
16376 omp_parallel_combined_clauses
= &tmp
;
16377 stmt
= begin_omp_parallel ();
16378 RECUR (OMP_PARALLEL_BODY (t
));
16379 gcc_assert (omp_parallel_combined_clauses
== NULL
);
16380 OMP_PARALLEL_COMBINED (finish_omp_parallel (tmp
, stmt
))
16381 = OMP_PARALLEL_COMBINED (t
);
16382 pop_omp_privatization_clauses (r
);
16386 r
= push_omp_privatization_clauses (false);
16387 tmp
= tsubst_omp_clauses (OMP_TASK_CLAUSES (t
), C_ORT_OMP
, args
,
16388 complain
, in_decl
);
16389 stmt
= begin_omp_task ();
16390 RECUR (OMP_TASK_BODY (t
));
16391 finish_omp_task (tmp
, stmt
);
16392 pop_omp_privatization_clauses (r
);
16399 case OMP_DISTRIBUTE
:
16403 tree clauses
, body
, pre_body
;
16404 tree declv
= NULL_TREE
, initv
= NULL_TREE
, condv
= NULL_TREE
;
16405 tree orig_declv
= NULL_TREE
;
16406 tree incrv
= NULL_TREE
;
16407 enum c_omp_region_type ort
= C_ORT_OMP
;
16410 if (TREE_CODE (t
) == CILK_SIMD
|| TREE_CODE (t
) == CILK_FOR
)
16412 else if (TREE_CODE (t
) == OACC_LOOP
)
16415 r
= push_omp_privatization_clauses (OMP_FOR_INIT (t
) == NULL_TREE
);
16416 clauses
= tsubst_omp_clauses (OMP_FOR_CLAUSES (t
), ort
, args
, complain
,
16418 if (OMP_FOR_INIT (t
) != NULL_TREE
)
16420 declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
16421 if (OMP_FOR_ORIG_DECLS (t
))
16422 orig_declv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
16423 initv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
16424 condv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
16425 incrv
= make_tree_vec (TREE_VEC_LENGTH (OMP_FOR_INIT (t
)));
16428 stmt
= begin_omp_structured_block ();
16430 pre_body
= push_stmt_list ();
16431 RECUR (OMP_FOR_PRE_BODY (t
));
16432 pre_body
= pop_stmt_list (pre_body
);
16434 if (OMP_FOR_INIT (t
) != NULL_TREE
)
16435 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (t
)); i
++)
16436 tsubst_omp_for_iterator (t
, i
, declv
, orig_declv
, initv
, condv
,
16437 incrv
, &clauses
, args
, complain
, in_decl
,
16438 integral_constant_expression_p
);
16439 omp_parallel_combined_clauses
= NULL
;
16441 body
= push_stmt_list ();
16442 RECUR (OMP_FOR_BODY (t
));
16443 body
= pop_stmt_list (body
);
16445 if (OMP_FOR_INIT (t
) != NULL_TREE
)
16446 t
= finish_omp_for (EXPR_LOCATION (t
), TREE_CODE (t
), declv
,
16447 orig_declv
, initv
, condv
, incrv
, body
, pre_body
,
16451 t
= make_node (TREE_CODE (t
));
16452 TREE_TYPE (t
) = void_type_node
;
16453 OMP_FOR_BODY (t
) = body
;
16454 OMP_FOR_PRE_BODY (t
) = pre_body
;
16455 OMP_FOR_CLAUSES (t
) = clauses
;
16456 SET_EXPR_LOCATION (t
, EXPR_LOCATION (t
));
16460 add_stmt (finish_omp_structured_block (stmt
));
16461 pop_omp_privatization_clauses (r
);
16466 omp_parallel_combined_clauses
= NULL
;
16471 r
= push_omp_privatization_clauses (TREE_CODE (t
) == OMP_TEAMS
16472 && OMP_TEAMS_COMBINED (t
));
16473 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), C_ORT_OMP
, args
, complain
,
16475 stmt
= push_stmt_list ();
16476 RECUR (OMP_BODY (t
));
16477 stmt
= pop_stmt_list (stmt
);
16480 OMP_BODY (t
) = stmt
;
16481 OMP_CLAUSES (t
) = tmp
;
16483 pop_omp_privatization_clauses (r
);
16487 case OMP_TARGET_DATA
:
16489 tmp
= tsubst_omp_clauses (OMP_CLAUSES (t
), (TREE_CODE (t
) == OACC_DATA
)
16490 ? C_ORT_ACC
: C_ORT_OMP
, args
, complain
,
16492 keep_next_level (true);
16493 stmt
= begin_omp_structured_block ();
16495 RECUR (OMP_BODY (t
));
16496 stmt
= finish_omp_structured_block (stmt
);
16499 OMP_BODY (t
) = stmt
;
16500 OMP_CLAUSES (t
) = tmp
;
16501 if (TREE_CODE (t
) == OMP_TARGET
&& OMP_TARGET_COMBINED (t
))
16503 tree teams
= cp_walk_tree (&stmt
, tsubst_find_omp_teams
, NULL
, NULL
);
16506 /* For combined target teams, ensure the num_teams and
16507 thread_limit clause expressions are evaluated on the host,
16508 before entering the target construct. */
16510 for (c
= OMP_TEAMS_CLAUSES (teams
);
16511 c
; c
= OMP_CLAUSE_CHAIN (c
))
16512 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_NUM_TEAMS
16513 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_THREAD_LIMIT
)
16514 && TREE_CODE (OMP_CLAUSE_OPERAND (c
, 0)) != INTEGER_CST
)
16516 tree expr
= OMP_CLAUSE_OPERAND (c
, 0);
16517 expr
= force_target_expr (TREE_TYPE (expr
), expr
, tf_none
);
16518 if (expr
== error_mark_node
)
16520 tmp
= TARGET_EXPR_SLOT (expr
);
16522 OMP_CLAUSE_OPERAND (c
, 0) = expr
;
16523 tree tc
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
16524 OMP_CLAUSE_FIRSTPRIVATE
);
16525 OMP_CLAUSE_DECL (tc
) = tmp
;
16526 OMP_CLAUSE_CHAIN (tc
) = OMP_TARGET_CLAUSES (t
);
16527 OMP_TARGET_CLAUSES (t
) = tc
;
16536 tmp
= tsubst_omp_clauses (OACC_DECLARE_CLAUSES (t
), C_ORT_ACC
, args
,
16537 complain
, in_decl
);
16538 OACC_DECLARE_CLAUSES (t
) = tmp
;
16542 case OMP_TARGET_UPDATE
:
16543 case OMP_TARGET_ENTER_DATA
:
16544 case OMP_TARGET_EXIT_DATA
:
16545 tmp
= tsubst_omp_clauses (OMP_STANDALONE_CLAUSES (t
), C_ORT_OMP
, args
,
16546 complain
, in_decl
);
16548 OMP_STANDALONE_CLAUSES (t
) = tmp
;
16552 case OACC_ENTER_DATA
:
16553 case OACC_EXIT_DATA
:
16555 tmp
= tsubst_omp_clauses (OMP_STANDALONE_CLAUSES (t
), C_ORT_ACC
, args
,
16556 complain
, in_decl
);
16558 OMP_STANDALONE_CLAUSES (t
) = tmp
;
16563 tmp
= tsubst_omp_clauses (OMP_ORDERED_CLAUSES (t
), C_ORT_OMP
, args
,
16564 complain
, in_decl
);
16565 stmt
= push_stmt_list ();
16566 RECUR (OMP_BODY (t
));
16567 stmt
= pop_stmt_list (stmt
);
16570 OMP_BODY (t
) = stmt
;
16571 OMP_ORDERED_CLAUSES (t
) = tmp
;
16577 case OMP_TASKGROUP
:
16578 stmt
= push_stmt_list ();
16579 RECUR (OMP_BODY (t
));
16580 stmt
= pop_stmt_list (stmt
);
16583 OMP_BODY (t
) = stmt
;
16588 gcc_assert (OMP_ATOMIC_DEPENDENT_P (t
));
16589 if (TREE_CODE (TREE_OPERAND (t
, 1)) != MODIFY_EXPR
)
16591 tree op1
= TREE_OPERAND (t
, 1);
16592 tree rhs1
= NULL_TREE
;
16594 if (TREE_CODE (op1
) == COMPOUND_EXPR
)
16596 rhs1
= RECUR (TREE_OPERAND (op1
, 0));
16597 op1
= TREE_OPERAND (op1
, 1);
16599 lhs
= RECUR (TREE_OPERAND (op1
, 0));
16600 rhs
= RECUR (TREE_OPERAND (op1
, 1));
16601 finish_omp_atomic (OMP_ATOMIC
, TREE_CODE (op1
), lhs
, rhs
,
16602 NULL_TREE
, NULL_TREE
, rhs1
,
16603 OMP_ATOMIC_SEQ_CST (t
));
16607 tree op1
= TREE_OPERAND (t
, 1);
16608 tree v
= NULL_TREE
, lhs
, rhs
= NULL_TREE
, lhs1
= NULL_TREE
;
16609 tree rhs1
= NULL_TREE
;
16610 enum tree_code code
= TREE_CODE (TREE_OPERAND (op1
, 1));
16611 enum tree_code opcode
= NOP_EXPR
;
16612 if (code
== OMP_ATOMIC_READ
)
16614 v
= RECUR (TREE_OPERAND (op1
, 0));
16615 lhs
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
16617 else if (code
== OMP_ATOMIC_CAPTURE_OLD
16618 || code
== OMP_ATOMIC_CAPTURE_NEW
)
16620 tree op11
= TREE_OPERAND (TREE_OPERAND (op1
, 1), 1);
16621 v
= RECUR (TREE_OPERAND (op1
, 0));
16622 lhs1
= RECUR (TREE_OPERAND (TREE_OPERAND (op1
, 1), 0));
16623 if (TREE_CODE (op11
) == COMPOUND_EXPR
)
16625 rhs1
= RECUR (TREE_OPERAND (op11
, 0));
16626 op11
= TREE_OPERAND (op11
, 1);
16628 lhs
= RECUR (TREE_OPERAND (op11
, 0));
16629 rhs
= RECUR (TREE_OPERAND (op11
, 1));
16630 opcode
= TREE_CODE (op11
);
16631 if (opcode
== MODIFY_EXPR
)
16637 lhs
= RECUR (TREE_OPERAND (op1
, 0));
16638 rhs
= RECUR (TREE_OPERAND (op1
, 1));
16640 finish_omp_atomic (code
, opcode
, lhs
, rhs
, v
, lhs1
, rhs1
,
16641 OMP_ATOMIC_SEQ_CST (t
));
16645 case TRANSACTION_EXPR
:
16648 flags
|= (TRANSACTION_EXPR_OUTER (t
) ? TM_STMT_ATTR_OUTER
: 0);
16649 flags
|= (TRANSACTION_EXPR_RELAXED (t
) ? TM_STMT_ATTR_RELAXED
: 0);
16651 if (TRANSACTION_EXPR_IS_STMT (t
))
16653 tree body
= TRANSACTION_EXPR_BODY (t
);
16654 tree noex
= NULL_TREE
;
16655 if (TREE_CODE (body
) == MUST_NOT_THROW_EXPR
)
16657 noex
= MUST_NOT_THROW_COND (body
);
16658 if (noex
== NULL_TREE
)
16659 noex
= boolean_true_node
;
16660 body
= TREE_OPERAND (body
, 0);
16662 stmt
= begin_transaction_stmt (input_location
, NULL
, flags
);
16664 finish_transaction_stmt (stmt
, NULL
, flags
, RECUR (noex
));
16668 stmt
= build_transaction_expr (EXPR_LOCATION (t
),
16669 RECUR (TRANSACTION_EXPR_BODY (t
)),
16676 case MUST_NOT_THROW_EXPR
:
16678 tree op0
= RECUR (TREE_OPERAND (t
, 0));
16679 tree cond
= RECUR (MUST_NOT_THROW_COND (t
));
16680 RETURN (build_must_not_throw_expr (op0
, cond
));
16683 case EXPR_PACK_EXPANSION
:
16684 error ("invalid use of pack expansion expression");
16685 RETURN (error_mark_node
);
16687 case NONTYPE_ARGUMENT_PACK
:
16688 error ("use %<...%> to expand argument pack");
16689 RETURN (error_mark_node
);
16691 case CILK_SPAWN_STMT
:
16692 cfun
->calls_cilk_spawn
= 1;
16693 RETURN (build_cilk_spawn (EXPR_LOCATION (t
), RECUR (CILK_SPAWN_FN (t
))));
16695 case CILK_SYNC_STMT
:
16696 RETURN (build_cilk_sync ());
16698 case COMPOUND_EXPR
:
16699 tmp
= RECUR (TREE_OPERAND (t
, 0));
16700 if (tmp
== NULL_TREE
)
16701 /* If the first operand was a statement, we're done with it. */
16702 RETURN (RECUR (TREE_OPERAND (t
, 1)));
16703 RETURN (build_x_compound_expr (EXPR_LOCATION (t
), tmp
,
16704 RECUR (TREE_OPERAND (t
, 1)),
16707 case ANNOTATE_EXPR
:
16708 tmp
= RECUR (TREE_OPERAND (t
, 0));
16709 RETURN (build2_loc (EXPR_LOCATION (t
), ANNOTATE_EXPR
,
16710 TREE_TYPE (tmp
), tmp
, RECUR (TREE_OPERAND (t
, 1))));
16713 gcc_assert (!STATEMENT_CODE_P (TREE_CODE (t
)));
16715 RETURN (tsubst_copy_and_build (t
, args
, complain
, in_decl
,
16716 /*function_p=*/false,
16717 integral_constant_expression_p
));
16720 RETURN (NULL_TREE
);
16722 input_location
= loc
;
16728 /* Instantiate the special body of the artificial DECL_OMP_DECLARE_REDUCTION
16729 function. For description of the body see comment above
16730 cp_parser_omp_declare_reduction_exprs. */
16733 tsubst_omp_udr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
16735 if (t
== NULL_TREE
|| t
== error_mark_node
)
16738 gcc_assert (TREE_CODE (t
) == STATEMENT_LIST
);
16740 tree_stmt_iterator tsi
;
16743 memset (stmts
, 0, sizeof stmts
);
16744 for (i
= 0, tsi
= tsi_start (t
);
16745 i
< 7 && !tsi_end_p (tsi
);
16746 i
++, tsi_next (&tsi
))
16747 stmts
[i
] = tsi_stmt (tsi
);
16748 gcc_assert (tsi_end_p (tsi
));
16752 gcc_assert (TREE_CODE (stmts
[0]) == DECL_EXPR
16753 && TREE_CODE (stmts
[1]) == DECL_EXPR
);
16754 tree omp_out
= tsubst (DECL_EXPR_DECL (stmts
[0]),
16755 args
, complain
, in_decl
);
16756 tree omp_in
= tsubst (DECL_EXPR_DECL (stmts
[1]),
16757 args
, complain
, in_decl
);
16758 DECL_CONTEXT (omp_out
) = current_function_decl
;
16759 DECL_CONTEXT (omp_in
) = current_function_decl
;
16760 keep_next_level (true);
16761 tree block
= begin_omp_structured_block ();
16762 tsubst_expr (stmts
[2], args
, complain
, in_decl
, false);
16763 block
= finish_omp_structured_block (block
);
16764 block
= maybe_cleanup_point_expr_void (block
);
16765 add_decl_expr (omp_out
);
16766 if (TREE_NO_WARNING (DECL_EXPR_DECL (stmts
[0])))
16767 TREE_NO_WARNING (omp_out
) = 1;
16768 add_decl_expr (omp_in
);
16769 finish_expr_stmt (block
);
16773 gcc_assert (TREE_CODE (stmts
[3]) == DECL_EXPR
16774 && TREE_CODE (stmts
[4]) == DECL_EXPR
);
16775 tree omp_priv
= tsubst (DECL_EXPR_DECL (stmts
[3]),
16776 args
, complain
, in_decl
);
16777 tree omp_orig
= tsubst (DECL_EXPR_DECL (stmts
[4]),
16778 args
, complain
, in_decl
);
16779 DECL_CONTEXT (omp_priv
) = current_function_decl
;
16780 DECL_CONTEXT (omp_orig
) = current_function_decl
;
16781 keep_next_level (true);
16782 tree block
= begin_omp_structured_block ();
16783 tsubst_expr (stmts
[5], args
, complain
, in_decl
, false);
16784 block
= finish_omp_structured_block (block
);
16785 block
= maybe_cleanup_point_expr_void (block
);
16786 cp_walk_tree (&block
, cp_remove_omp_priv_cleanup_stmt
, omp_priv
, NULL
);
16787 add_decl_expr (omp_priv
);
16788 add_decl_expr (omp_orig
);
16789 finish_expr_stmt (block
);
16791 add_decl_expr (omp_orig
);
16795 /* T is a postfix-expression that is not being used in a function
16796 call. Return the substituted version of T. */
16799 tsubst_non_call_postfix_expression (tree t
, tree args
,
16800 tsubst_flags_t complain
,
16803 if (TREE_CODE (t
) == SCOPE_REF
)
16804 t
= tsubst_qualified_id (t
, args
, complain
, in_decl
,
16805 /*done=*/false, /*address_p=*/false);
16807 t
= tsubst_copy_and_build (t
, args
, complain
, in_decl
,
16808 /*function_p=*/false,
16809 /*integral_constant_expression_p=*/false);
16814 /* T is a LAMBDA_EXPR. Generate a new LAMBDA_EXPR for the current
16815 instantiation context. Instantiating a pack expansion containing a lambda
16816 might result in multiple lambdas all based on the same lambda in the
16820 tsubst_lambda_expr (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
16822 tree oldfn
= lambda_function (t
);
16825 tree r
= build_lambda_expr ();
16827 LAMBDA_EXPR_LOCATION (r
)
16828 = LAMBDA_EXPR_LOCATION (t
);
16829 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (r
)
16830 = LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (t
);
16831 LAMBDA_EXPR_MUTABLE_P (r
) = LAMBDA_EXPR_MUTABLE_P (t
);
16833 if (LAMBDA_EXPR_EXTRA_SCOPE (t
) == NULL_TREE
)
16834 LAMBDA_EXPR_EXTRA_SCOPE (r
) = NULL_TREE
;
16836 record_lambda_scope (r
);
16838 gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t
) == NULL_TREE
16839 && LAMBDA_EXPR_PENDING_PROXIES (t
) == NULL
);
16841 for (tree cap
= LAMBDA_EXPR_CAPTURE_LIST (t
); cap
;
16842 cap
= TREE_CHAIN (cap
))
16844 tree field
= TREE_PURPOSE (cap
);
16845 if (PACK_EXPANSION_P (field
))
16846 field
= PACK_EXPANSION_PATTERN (field
);
16847 field
= tsubst_decl (field
, args
, complain
);
16849 if (field
== error_mark_node
)
16850 return error_mark_node
;
16852 tree init
= TREE_VALUE (cap
);
16853 if (PACK_EXPANSION_P (init
))
16854 init
= tsubst_pack_expansion (init
, args
, complain
, in_decl
);
16856 init
= tsubst_copy_and_build (init
, args
, complain
, in_decl
,
16857 /*fn*/false, /*constexpr*/false);
16859 if (TREE_CODE (field
) == TREE_VEC
)
16861 int len
= TREE_VEC_LENGTH (field
);
16862 gcc_assert (TREE_CODE (init
) == TREE_VEC
16863 && TREE_VEC_LENGTH (init
) == len
);
16864 for (int i
= 0; i
< len
; ++i
)
16865 LAMBDA_EXPR_CAPTURE_LIST (r
)
16866 = tree_cons (TREE_VEC_ELT (field
, i
),
16867 TREE_VEC_ELT (init
, i
),
16868 LAMBDA_EXPR_CAPTURE_LIST (r
));
16872 LAMBDA_EXPR_CAPTURE_LIST (r
)
16873 = tree_cons (field
, init
, LAMBDA_EXPR_CAPTURE_LIST (r
));
16875 if (id_equal (DECL_NAME (field
), "__this"))
16876 LAMBDA_EXPR_THIS_CAPTURE (r
) = field
;
16880 tree type
= begin_lambda_type (r
);
16882 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
16883 determine_visibility (TYPE_NAME (type
));
16885 register_capture_members (LAMBDA_EXPR_CAPTURE_LIST (r
));
16887 tree oldtmpl
= (generic_lambda_fn_p (oldfn
)
16888 ? DECL_TI_TEMPLATE (oldfn
)
16891 tree fntype
= static_fn_type (oldfn
);
16893 ++processing_template_decl
;
16894 fntype
= tsubst (fntype
, args
, complain
, in_decl
);
16896 --processing_template_decl
;
16898 if (fntype
== error_mark_node
)
16899 r
= error_mark_node
;
16902 /* Fix the type of 'this'. */
16903 fntype
= build_memfn_type (fntype
, type
,
16904 type_memfn_quals (fntype
),
16905 type_memfn_rqual (fntype
));
16909 tmpl
= tsubst_template_decl (oldtmpl
, args
, complain
, fntype
);
16910 fn
= DECL_TEMPLATE_RESULT (tmpl
);
16911 finish_member_declaration (tmpl
);
16916 fn
= tsubst_function_decl (oldfn
, args
, complain
, fntype
);
16917 finish_member_declaration (fn
);
16920 /* Let finish_function set this. */
16921 DECL_DECLARED_CONSTEXPR_P (fn
) = false;
16923 bool nested
= cfun
;
16925 push_function_context ();
16927 local_specialization_stack
s (lss_copy
);
16929 tree body
= start_lambda_function (fn
, r
);
16931 register_parameter_specializations (oldfn
, fn
);
16933 tsubst_expr (DECL_SAVED_TREE (oldfn
), args
, complain
, r
,
16934 /*constexpr*/false);
16936 finish_lambda_function (body
);
16939 pop_function_context ();
16941 /* The capture list was built up in reverse order; fix that now. */
16942 LAMBDA_EXPR_CAPTURE_LIST (r
)
16943 = nreverse (LAMBDA_EXPR_CAPTURE_LIST (r
));
16945 LAMBDA_EXPR_THIS_CAPTURE (r
) = NULL_TREE
;
16947 maybe_add_lambda_conv_op (type
);
16950 finish_struct (type
, /*attr*/NULL_TREE
);
16952 insert_pending_capture_proxies ();
16957 /* Like tsubst but deals with expressions and performs semantic
16958 analysis. FUNCTION_P is true if T is the "F" in "F (ARGS)". */
16961 tsubst_copy_and_build (tree t
,
16963 tsubst_flags_t complain
,
16966 bool integral_constant_expression_p
)
16968 #define RETURN(EXP) do { retval = (EXP); goto out; } while(0)
16969 #define RECUR(NODE) \
16970 tsubst_copy_and_build (NODE, args, complain, in_decl, \
16971 /*function_p=*/false, \
16972 integral_constant_expression_p)
16977 if (t
== NULL_TREE
|| t
== error_mark_node
)
16980 loc
= input_location
;
16981 if (EXPR_HAS_LOCATION (t
))
16982 input_location
= EXPR_LOCATION (t
);
16984 /* N3276 decltype magic only applies to calls at the top level or on the
16985 right side of a comma. */
16986 tsubst_flags_t decltype_flag
= (complain
& tf_decltype
);
16987 complain
&= ~tf_decltype
;
16989 switch (TREE_CODE (t
))
16993 /* Fall through. */
16994 case IDENTIFIER_NODE
:
16998 bool non_integral_constant_expression_p
;
16999 const char *error_msg
;
17001 if (IDENTIFIER_CONV_OP_P (t
))
17003 tree new_type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
17004 t
= make_conv_op_name (new_type
);
17007 /* Look up the name. */
17008 decl
= lookup_name (t
);
17010 /* By convention, expressions use ERROR_MARK_NODE to indicate
17011 failure, not NULL_TREE. */
17012 if (decl
== NULL_TREE
)
17013 decl
= error_mark_node
;
17015 decl
= finish_id_expression (t
, decl
, NULL_TREE
,
17017 integral_constant_expression_p
,
17018 /*allow_non_integral_constant_expression_p=*/(cxx_dialect
>= cxx11
),
17019 &non_integral_constant_expression_p
,
17020 /*template_p=*/false,
17022 /*address_p=*/false,
17023 /*template_arg_p=*/false,
17028 if (!function_p
&& identifier_p (decl
))
17030 if (complain
& tf_error
)
17031 unqualified_name_lookup_error (decl
);
17032 decl
= error_mark_node
;
17037 case TEMPLATE_ID_EXPR
:
17040 tree templ
= RECUR (TREE_OPERAND (t
, 0));
17041 tree targs
= TREE_OPERAND (t
, 1);
17044 targs
= tsubst_template_args (targs
, args
, complain
, in_decl
);
17045 if (targs
== error_mark_node
)
17046 return error_mark_node
;
17048 if (TREE_CODE (templ
) == SCOPE_REF
)
17050 tree name
= TREE_OPERAND (templ
, 1);
17051 tree tid
= lookup_template_function (name
, targs
);
17052 TREE_OPERAND (templ
, 1) = tid
;
17056 if (variable_template_p (templ
))
17057 RETURN (lookup_and_finish_template_variable (templ
, targs
, complain
));
17059 if (TREE_CODE (templ
) == COMPONENT_REF
)
17061 object
= TREE_OPERAND (templ
, 0);
17062 templ
= TREE_OPERAND (templ
, 1);
17065 object
= NULL_TREE
;
17066 templ
= lookup_template_function (templ
, targs
);
17069 RETURN (build3 (COMPONENT_REF
, TREE_TYPE (templ
),
17070 object
, templ
, NULL_TREE
));
17072 RETURN (baselink_for_fns (templ
));
17077 tree r
= RECUR (TREE_OPERAND (t
, 0));
17079 if (REFERENCE_REF_P (t
))
17081 /* A type conversion to reference type will be enclosed in
17082 such an indirect ref, but the substitution of the cast
17083 will have also added such an indirect ref. */
17084 r
= convert_from_reference (r
);
17087 r
= build_x_indirect_ref (input_location
, r
, RO_UNARY_STAR
,
17088 complain
|decltype_flag
);
17090 if (TREE_CODE (r
) == INDIRECT_REF
)
17091 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
17098 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
17099 tree op0
= RECUR (TREE_OPERAND (t
, 0));
17100 RETURN (build_nop (type
, op0
));
17103 case IMPLICIT_CONV_EXPR
:
17105 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
17106 tree expr
= RECUR (TREE_OPERAND (t
, 0));
17107 int flags
= LOOKUP_IMPLICIT
;
17108 if (IMPLICIT_CONV_EXPR_DIRECT_INIT (t
))
17109 flags
= LOOKUP_NORMAL
;
17110 RETURN (perform_implicit_conversion_flags (type
, expr
, complain
,
17116 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
17117 tree op0
= RECUR (TREE_OPERAND (t
, 0));
17118 RETURN (build1 (CONVERT_EXPR
, type
, op0
));
17122 case REINTERPRET_CAST_EXPR
:
17123 case CONST_CAST_EXPR
:
17124 case DYNAMIC_CAST_EXPR
:
17125 case STATIC_CAST_EXPR
:
17128 tree op
, r
= NULL_TREE
;
17130 type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
17131 if (integral_constant_expression_p
17132 && !cast_valid_in_integral_constant_expression_p (type
))
17134 if (complain
& tf_error
)
17135 error ("a cast to a type other than an integral or "
17136 "enumeration type cannot appear in a constant-expression");
17137 RETURN (error_mark_node
);
17140 op
= RECUR (TREE_OPERAND (t
, 0));
17142 warning_sentinel
s(warn_useless_cast
);
17143 switch (TREE_CODE (t
))
17146 r
= build_functional_cast (type
, op
, complain
);
17148 case REINTERPRET_CAST_EXPR
:
17149 r
= build_reinterpret_cast (type
, op
, complain
);
17151 case CONST_CAST_EXPR
:
17152 r
= build_const_cast (type
, op
, complain
);
17154 case DYNAMIC_CAST_EXPR
:
17155 r
= build_dynamic_cast (type
, op
, complain
);
17157 case STATIC_CAST_EXPR
:
17158 r
= build_static_cast (type
, op
, complain
);
17161 gcc_unreachable ();
17167 case POSTDECREMENT_EXPR
:
17168 case POSTINCREMENT_EXPR
:
17169 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
17170 args
, complain
, in_decl
);
17171 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
), op1
,
17172 complain
|decltype_flag
));
17174 case PREDECREMENT_EXPR
:
17175 case PREINCREMENT_EXPR
:
17179 case TRUTH_NOT_EXPR
:
17180 case UNARY_PLUS_EXPR
: /* Unary + */
17181 case REALPART_EXPR
:
17182 case IMAGPART_EXPR
:
17183 RETURN (build_x_unary_op (input_location
, TREE_CODE (t
),
17184 RECUR (TREE_OPERAND (t
, 0)),
17185 complain
|decltype_flag
));
17187 case FIX_TRUNC_EXPR
:
17188 RETURN (cp_build_unary_op (FIX_TRUNC_EXPR
, RECUR (TREE_OPERAND (t
, 0)),
17192 op1
= TREE_OPERAND (t
, 0);
17193 if (TREE_CODE (op1
) == LABEL_DECL
)
17194 RETURN (finish_label_address_expr (DECL_NAME (op1
),
17195 EXPR_LOCATION (op1
)));
17196 if (TREE_CODE (op1
) == SCOPE_REF
)
17197 op1
= tsubst_qualified_id (op1
, args
, complain
, in_decl
,
17198 /*done=*/true, /*address_p=*/true);
17200 op1
= tsubst_non_call_postfix_expression (op1
, args
, complain
,
17202 RETURN (build_x_unary_op (input_location
, ADDR_EXPR
, op1
,
17203 complain
|decltype_flag
));
17208 case TRUNC_DIV_EXPR
:
17209 case CEIL_DIV_EXPR
:
17210 case FLOOR_DIV_EXPR
:
17211 case ROUND_DIV_EXPR
:
17212 case EXACT_DIV_EXPR
:
17216 case TRUNC_MOD_EXPR
:
17217 case FLOOR_MOD_EXPR
:
17218 case TRUTH_ANDIF_EXPR
:
17219 case TRUTH_ORIF_EXPR
:
17220 case TRUTH_AND_EXPR
:
17221 case TRUTH_OR_EXPR
:
17237 warning_sentinel
s1(warn_type_limits
);
17238 warning_sentinel
s2(warn_div_by_zero
);
17239 warning_sentinel
s3(warn_logical_op
);
17240 warning_sentinel
s4(warn_tautological_compare
);
17241 tree op0
= RECUR (TREE_OPERAND (t
, 0));
17242 tree op1
= RECUR (TREE_OPERAND (t
, 1));
17243 tree r
= build_x_binary_op
17244 (input_location
, TREE_CODE (t
),
17246 (TREE_NO_WARNING (TREE_OPERAND (t
, 0))
17248 : TREE_CODE (TREE_OPERAND (t
, 0))),
17250 (TREE_NO_WARNING (TREE_OPERAND (t
, 1))
17252 : TREE_CODE (TREE_OPERAND (t
, 1))),
17254 complain
|decltype_flag
);
17255 if (EXPR_P (r
) && TREE_NO_WARNING (t
))
17256 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
17261 case POINTER_PLUS_EXPR
:
17263 tree op0
= RECUR (TREE_OPERAND (t
, 0));
17264 tree op1
= RECUR (TREE_OPERAND (t
, 1));
17265 return fold_build_pointer_plus (op0
, op1
);
17269 RETURN (tsubst_qualified_id (t
, args
, complain
, in_decl
, /*done=*/true,
17270 /*address_p=*/false));
17272 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
17273 args
, complain
, in_decl
);
17274 RETURN (build_x_array_ref (EXPR_LOCATION (t
), op1
,
17275 RECUR (TREE_OPERAND (t
, 1)),
17276 complain
|decltype_flag
));
17278 case ARRAY_NOTATION_REF
:
17280 tree start_index
, length
, stride
;
17281 op1
= tsubst_non_call_postfix_expression (ARRAY_NOTATION_ARRAY (t
),
17282 args
, complain
, in_decl
);
17283 start_index
= RECUR (ARRAY_NOTATION_START (t
));
17284 length
= RECUR (ARRAY_NOTATION_LENGTH (t
));
17285 stride
= RECUR (ARRAY_NOTATION_STRIDE (t
));
17286 RETURN (build_array_notation_ref (EXPR_LOCATION (t
), op1
, start_index
,
17287 length
, stride
, TREE_TYPE (op1
)));
17290 if (PACK_EXPANSION_P (TREE_OPERAND (t
, 0))
17291 || ARGUMENT_PACK_P (TREE_OPERAND (t
, 0)))
17292 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
17299 op1
= TREE_OPERAND (t
, 0);
17300 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
17301 op1
= TREE_TYPE (op1
);
17304 /* When there are no ARGS, we are trying to evaluate a
17305 non-dependent expression from the parser. Trying to do
17306 the substitutions may not work. */
17308 op1
= TREE_TYPE (op1
);
17312 ++cp_unevaluated_operand
;
17313 ++c_inhibit_evaluation_warnings
;
17315 op1
= tsubst (op1
, args
, complain
, in_decl
);
17317 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
17318 /*function_p=*/false,
17319 /*integral_constant_expression_p=*/
17321 --cp_unevaluated_operand
;
17322 --c_inhibit_evaluation_warnings
;
17325 r
= cxx_sizeof_or_alignof_type (op1
, TREE_CODE (t
),
17326 complain
& tf_error
);
17328 r
= cxx_sizeof_or_alignof_expr (op1
, TREE_CODE (t
),
17329 complain
& tf_error
);
17330 if (TREE_CODE (t
) == SIZEOF_EXPR
&& r
!= error_mark_node
)
17332 if (TREE_CODE (r
) != SIZEOF_EXPR
|| TYPE_P (op1
))
17334 if (!processing_template_decl
&& TYPE_P (op1
))
17336 r
= build_min (SIZEOF_EXPR
, size_type_node
,
17337 build1 (NOP_EXPR
, op1
, error_mark_node
));
17338 SIZEOF_EXPR_TYPE_P (r
) = 1;
17341 r
= build_min (SIZEOF_EXPR
, size_type_node
, op1
);
17342 TREE_SIDE_EFFECTS (r
) = 0;
17343 TREE_READONLY (r
) = 1;
17345 SET_EXPR_LOCATION (r
, EXPR_LOCATION (t
));
17350 case AT_ENCODE_EXPR
:
17352 op1
= TREE_OPERAND (t
, 0);
17353 ++cp_unevaluated_operand
;
17354 ++c_inhibit_evaluation_warnings
;
17355 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
17356 /*function_p=*/false,
17357 /*integral_constant_expression_p=*/false);
17358 --cp_unevaluated_operand
;
17359 --c_inhibit_evaluation_warnings
;
17360 RETURN (objc_build_encode_expr (op1
));
17363 case NOEXCEPT_EXPR
:
17364 op1
= TREE_OPERAND (t
, 0);
17365 ++cp_unevaluated_operand
;
17366 ++c_inhibit_evaluation_warnings
;
17367 ++cp_noexcept_operand
;
17368 op1
= tsubst_copy_and_build (op1
, args
, complain
, in_decl
,
17369 /*function_p=*/false,
17370 /*integral_constant_expression_p=*/false);
17371 --cp_unevaluated_operand
;
17372 --c_inhibit_evaluation_warnings
;
17373 --cp_noexcept_operand
;
17374 RETURN (finish_noexcept_expr (op1
, complain
));
17378 warning_sentinel
s(warn_div_by_zero
);
17379 tree lhs
= RECUR (TREE_OPERAND (t
, 0));
17380 tree rhs
= RECUR (TREE_OPERAND (t
, 2));
17381 tree r
= build_x_modify_expr
17382 (EXPR_LOCATION (t
), lhs
, TREE_CODE (TREE_OPERAND (t
, 1)), rhs
,
17383 complain
|decltype_flag
);
17384 /* TREE_NO_WARNING must be set if either the expression was
17385 parenthesized or it uses an operator such as >>= rather
17386 than plain assignment. In the former case, it was already
17387 set and must be copied. In the latter case,
17388 build_x_modify_expr sets it and it must not be reset
17390 if (TREE_NO_WARNING (t
))
17391 TREE_NO_WARNING (r
) = TREE_NO_WARNING (t
);
17397 op1
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
17398 args
, complain
, in_decl
);
17399 /* Remember that there was a reference to this entity. */
17401 && !mark_used (op1
, complain
) && !(complain
& tf_error
))
17402 RETURN (error_mark_node
);
17403 RETURN (build_x_arrow (input_location
, op1
, complain
));
17407 tree placement
= RECUR (TREE_OPERAND (t
, 0));
17408 tree init
= RECUR (TREE_OPERAND (t
, 3));
17409 vec
<tree
, va_gc
> *placement_vec
;
17410 vec
<tree
, va_gc
> *init_vec
;
17413 if (placement
== NULL_TREE
)
17414 placement_vec
= NULL
;
17417 placement_vec
= make_tree_vector ();
17418 for (; placement
!= NULL_TREE
; placement
= TREE_CHAIN (placement
))
17419 vec_safe_push (placement_vec
, TREE_VALUE (placement
));
17422 /* If there was an initializer in the original tree, but it
17423 instantiated to an empty list, then we should pass a
17424 non-NULL empty vector to tell build_new that it was an
17425 empty initializer() rather than no initializer. This can
17426 only happen when the initializer is a pack expansion whose
17427 parameter packs are of length zero. */
17428 if (init
== NULL_TREE
&& TREE_OPERAND (t
, 3) == NULL_TREE
)
17432 init_vec
= make_tree_vector ();
17433 if (init
== void_node
)
17434 gcc_assert (init_vec
!= NULL
);
17437 for (; init
!= NULL_TREE
; init
= TREE_CHAIN (init
))
17438 vec_safe_push (init_vec
, TREE_VALUE (init
));
17442 tree op1
= tsubst (TREE_OPERAND (t
, 1), args
, complain
, in_decl
);
17443 tree op2
= RECUR (TREE_OPERAND (t
, 2));
17444 ret
= build_new (&placement_vec
, op1
, op2
, &init_vec
,
17445 NEW_EXPR_USE_GLOBAL (t
),
17448 if (placement_vec
!= NULL
)
17449 release_tree_vector (placement_vec
);
17450 if (init_vec
!= NULL
)
17451 release_tree_vector (init_vec
);
17458 tree op0
= RECUR (TREE_OPERAND (t
, 0));
17459 tree op1
= RECUR (TREE_OPERAND (t
, 1));
17460 RETURN (delete_sanity (op0
, op1
,
17461 DELETE_EXPR_USE_VEC (t
),
17462 DELETE_EXPR_USE_GLOBAL (t
),
17466 case COMPOUND_EXPR
:
17468 tree op0
= tsubst_copy_and_build (TREE_OPERAND (t
, 0), args
,
17469 complain
& ~tf_decltype
, in_decl
,
17470 /*function_p=*/false,
17471 integral_constant_expression_p
);
17472 RETURN (build_x_compound_expr (EXPR_LOCATION (t
),
17474 RECUR (TREE_OPERAND (t
, 1)),
17475 complain
|decltype_flag
));
17481 vec
<tree
, va_gc
> *call_args
;
17482 unsigned int nargs
, i
;
17487 function
= CALL_EXPR_FN (t
);
17488 /* Internal function with no arguments. */
17489 if (function
== NULL_TREE
&& call_expr_nargs (t
) == 0)
17492 /* When we parsed the expression, we determined whether or
17493 not Koenig lookup should be performed. */
17494 koenig_p
= KOENIG_LOOKUP_P (t
);
17495 if (function
== NULL_TREE
)
17498 qualified_p
= false;
17500 else if (TREE_CODE (function
) == SCOPE_REF
)
17502 qualified_p
= true;
17503 function
= tsubst_qualified_id (function
, args
, complain
, in_decl
,
17505 /*address_p=*/false);
17507 else if (koenig_p
&& identifier_p (function
))
17509 /* Do nothing; calling tsubst_copy_and_build on an identifier
17510 would incorrectly perform unqualified lookup again.
17512 Note that we can also have an IDENTIFIER_NODE if the earlier
17513 unqualified lookup found a member function; in that case
17514 koenig_p will be false and we do want to do the lookup
17515 again to find the instantiated member function.
17517 FIXME but doing that causes c++/15272, so we need to stop
17518 using IDENTIFIER_NODE in that situation. */
17519 qualified_p
= false;
17523 if (TREE_CODE (function
) == COMPONENT_REF
)
17525 tree op
= TREE_OPERAND (function
, 1);
17527 qualified_p
= (TREE_CODE (op
) == SCOPE_REF
17528 || (BASELINK_P (op
)
17529 && BASELINK_QUALIFIED_P (op
)));
17532 qualified_p
= false;
17534 if (TREE_CODE (function
) == ADDR_EXPR
17535 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
17536 /* Avoid error about taking the address of a constructor. */
17537 function
= TREE_OPERAND (function
, 0);
17539 function
= tsubst_copy_and_build (function
, args
, complain
,
17542 integral_constant_expression_p
);
17544 if (BASELINK_P (function
))
17545 qualified_p
= true;
17548 nargs
= call_expr_nargs (t
);
17549 call_args
= make_tree_vector ();
17550 for (i
= 0; i
< nargs
; ++i
)
17552 tree arg
= CALL_EXPR_ARG (t
, i
);
17554 if (!PACK_EXPANSION_P (arg
))
17555 vec_safe_push (call_args
, RECUR (CALL_EXPR_ARG (t
, i
)));
17558 /* Expand the pack expansion and push each entry onto
17560 arg
= tsubst_pack_expansion (arg
, args
, complain
, in_decl
);
17561 if (TREE_CODE (arg
) == TREE_VEC
)
17563 unsigned int len
, j
;
17565 len
= TREE_VEC_LENGTH (arg
);
17566 for (j
= 0; j
< len
; ++j
)
17568 tree value
= TREE_VEC_ELT (arg
, j
);
17569 if (value
!= NULL_TREE
)
17570 value
= convert_from_reference (value
);
17571 vec_safe_push (call_args
, value
);
17576 /* A partial substitution. Add one entry. */
17577 vec_safe_push (call_args
, arg
);
17582 /* We do not perform argument-dependent lookup if normal
17583 lookup finds a non-function, in accordance with the
17584 expected resolution of DR 218. */
17586 && ((is_overloaded_fn (function
)
17587 /* If lookup found a member function, the Koenig lookup is
17588 not appropriate, even if an unqualified-name was used
17589 to denote the function. */
17590 && !DECL_FUNCTION_MEMBER_P (get_first_fn (function
)))
17591 || identifier_p (function
))
17592 /* Only do this when substitution turns a dependent call
17593 into a non-dependent call. */
17594 && type_dependent_expression_p_push (t
)
17595 && !any_type_dependent_arguments_p (call_args
))
17596 function
= perform_koenig_lookup (function
, call_args
, tf_none
);
17598 if (function
!= NULL_TREE
17599 && identifier_p (function
)
17600 && !any_type_dependent_arguments_p (call_args
))
17602 if (koenig_p
&& (complain
& tf_warning_or_error
))
17604 /* For backwards compatibility and good diagnostics, try
17605 the unqualified lookup again if we aren't in SFINAE
17607 tree unq
= (tsubst_copy_and_build
17608 (function
, args
, complain
, in_decl
, true,
17609 integral_constant_expression_p
));
17610 if (unq
== error_mark_node
)
17612 release_tree_vector (call_args
);
17613 RETURN (error_mark_node
);
17616 if (unq
!= function
)
17618 /* In a lambda fn, we have to be careful to not
17619 introduce new this captures. Legacy code can't
17620 be using lambdas anyway, so it's ok to be
17622 bool in_lambda
= (current_class_type
17623 && LAMBDA_TYPE_P (current_class_type
));
17624 char const *const msg
17625 = G_("%qD was not declared in this scope, "
17626 "and no declarations were found by "
17627 "argument-dependent lookup at the point "
17628 "of instantiation");
17632 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
17635 diag
= permerror (EXPR_LOC_OR_LOC (t
, input_location
),
17641 if (INDIRECT_REF_P (fn
))
17642 fn
= TREE_OPERAND (fn
, 0);
17643 if (is_overloaded_fn (fn
))
17644 fn
= get_first_fn (fn
);
17647 /* Can't say anything more. */;
17648 else if (DECL_CLASS_SCOPE_P (fn
))
17650 location_t loc
= EXPR_LOC_OR_LOC (t
,
17653 "declarations in dependent base %qT are "
17654 "not found by unqualified lookup",
17655 DECL_CLASS_CONTEXT (fn
));
17656 if (current_class_ptr
)
17658 "use %<this->%D%> instead", function
);
17661 "use %<%T::%D%> instead",
17662 current_class_name
, function
);
17665 inform (DECL_SOURCE_LOCATION (fn
),
17666 "%qD declared here, later in the "
17667 "translation unit", fn
);
17670 release_tree_vector (call_args
);
17671 RETURN (error_mark_node
);
17678 if (identifier_p (function
))
17680 if (complain
& tf_error
)
17681 unqualified_name_lookup_error (function
);
17682 release_tree_vector (call_args
);
17683 RETURN (error_mark_node
);
17687 /* Remember that there was a reference to this entity. */
17688 if (function
!= NULL_TREE
17689 && DECL_P (function
)
17690 && !mark_used (function
, complain
) && !(complain
& tf_error
))
17692 release_tree_vector (call_args
);
17693 RETURN (error_mark_node
);
17696 /* Put back tf_decltype for the actual call. */
17697 complain
|= decltype_flag
;
17699 if (function
== NULL_TREE
)
17700 switch (CALL_EXPR_IFN (t
))
17703 gcc_assert (nargs
== 1);
17704 if (vec_safe_length (call_args
) != 1)
17706 error_at (EXPR_LOC_OR_LOC (t
, input_location
),
17707 "wrong number of arguments to "
17708 "%<__builtin_launder%>");
17709 ret
= error_mark_node
;
17712 ret
= finish_builtin_launder (EXPR_LOC_OR_LOC (t
,
17714 (*call_args
)[0], complain
);
17718 /* Unsupported internal function with arguments. */
17719 gcc_unreachable ();
17721 else if (TREE_CODE (function
) == OFFSET_REF
)
17722 ret
= build_offset_ref_call_from_tree (function
, &call_args
,
17724 else if (TREE_CODE (function
) == COMPONENT_REF
)
17726 tree instance
= TREE_OPERAND (function
, 0);
17727 tree fn
= TREE_OPERAND (function
, 1);
17729 if (processing_template_decl
17730 && (type_dependent_expression_p (instance
)
17731 || (!BASELINK_P (fn
)
17732 && TREE_CODE (fn
) != FIELD_DECL
)
17733 || type_dependent_expression_p (fn
)
17734 || any_type_dependent_arguments_p (call_args
)))
17735 ret
= build_min_nt_call_vec (function
, call_args
);
17736 else if (!BASELINK_P (fn
))
17737 ret
= finish_call_expr (function
, &call_args
,
17738 /*disallow_virtual=*/false,
17739 /*koenig_p=*/false,
17742 ret
= (build_new_method_call
17744 &call_args
, NULL_TREE
,
17745 qualified_p
? LOOKUP_NONVIRTUAL
: LOOKUP_NORMAL
,
17750 ret
= finish_call_expr (function
, &call_args
,
17751 /*disallow_virtual=*/qualified_p
,
17755 release_tree_vector (call_args
);
17757 if (ret
!= error_mark_node
)
17759 bool op
= CALL_EXPR_OPERATOR_SYNTAX (t
);
17760 bool ord
= CALL_EXPR_ORDERED_ARGS (t
);
17761 bool rev
= CALL_EXPR_REVERSE_ARGS (t
);
17762 bool thk
= CALL_FROM_THUNK_P (t
);
17763 if (op
|| ord
|| rev
|| thk
)
17765 function
= extract_call_expr (ret
);
17766 CALL_EXPR_OPERATOR_SYNTAX (function
) = op
;
17767 CALL_EXPR_ORDERED_ARGS (function
) = ord
;
17768 CALL_EXPR_REVERSE_ARGS (function
) = rev
;
17771 CALL_FROM_THUNK_P (function
) = true;
17772 /* The thunk location is not interesting. */
17773 SET_EXPR_LOCATION (function
, UNKNOWN_LOCATION
);
17783 tree cond
= RECUR (TREE_OPERAND (t
, 0));
17784 tree folded_cond
= fold_non_dependent_expr (cond
);
17787 if (TREE_CODE (folded_cond
) == INTEGER_CST
)
17789 if (integer_zerop (folded_cond
))
17791 ++c_inhibit_evaluation_warnings
;
17792 exp1
= RECUR (TREE_OPERAND (t
, 1));
17793 --c_inhibit_evaluation_warnings
;
17794 exp2
= RECUR (TREE_OPERAND (t
, 2));
17798 exp1
= RECUR (TREE_OPERAND (t
, 1));
17799 ++c_inhibit_evaluation_warnings
;
17800 exp2
= RECUR (TREE_OPERAND (t
, 2));
17801 --c_inhibit_evaluation_warnings
;
17803 cond
= folded_cond
;
17807 exp1
= RECUR (TREE_OPERAND (t
, 1));
17808 exp2
= RECUR (TREE_OPERAND (t
, 2));
17811 RETURN (build_x_conditional_expr (EXPR_LOCATION (t
),
17812 cond
, exp1
, exp2
, complain
));
17815 case PSEUDO_DTOR_EXPR
:
17817 tree op0
= RECUR (TREE_OPERAND (t
, 0));
17818 tree op1
= RECUR (TREE_OPERAND (t
, 1));
17819 tree op2
= tsubst (TREE_OPERAND (t
, 2), args
, complain
, in_decl
);
17820 RETURN (finish_pseudo_destructor_expr (op0
, op1
, op2
,
17826 tree purpose
, value
, chain
;
17828 if (t
== void_list_node
)
17831 if ((TREE_PURPOSE (t
) && PACK_EXPANSION_P (TREE_PURPOSE (t
)))
17832 || (TREE_VALUE (t
) && PACK_EXPANSION_P (TREE_VALUE (t
))))
17834 /* We have pack expansions, so expand those and
17835 create a new list out of it. */
17836 tree purposevec
= NULL_TREE
;
17837 tree valuevec
= NULL_TREE
;
17841 /* Expand the argument expressions. */
17842 if (TREE_PURPOSE (t
))
17843 purposevec
= tsubst_pack_expansion (TREE_PURPOSE (t
), args
,
17844 complain
, in_decl
);
17845 if (TREE_VALUE (t
))
17846 valuevec
= tsubst_pack_expansion (TREE_VALUE (t
), args
,
17847 complain
, in_decl
);
17849 /* Build the rest of the list. */
17850 chain
= TREE_CHAIN (t
);
17851 if (chain
&& chain
!= void_type_node
)
17852 chain
= RECUR (chain
);
17854 /* Determine the number of arguments. */
17855 if (purposevec
&& TREE_CODE (purposevec
) == TREE_VEC
)
17857 len
= TREE_VEC_LENGTH (purposevec
);
17858 gcc_assert (!valuevec
|| len
== TREE_VEC_LENGTH (valuevec
));
17860 else if (TREE_CODE (valuevec
) == TREE_VEC
)
17861 len
= TREE_VEC_LENGTH (valuevec
);
17864 /* Since we only performed a partial substitution into
17865 the argument pack, we only RETURN (a single list
17867 if (purposevec
== TREE_PURPOSE (t
)
17868 && valuevec
== TREE_VALUE (t
)
17869 && chain
== TREE_CHAIN (t
))
17872 RETURN (tree_cons (purposevec
, valuevec
, chain
));
17875 /* Convert the argument vectors into a TREE_LIST */
17879 /* Grab the Ith values. */
17881 purpose
= purposevec
? TREE_VEC_ELT (purposevec
, i
)
17884 = valuevec
? convert_from_reference (TREE_VEC_ELT (valuevec
, i
))
17887 /* Build the list (backwards). */
17888 chain
= tree_cons (purpose
, value
, chain
);
17894 purpose
= TREE_PURPOSE (t
);
17896 purpose
= RECUR (purpose
);
17897 value
= TREE_VALUE (t
);
17899 value
= RECUR (value
);
17900 chain
= TREE_CHAIN (t
);
17901 if (chain
&& chain
!= void_type_node
)
17902 chain
= RECUR (chain
);
17903 if (purpose
== TREE_PURPOSE (t
)
17904 && value
== TREE_VALUE (t
)
17905 && chain
== TREE_CHAIN (t
))
17907 RETURN (tree_cons (purpose
, value
, chain
));
17910 case COMPONENT_REF
:
17917 object
= tsubst_non_call_postfix_expression (TREE_OPERAND (t
, 0),
17918 args
, complain
, in_decl
);
17919 /* Remember that there was a reference to this entity. */
17920 if (DECL_P (object
)
17921 && !mark_used (object
, complain
) && !(complain
& tf_error
))
17922 RETURN (error_mark_node
);
17923 object_type
= TREE_TYPE (object
);
17925 member
= TREE_OPERAND (t
, 1);
17926 if (BASELINK_P (member
))
17927 member
= tsubst_baselink (member
,
17928 non_reference (TREE_TYPE (object
)),
17929 args
, complain
, in_decl
);
17931 member
= tsubst_copy (member
, args
, complain
, in_decl
);
17932 if (member
== error_mark_node
)
17933 RETURN (error_mark_node
);
17935 if (TREE_CODE (member
) == FIELD_DECL
)
17937 r
= finish_non_static_data_member (member
, object
, NULL_TREE
);
17938 if (TREE_CODE (r
) == COMPONENT_REF
)
17939 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
17942 else if (type_dependent_expression_p (object
))
17943 /* We can't do much here. */;
17944 else if (!CLASS_TYPE_P (object_type
))
17946 if (scalarish_type_p (object_type
))
17948 tree s
= NULL_TREE
;
17949 tree dtor
= member
;
17951 if (TREE_CODE (dtor
) == SCOPE_REF
)
17953 s
= TREE_OPERAND (dtor
, 0);
17954 dtor
= TREE_OPERAND (dtor
, 1);
17956 if (TREE_CODE (dtor
) == BIT_NOT_EXPR
)
17958 dtor
= TREE_OPERAND (dtor
, 0);
17960 RETURN (finish_pseudo_destructor_expr
17961 (object
, s
, dtor
, input_location
));
17965 else if (TREE_CODE (member
) == SCOPE_REF
17966 && TREE_CODE (TREE_OPERAND (member
, 1)) == TEMPLATE_ID_EXPR
)
17968 /* Lookup the template functions now that we know what the
17970 tree scope
= TREE_OPERAND (member
, 0);
17971 tree tmpl
= TREE_OPERAND (TREE_OPERAND (member
, 1), 0);
17972 tree args
= TREE_OPERAND (TREE_OPERAND (member
, 1), 1);
17973 member
= lookup_qualified_name (scope
, tmpl
,
17974 /*is_type_p=*/false,
17975 /*complain=*/false);
17976 if (BASELINK_P (member
))
17978 BASELINK_FUNCTIONS (member
)
17979 = build_nt (TEMPLATE_ID_EXPR
, BASELINK_FUNCTIONS (member
),
17981 member
= (adjust_result_of_qualified_name_lookup
17982 (member
, BINFO_TYPE (BASELINK_BINFO (member
)),
17987 qualified_name_lookup_error (scope
, tmpl
, member
,
17989 RETURN (error_mark_node
);
17992 else if (TREE_CODE (member
) == SCOPE_REF
17993 && !CLASS_TYPE_P (TREE_OPERAND (member
, 0))
17994 && TREE_CODE (TREE_OPERAND (member
, 0)) != NAMESPACE_DECL
)
17996 if (complain
& tf_error
)
17998 if (TYPE_P (TREE_OPERAND (member
, 0)))
17999 error ("%qT is not a class or namespace",
18000 TREE_OPERAND (member
, 0));
18002 error ("%qD is not a class or namespace",
18003 TREE_OPERAND (member
, 0));
18005 RETURN (error_mark_node
);
18008 r
= finish_class_member_access_expr (object
, member
,
18009 /*template_p=*/false,
18011 if (TREE_CODE (r
) == COMPONENT_REF
)
18012 REF_PARENTHESIZED_P (r
) = REF_PARENTHESIZED_P (t
);
18017 RETURN (build_throw
18018 (RECUR (TREE_OPERAND (t
, 0))));
18022 vec
<constructor_elt
, va_gc
> *n
;
18023 constructor_elt
*ce
;
18024 unsigned HOST_WIDE_INT idx
;
18025 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
18026 bool process_index_p
;
18028 bool need_copy_p
= false;
18031 if (type
== error_mark_node
)
18032 RETURN (error_mark_node
);
18034 /* digest_init will do the wrong thing if we let it. */
18035 if (type
&& TYPE_PTRMEMFUNC_P (type
))
18038 /* We do not want to process the index of aggregate
18039 initializers as they are identifier nodes which will be
18040 looked up by digest_init. */
18041 process_index_p
= !(type
&& MAYBE_CLASS_TYPE_P (type
));
18043 n
= vec_safe_copy (CONSTRUCTOR_ELTS (t
));
18044 newlen
= vec_safe_length (n
);
18045 FOR_EACH_VEC_SAFE_ELT (n
, idx
, ce
)
18047 if (ce
->index
&& process_index_p
18048 /* An identifier index is looked up in the type
18049 being initialized, not the current scope. */
18050 && TREE_CODE (ce
->index
) != IDENTIFIER_NODE
)
18051 ce
->index
= RECUR (ce
->index
);
18053 if (PACK_EXPANSION_P (ce
->value
))
18055 /* Substitute into the pack expansion. */
18056 ce
->value
= tsubst_pack_expansion (ce
->value
, args
, complain
,
18059 if (ce
->value
== error_mark_node
18060 || PACK_EXPANSION_P (ce
->value
))
18062 else if (TREE_VEC_LENGTH (ce
->value
) == 1)
18063 /* Just move the argument into place. */
18064 ce
->value
= TREE_VEC_ELT (ce
->value
, 0);
18067 /* Update the length of the final CONSTRUCTOR
18068 arguments vector, and note that we will need to
18070 newlen
= newlen
+ TREE_VEC_LENGTH (ce
->value
) - 1;
18071 need_copy_p
= true;
18075 ce
->value
= RECUR (ce
->value
);
18080 vec
<constructor_elt
, va_gc
> *old_n
= n
;
18082 vec_alloc (n
, newlen
);
18083 FOR_EACH_VEC_ELT (*old_n
, idx
, ce
)
18085 if (TREE_CODE (ce
->value
) == TREE_VEC
)
18087 int i
, len
= TREE_VEC_LENGTH (ce
->value
);
18088 for (i
= 0; i
< len
; ++i
)
18089 CONSTRUCTOR_APPEND_ELT (n
, 0,
18090 TREE_VEC_ELT (ce
->value
, i
));
18093 CONSTRUCTOR_APPEND_ELT (n
, 0, ce
->value
);
18097 r
= build_constructor (init_list_type_node
, n
);
18098 CONSTRUCTOR_IS_DIRECT_INIT (r
) = CONSTRUCTOR_IS_DIRECT_INIT (t
);
18100 if (TREE_HAS_CONSTRUCTOR (t
))
18102 fcl_t cl
= fcl_functional
;
18103 if (CONSTRUCTOR_C99_COMPOUND_LITERAL (t
))
18105 RETURN (finish_compound_literal (type
, r
, complain
, cl
));
18108 TREE_TYPE (r
) = type
;
18114 tree operand_0
= TREE_OPERAND (t
, 0);
18115 if (TYPE_P (operand_0
))
18117 operand_0
= tsubst (operand_0
, args
, complain
, in_decl
);
18118 RETURN (get_typeid (operand_0
, complain
));
18122 operand_0
= RECUR (operand_0
);
18123 RETURN (build_typeid (operand_0
, complain
));
18130 else if (DECL_PACK_P (t
))
18132 /* We don't build decls for an instantiation of a
18133 variadic capture proxy, we instantiate the elements
18135 gcc_assert (DECL_HAS_VALUE_EXPR_P (t
));
18136 return RECUR (DECL_VALUE_EXPR (t
));
18142 tree r
= tsubst_copy (t
, args
, complain
, in_decl
);
18143 /* ??? We're doing a subset of finish_id_expression here. */
18145 && !processing_template_decl
18146 && !cp_unevaluated_operand
18147 && (TREE_STATIC (r
) || DECL_EXTERNAL (r
))
18148 && CP_DECL_THREAD_LOCAL_P (r
))
18150 if (tree wrap
= get_tls_wrapper_fn (r
))
18151 /* Replace an evaluated use of the thread_local variable with
18152 a call to its wrapper. */
18153 r
= build_cxx_call (wrap
, 0, NULL
, tf_warning_or_error
);
18155 else if (outer_automatic_var_p (r
))
18156 r
= process_outer_var_ref (r
, complain
);
18158 if (TREE_CODE (TREE_TYPE (t
)) != REFERENCE_TYPE
)
18159 /* If the original type was a reference, we'll be wrapped in
18160 the appropriate INDIRECT_REF. */
18161 r
= convert_from_reference (r
);
18167 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18168 tree type
= tsubst (TREE_TYPE (t
), args
, complain
, in_decl
);
18169 RETURN (build_x_va_arg (EXPR_LOCATION (t
), op0
, type
));
18172 case OFFSETOF_EXPR
:
18175 = tsubst_copy_and_build (TREE_OPERAND (t
, 1), args
, complain
,
18176 in_decl
, /*function_p=*/false,
18177 /*integral_constant_expression_p=*/false);
18178 RETURN (finish_offsetof (object_ptr
,
18179 RECUR (TREE_OPERAND (t
, 0)),
18180 EXPR_LOCATION (t
)));
18183 case ADDRESSOF_EXPR
:
18184 RETURN (cp_build_addressof (EXPR_LOCATION (t
),
18185 RECUR (TREE_OPERAND (t
, 0)), complain
));
18189 tree type1
= tsubst (TRAIT_EXPR_TYPE1 (t
), args
,
18190 complain
, in_decl
);
18192 tree type2
= TRAIT_EXPR_TYPE2 (t
);
18193 if (type2
&& TREE_CODE (type2
) == TREE_LIST
)
18194 type2
= RECUR (type2
);
18196 type2
= tsubst (type2
, args
, complain
, in_decl
);
18198 RETURN (finish_trait_expr (TRAIT_EXPR_KIND (t
), type1
, type2
));
18203 tree old_stmt_expr
= cur_stmt_expr
;
18204 tree stmt_expr
= begin_stmt_expr ();
18206 cur_stmt_expr
= stmt_expr
;
18207 tsubst_expr (STMT_EXPR_STMT (t
), args
, complain
, in_decl
,
18208 integral_constant_expression_p
);
18209 stmt_expr
= finish_stmt_expr (stmt_expr
, false);
18210 cur_stmt_expr
= old_stmt_expr
;
18212 /* If the resulting list of expression statement is empty,
18213 fold it further into void_node. */
18214 if (empty_expr_stmt_p (stmt_expr
))
18215 stmt_expr
= void_node
;
18217 RETURN (stmt_expr
);
18222 tree r
= tsubst_lambda_expr (t
, args
, complain
, in_decl
);
18224 RETURN (build_lambda_object (r
));
18228 /* We can get here for a constant initializer of non-dependent type.
18229 FIXME stop folding in cp_parser_initializer_clause. */
18231 tree r
= get_target_expr_sfinae (RECUR (TARGET_EXPR_INITIAL (t
)),
18236 case TRANSACTION_EXPR
:
18237 RETURN (tsubst_expr(t
, args
, complain
, in_decl
,
18238 integral_constant_expression_p
));
18241 RETURN (finish_parenthesized_expr (RECUR (TREE_OPERAND (t
, 0))));
18243 case VEC_PERM_EXPR
:
18245 tree op0
= RECUR (TREE_OPERAND (t
, 0));
18246 tree op1
= RECUR (TREE_OPERAND (t
, 1));
18247 tree op2
= RECUR (TREE_OPERAND (t
, 2));
18248 RETURN (build_x_vec_perm_expr (input_location
, op0
, op1
, op2
,
18252 case REQUIRES_EXPR
:
18253 RETURN (tsubst_requires_expr (t
, args
, complain
, in_decl
));
18256 /* Handle Objective-C++ constructs, if appropriate. */
18259 = objcp_tsubst_copy_and_build (t
, args
, complain
,
18260 in_decl
, /*function_p=*/false);
18264 RETURN (tsubst_copy (t
, args
, complain
, in_decl
));
18270 input_location
= loc
;
18274 /* Verify that the instantiated ARGS are valid. For type arguments,
18275 make sure that the type's linkage is ok. For non-type arguments,
18276 make sure they are constants if they are integral or enumerations.
18277 Emit an error under control of COMPLAIN, and return TRUE on error. */
18280 check_instantiated_arg (tree tmpl
, tree t
, tsubst_flags_t complain
)
18282 if (dependent_template_arg_p (t
))
18284 if (ARGUMENT_PACK_P (t
))
18286 tree vec
= ARGUMENT_PACK_ARGS (t
);
18287 int len
= TREE_VEC_LENGTH (vec
);
18288 bool result
= false;
18291 for (i
= 0; i
< len
; ++i
)
18292 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (vec
, i
), complain
))
18296 else if (TYPE_P (t
))
18298 /* [basic.link]: A name with no linkage (notably, the name
18299 of a class or enumeration declared in a local scope)
18300 shall not be used to declare an entity with linkage.
18301 This implies that names with no linkage cannot be used as
18304 DR 757 relaxes this restriction for C++0x. */
18305 tree nt
= (cxx_dialect
> cxx98
? NULL_TREE
18306 : no_linkage_check (t
, /*relaxed_p=*/false));
18310 /* DR 488 makes use of a type with no linkage cause
18311 type deduction to fail. */
18312 if (complain
& tf_error
)
18314 if (TYPE_UNNAMED_P (nt
))
18315 error ("%qT is/uses unnamed type", t
);
18317 error ("template argument for %qD uses local type %qT",
18322 /* In order to avoid all sorts of complications, we do not
18323 allow variably-modified types as template arguments. */
18324 else if (variably_modified_type_p (t
, NULL_TREE
))
18326 if (complain
& tf_error
)
18327 error ("%qT is a variably modified type", t
);
18331 /* Class template and alias template arguments should be OK. */
18332 else if (DECL_TYPE_TEMPLATE_P (t
))
18334 /* A non-type argument of integral or enumerated type must be a
18336 else if (TREE_TYPE (t
)
18337 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (t
))
18338 && !REFERENCE_REF_P (t
)
18339 && !TREE_CONSTANT (t
))
18341 if (complain
& tf_error
)
18342 error ("integral expression %qE is not constant", t
);
18349 check_instantiated_args (tree tmpl
, tree args
, tsubst_flags_t complain
)
18351 int ix
, len
= DECL_NTPARMS (tmpl
);
18352 bool result
= false;
18354 for (ix
= 0; ix
!= len
; ix
++)
18356 if (check_instantiated_arg (tmpl
, TREE_VEC_ELT (args
, ix
), complain
))
18359 if (result
&& (complain
& tf_error
))
18360 error (" trying to instantiate %qD", tmpl
);
18364 /* We're out of SFINAE context now, so generate diagnostics for the access
18365 errors we saw earlier when instantiating D from TMPL and ARGS. */
18368 recheck_decl_substitution (tree d
, tree tmpl
, tree args
)
18370 tree pattern
= DECL_TEMPLATE_RESULT (tmpl
);
18371 tree type
= TREE_TYPE (pattern
);
18372 location_t loc
= input_location
;
18374 push_access_scope (d
);
18375 push_deferring_access_checks (dk_no_deferred
);
18376 input_location
= DECL_SOURCE_LOCATION (pattern
);
18377 tsubst (type
, args
, tf_warning_or_error
, d
);
18378 input_location
= loc
;
18379 pop_deferring_access_checks ();
18380 pop_access_scope (d
);
18383 /* Instantiate the indicated variable, function, or alias template TMPL with
18384 the template arguments in TARG_PTR. */
18387 instantiate_template_1 (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
18389 tree targ_ptr
= orig_args
;
18393 bool access_ok
= true;
18395 if (tmpl
== error_mark_node
)
18396 return error_mark_node
;
18398 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
18400 /* If this function is a clone, handle it specially. */
18401 if (DECL_CLONED_FUNCTION_P (tmpl
))
18406 /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
18407 DECL_CLONED_FUNCTION. */
18408 spec
= instantiate_template (DECL_ABSTRACT_ORIGIN (tmpl
),
18409 targ_ptr
, complain
);
18410 if (spec
== error_mark_node
)
18411 return error_mark_node
;
18413 /* Look for the clone. */
18414 FOR_EACH_CLONE (clone
, spec
)
18415 if (DECL_NAME (clone
) == DECL_NAME (tmpl
))
18417 /* We should always have found the clone by now. */
18418 gcc_unreachable ();
18422 if (targ_ptr
== error_mark_node
)
18423 return error_mark_node
;
18425 /* Check to see if we already have this specialization. */
18426 gen_tmpl
= most_general_template (tmpl
);
18427 if (TMPL_ARGS_DEPTH (targ_ptr
)
18428 < TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
)))
18429 /* targ_ptr only has the innermost template args, so add the outer ones
18430 from tmpl, which could be either a partial instantiation or gen_tmpl (in
18431 the case of a non-dependent call within a template definition). */
18432 targ_ptr
= (add_outermost_template_args
18433 (DECL_TI_ARGS (DECL_TEMPLATE_RESULT (tmpl
)),
18436 /* It would be nice to avoid hashing here and then again in tsubst_decl,
18437 but it doesn't seem to be on the hot path. */
18438 spec
= retrieve_specialization (gen_tmpl
, targ_ptr
, 0);
18440 gcc_assert (tmpl
== gen_tmpl
18441 || ((fndecl
= retrieve_specialization (tmpl
, orig_args
, 0))
18443 || fndecl
== NULL_TREE
);
18445 if (spec
!= NULL_TREE
)
18447 if (FNDECL_HAS_ACCESS_ERRORS (spec
))
18449 if (complain
& tf_error
)
18450 recheck_decl_substitution (spec
, gen_tmpl
, targ_ptr
);
18451 return error_mark_node
;
18456 if (check_instantiated_args (gen_tmpl
, INNERMOST_TEMPLATE_ARGS (targ_ptr
),
18458 return error_mark_node
;
18460 /* We are building a FUNCTION_DECL, during which the access of its
18461 parameters and return types have to be checked. However this
18462 FUNCTION_DECL which is the desired context for access checking
18463 is not built yet. We solve this chicken-and-egg problem by
18464 deferring all checks until we have the FUNCTION_DECL. */
18465 push_deferring_access_checks (dk_deferred
);
18467 /* Instantiation of the function happens in the context of the function
18468 template, not the context of the overload resolution we're doing. */
18469 push_to_top_level ();
18470 /* If there are dependent arguments, e.g. because we're doing partial
18471 ordering, make sure processing_template_decl stays set. */
18472 if (uses_template_parms (targ_ptr
))
18473 ++processing_template_decl
;
18474 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
18476 tree ctx
= tsubst_aggr_type (DECL_CONTEXT (gen_tmpl
), targ_ptr
,
18477 complain
, gen_tmpl
, true);
18478 push_nested_class (ctx
);
18481 tree pattern
= DECL_TEMPLATE_RESULT (gen_tmpl
);
18483 fndecl
= NULL_TREE
;
18484 if (VAR_P (pattern
))
18486 /* We need to determine if we're using a partial or explicit
18487 specialization now, because the type of the variable could be
18489 tree tid
= lookup_template_variable (gen_tmpl
, targ_ptr
);
18490 tree elt
= most_specialized_partial_spec (tid
, complain
);
18491 if (elt
== error_mark_node
)
18492 pattern
= error_mark_node
;
18495 tree partial_tmpl
= TREE_VALUE (elt
);
18496 tree partial_args
= TREE_PURPOSE (elt
);
18497 tree partial_pat
= DECL_TEMPLATE_RESULT (partial_tmpl
);
18498 fndecl
= tsubst (partial_pat
, partial_args
, complain
, gen_tmpl
);
18502 /* Substitute template parameters to obtain the specialization. */
18503 if (fndecl
== NULL_TREE
)
18504 fndecl
= tsubst (pattern
, targ_ptr
, complain
, gen_tmpl
);
18505 if (DECL_CLASS_SCOPE_P (gen_tmpl
))
18506 pop_nested_class ();
18507 pop_from_top_level ();
18509 if (fndecl
== error_mark_node
)
18511 pop_deferring_access_checks ();
18512 return error_mark_node
;
18515 /* The DECL_TI_TEMPLATE should always be the immediate parent
18516 template, not the most general template. */
18517 DECL_TI_TEMPLATE (fndecl
) = tmpl
;
18518 DECL_TI_ARGS (fndecl
) = targ_ptr
;
18520 /* Now we know the specialization, compute access previously
18521 deferred. Do no access control for inheriting constructors,
18522 as we already checked access for the inherited constructor. */
18523 if (!(flag_new_inheriting_ctors
18524 && DECL_INHERITED_CTOR (fndecl
)))
18526 push_access_scope (fndecl
);
18527 if (!perform_deferred_access_checks (complain
))
18529 pop_access_scope (fndecl
);
18531 pop_deferring_access_checks ();
18533 /* If we've just instantiated the main entry point for a function,
18534 instantiate all the alternate entry points as well. We do this
18535 by cloning the instantiation of the main entry point, not by
18536 instantiating the template clones. */
18537 if (DECL_CHAIN (gen_tmpl
) && DECL_CLONED_FUNCTION_P (DECL_CHAIN (gen_tmpl
)))
18538 clone_function_decl (fndecl
, /*update_methods=*/false);
18542 if (!(complain
& tf_error
))
18544 /* Remember to reinstantiate when we're out of SFINAE so the user
18545 can see the errors. */
18546 FNDECL_HAS_ACCESS_ERRORS (fndecl
) = true;
18548 return error_mark_node
;
18553 /* Wrapper for instantiate_template_1. */
18556 instantiate_template (tree tmpl
, tree orig_args
, tsubst_flags_t complain
)
18559 timevar_push (TV_TEMPLATE_INST
);
18560 ret
= instantiate_template_1 (tmpl
, orig_args
, complain
);
18561 timevar_pop (TV_TEMPLATE_INST
);
18565 /* Instantiate the alias template TMPL with ARGS. Also push a template
18566 instantiation level, which instantiate_template doesn't do because
18567 functions and variables have sufficient context established by the
18571 instantiate_alias_template (tree tmpl
, tree args
, tsubst_flags_t complain
)
18573 struct pending_template
*old_last_pend
= last_pending_template
;
18574 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
18575 if (tmpl
== error_mark_node
|| args
== error_mark_node
)
18576 return error_mark_node
;
18577 tree tinst
= build_tree_list (tmpl
, args
);
18578 if (!push_tinst_level (tinst
))
18581 return error_mark_node
;
18585 coerce_innermost_template_parms (DECL_TEMPLATE_PARMS (tmpl
),
18586 args
, tmpl
, complain
,
18587 /*require_all_args=*/true,
18588 /*use_default_args=*/true);
18590 tree r
= instantiate_template (tmpl
, args
, complain
);
18591 pop_tinst_level ();
18592 /* We can't free this if a pending_template entry or last_error_tinst_level
18593 is pointing at it. */
18594 if (last_pending_template
== old_last_pend
18595 && last_error_tinst_level
== old_error_tinst
)
18601 /* PARM is a template parameter pack for FN. Returns true iff
18602 PARM is used in a deducible way in the argument list of FN. */
18605 pack_deducible_p (tree parm
, tree fn
)
18607 tree t
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
18608 for (; t
; t
= TREE_CHAIN (t
))
18610 tree type
= TREE_VALUE (t
);
18612 if (!PACK_EXPANSION_P (type
))
18614 for (packs
= PACK_EXPANSION_PARAMETER_PACKS (type
);
18615 packs
; packs
= TREE_CHAIN (packs
))
18616 if (template_args_equal (TREE_VALUE (packs
), parm
))
18618 /* The template parameter pack is used in a function parameter
18619 pack. If this is the end of the parameter list, the
18620 template parameter pack is deducible. */
18621 if (TREE_CHAIN (t
) == void_list_node
)
18624 /* Otherwise, not. Well, it could be deduced from
18625 a non-pack parameter, but doing so would end up with
18626 a deduction mismatch, so don't bother. */
18630 /* The template parameter pack isn't used in any function parameter
18631 packs, but it might be used deeper, e.g. tuple<Args...>. */
18635 /* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
18636 NARGS elements of the arguments that are being used when calling
18637 it. TARGS is a vector into which the deduced template arguments
18640 Returns either a FUNCTION_DECL for the matching specialization of FN or
18641 NULL_TREE if no suitable specialization can be found. If EXPLAIN_P is
18642 true, diagnostics will be printed to explain why it failed.
18644 If FN is a conversion operator, or we are trying to produce a specific
18645 specialization, RETURN_TYPE is the return type desired.
18647 The EXPLICIT_TARGS are explicit template arguments provided via a
18650 The parameter STRICT is one of:
18653 We are deducing arguments for a function call, as in
18654 [temp.deduct.call]. If RETURN_TYPE is non-null, we are
18655 deducing arguments for a call to the result of a conversion
18656 function template, as in [over.call.object].
18659 We are deducing arguments for a conversion function, as in
18660 [temp.deduct.conv].
18663 We are deducing arguments when doing an explicit instantiation
18664 as in [temp.explicit], when determining an explicit specialization
18665 as in [temp.expl.spec], or when taking the address of a function
18666 template, as in [temp.deduct.funcaddr]. */
18669 fn_type_unification (tree fn
,
18670 tree explicit_targs
,
18673 unsigned int nargs
,
18675 unification_kind_t strict
,
18682 tree decl
= NULL_TREE
;
18683 tsubst_flags_t complain
= (explain_p
? tf_warning_or_error
: tf_none
);
18685 static int deduction_depth
;
18686 struct pending_template
*old_last_pend
= last_pending_template
;
18687 struct tinst_level
*old_error_tinst
= last_error_tinst_level
;
18690 if (flag_new_inheriting_ctors
)
18691 fn
= strip_inheriting_ctors (fn
);
18693 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (fn
);
18695 tree r
= error_mark_node
;
18697 tree full_targs
= targs
;
18698 if (TMPL_ARGS_DEPTH (targs
)
18699 < TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (fn
)))
18700 full_targs
= (add_outermost_template_args
18701 (DECL_TI_ARGS (DECL_TEMPLATE_RESULT (fn
)),
18705 complain
|= tf_decltype
;
18707 /* In C++0x, it's possible to have a function template whose type depends
18708 on itself recursively. This is most obvious with decltype, but can also
18709 occur with enumeration scope (c++/48969). So we need to catch infinite
18710 recursion and reject the substitution at deduction time; this function
18711 will return error_mark_node for any repeated substitution.
18713 This also catches excessive recursion such as when f<N> depends on
18714 f<N-1> across all integers, and returns error_mark_node for all the
18715 substitutions back up to the initial one.
18717 This is, of course, not reentrant. */
18718 if (excessive_deduction_depth
)
18719 return error_mark_node
;
18720 tinst
= build_tree_list (fn
, NULL_TREE
);
18723 gcc_assert (TREE_CODE (fn
) == TEMPLATE_DECL
);
18725 fntype
= TREE_TYPE (fn
);
18726 if (explicit_targs
)
18730 The specified template arguments must match the template
18731 parameters in kind (i.e., type, nontype, template), and there
18732 must not be more arguments than there are parameters;
18733 otherwise type deduction fails.
18735 Nontype arguments must match the types of the corresponding
18736 nontype template parameters, or must be convertible to the
18737 types of the corresponding nontype parameters as specified in
18738 _temp.arg.nontype_, otherwise type deduction fails.
18740 All references in the function type of the function template
18741 to the corresponding template parameters are replaced by the
18742 specified template argument values. If a substitution in a
18743 template parameter or in the function type of the function
18744 template results in an invalid type, type deduction fails. */
18745 int i
, len
= TREE_VEC_LENGTH (tparms
);
18746 location_t loc
= input_location
;
18747 bool incomplete
= false;
18749 if (explicit_targs
== error_mark_node
)
18752 if (TMPL_ARGS_DEPTH (explicit_targs
)
18753 < TMPL_ARGS_DEPTH (full_targs
))
18754 explicit_targs
= add_outermost_template_args (full_targs
,
18757 /* Adjust any explicit template arguments before entering the
18758 substitution context. */
18760 = (coerce_template_parms (tparms
, explicit_targs
, NULL_TREE
,
18762 /*require_all_args=*/false,
18763 /*use_default_args=*/false));
18764 if (explicit_targs
== error_mark_node
)
18767 /* Substitute the explicit args into the function type. This is
18768 necessary so that, for instance, explicitly declared function
18769 arguments can match null pointed constants. If we were given
18770 an incomplete set of explicit args, we must not do semantic
18771 processing during substitution as we could create partial
18773 for (i
= 0; i
< len
; i
++)
18775 tree parm
= TREE_VALUE (TREE_VEC_ELT (tparms
, i
));
18776 bool parameter_pack
= false;
18777 tree targ
= TREE_VEC_ELT (explicit_targs
, i
);
18779 /* Dig out the actual parm. */
18780 if (TREE_CODE (parm
) == TYPE_DECL
18781 || TREE_CODE (parm
) == TEMPLATE_DECL
)
18783 parm
= TREE_TYPE (parm
);
18784 parameter_pack
= TEMPLATE_TYPE_PARAMETER_PACK (parm
);
18786 else if (TREE_CODE (parm
) == PARM_DECL
)
18788 parm
= DECL_INITIAL (parm
);
18789 parameter_pack
= TEMPLATE_PARM_PARAMETER_PACK (parm
);
18792 if (!parameter_pack
&& targ
== NULL_TREE
)
18793 /* No explicit argument for this template parameter. */
18796 if (parameter_pack
&& pack_deducible_p (parm
, fn
))
18798 /* Mark the argument pack as "incomplete". We could
18799 still deduce more arguments during unification.
18800 We remove this mark in type_unification_real. */
18803 ARGUMENT_PACK_INCOMPLETE_P(targ
) = 1;
18804 ARGUMENT_PACK_EXPLICIT_ARGS (targ
)
18805 = ARGUMENT_PACK_ARGS (targ
);
18808 /* We have some incomplete argument packs. */
18813 TREE_VALUE (tinst
) = explicit_targs
;
18814 if (!push_tinst_level (tinst
))
18816 excessive_deduction_depth
= true;
18819 processing_template_decl
+= incomplete
;
18820 input_location
= DECL_SOURCE_LOCATION (fn
);
18821 /* Ignore any access checks; we'll see them again in
18822 instantiate_template and they might have the wrong
18823 access path at this point. */
18824 push_deferring_access_checks (dk_deferred
);
18825 fntype
= tsubst (TREE_TYPE (fn
), explicit_targs
,
18826 complain
| tf_partial
| tf_fndecl_type
, NULL_TREE
);
18827 pop_deferring_access_checks ();
18828 input_location
= loc
;
18829 processing_template_decl
-= incomplete
;
18830 pop_tinst_level ();
18832 if (fntype
== error_mark_node
)
18835 /* Place the explicitly specified arguments in TARGS. */
18836 explicit_targs
= INNERMOST_TEMPLATE_ARGS (explicit_targs
);
18837 for (i
= NUM_TMPL_ARGS (explicit_targs
); i
--;)
18838 TREE_VEC_ELT (targs
, i
) = TREE_VEC_ELT (explicit_targs
, i
);
18841 /* Never do unification on the 'this' parameter. */
18842 parms
= skip_artificial_parms_for (fn
, TYPE_ARG_TYPES (fntype
));
18844 if (return_type
&& strict
== DEDUCE_CALL
)
18846 /* We're deducing for a call to the result of a template conversion
18847 function. The parms we really want are in return_type. */
18848 if (POINTER_TYPE_P (return_type
))
18849 return_type
= TREE_TYPE (return_type
);
18850 parms
= TYPE_ARG_TYPES (return_type
);
18852 else if (return_type
)
18856 parms
= tree_cons (NULL_TREE
, TREE_TYPE (fntype
), parms
);
18857 new_args
= XALLOCAVEC (tree
, nargs
+ 1);
18858 new_args
[0] = return_type
;
18859 memcpy (new_args
+ 1, args
, nargs
* sizeof (tree
));
18864 /* We allow incomplete unification without an error message here
18865 because the standard doesn't seem to explicitly prohibit it. Our
18866 callers must be ready to deal with unification failures in any
18869 TREE_VALUE (tinst
) = targs
;
18870 /* If we aren't explaining yet, push tinst context so we can see where
18871 any errors (e.g. from class instantiations triggered by instantiation
18872 of default template arguments) come from. If we are explaining, this
18873 context is redundant. */
18874 if (!explain_p
&& !push_tinst_level (tinst
))
18876 excessive_deduction_depth
= true;
18880 /* type_unification_real will pass back any access checks from default
18881 template argument substitution. */
18882 vec
<deferred_access_check
, va_gc
> *checks
;
18885 ok
= !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
18886 full_targs
, parms
, args
, nargs
, /*subr=*/0,
18887 strict
, flags
, &checks
, explain_p
);
18889 pop_tinst_level ();
18893 /* Now that we have bindings for all of the template arguments,
18894 ensure that the arguments deduced for the template template
18895 parameters have compatible template parameter lists. We cannot
18896 check this property before we have deduced all template
18897 arguments, because the template parameter types of a template
18898 template parameter might depend on prior template parameters
18899 deduced after the template template parameter. The following
18900 ill-formed example illustrates this issue:
18902 template<typename T, template<T> class C> void f(C<5>, T);
18904 template<int N> struct X {};
18907 f(X<5>(), 5l); // error: template argument deduction fails
18910 The template parameter list of 'C' depends on the template type
18911 parameter 'T', but 'C' is deduced to 'X' before 'T' is deduced to
18912 'long'. Thus, we can't check that 'C' cannot bind to 'X' at the
18913 time that we deduce 'C'. */
18914 if (!template_template_parm_bindings_ok_p
18915 (DECL_INNERMOST_TEMPLATE_PARMS (fn
), targs
))
18917 unify_inconsistent_template_template_parameters (explain_p
);
18921 /* All is well so far. Now, check:
18925 When all template arguments have been deduced, all uses of
18926 template parameters in nondeduced contexts are replaced with
18927 the corresponding deduced argument values. If the
18928 substitution results in an invalid type, as described above,
18929 type deduction fails. */
18930 TREE_VALUE (tinst
) = targs
;
18931 if (!push_tinst_level (tinst
))
18933 excessive_deduction_depth
= true;
18937 /* Also collect access checks from the instantiation. */
18938 reopen_deferring_access_checks (checks
);
18940 decl
= instantiate_template (fn
, targs
, complain
);
18942 checks
= get_deferred_access_checks ();
18943 pop_deferring_access_checks ();
18945 pop_tinst_level ();
18947 if (decl
== error_mark_node
)
18950 /* Now perform any access checks encountered during substitution. */
18951 push_access_scope (decl
);
18952 ok
= perform_access_checks (checks
, complain
);
18953 pop_access_scope (decl
);
18957 /* If we're looking for an exact match, check that what we got
18958 is indeed an exact match. It might not be if some template
18959 parameters are used in non-deduced contexts. But don't check
18960 for an exact match if we have dependent template arguments;
18961 in that case we're doing partial ordering, and we already know
18962 that we have two candidates that will provide the actual type. */
18963 if (strict
== DEDUCE_EXACT
&& !any_dependent_template_arguments_p (targs
))
18965 tree substed
= TREE_TYPE (decl
);
18969 = skip_artificial_parms_for (decl
, TYPE_ARG_TYPES (substed
));
18971 sarg
= tree_cons (NULL_TREE
, TREE_TYPE (substed
), sarg
);
18972 for (i
= 0; i
< nargs
&& sarg
; ++i
, sarg
= TREE_CHAIN (sarg
))
18973 if (!same_type_p (args
[i
], TREE_VALUE (sarg
)))
18975 unify_type_mismatch (explain_p
, args
[i
],
18976 TREE_VALUE (sarg
));
18981 /* After doing deduction with the inherited constructor, actually return an
18982 instantiation of the inheriting constructor. */
18984 decl
= instantiate_template (orig_fn
, targs
, complain
);
18990 if (excessive_deduction_depth
)
18992 if (deduction_depth
== 0)
18993 /* Reset once we're all the way out. */
18994 excessive_deduction_depth
= false;
18997 /* We can't free this if a pending_template entry or last_error_tinst_level
18998 is pointing at it. */
18999 if (last_pending_template
== old_last_pend
19000 && last_error_tinst_level
== old_error_tinst
)
19006 /* Adjust types before performing type deduction, as described in
19007 [temp.deduct.call] and [temp.deduct.conv]. The rules in these two
19008 sections are symmetric. PARM is the type of a function parameter
19009 or the return type of the conversion function. ARG is the type of
19010 the argument passed to the call, or the type of the value
19011 initialized with the result of the conversion function.
19012 ARG_EXPR is the original argument expression, which may be null. */
19015 maybe_adjust_types_for_deduction (unification_kind_t strict
,
19028 /* Swap PARM and ARG throughout the remainder of this
19029 function; the handling is precisely symmetric since PARM
19030 will initialize ARG rather than vice versa. */
19031 std::swap (parm
, arg
);
19035 /* Core issue #873: Do the DR606 thing (see below) for these cases,
19036 too, but here handle it by stripping the reference from PARM
19037 rather than by adding it to ARG. */
19038 if (TREE_CODE (*parm
) == REFERENCE_TYPE
19039 && TYPE_REF_IS_RVALUE (*parm
)
19040 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
19041 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
19042 && TREE_CODE (*arg
) == REFERENCE_TYPE
19043 && !TYPE_REF_IS_RVALUE (*arg
))
19044 *parm
= TREE_TYPE (*parm
);
19045 /* Nothing else to do in this case. */
19049 gcc_unreachable ();
19052 if (TREE_CODE (*parm
) != REFERENCE_TYPE
)
19054 /* [temp.deduct.call]
19056 If P is not a reference type:
19058 --If A is an array type, the pointer type produced by the
19059 array-to-pointer standard conversion (_conv.array_) is
19060 used in place of A for type deduction; otherwise,
19062 --If A is a function type, the pointer type produced by
19063 the function-to-pointer standard conversion
19064 (_conv.func_) is used in place of A for type deduction;
19067 --If A is a cv-qualified type, the top level
19068 cv-qualifiers of A's type are ignored for type
19070 if (TREE_CODE (*arg
) == ARRAY_TYPE
)
19071 *arg
= build_pointer_type (TREE_TYPE (*arg
));
19072 else if (TREE_CODE (*arg
) == FUNCTION_TYPE
)
19073 *arg
= build_pointer_type (*arg
);
19075 *arg
= TYPE_MAIN_VARIANT (*arg
);
19078 /* [14.8.2.1/3 temp.deduct.call], "A forwarding reference is an rvalue
19079 reference to a cv-unqualified template parameter that does not represent a
19080 template parameter of a class template (during class template argument
19081 deduction (13.3.1.8)). If P is a forwarding reference and the argument is
19082 an lvalue, the type "lvalue reference to A" is used in place of A for type
19084 if (TREE_CODE (*parm
) == REFERENCE_TYPE
19085 && TYPE_REF_IS_RVALUE (*parm
)
19086 && TREE_CODE (TREE_TYPE (*parm
)) == TEMPLATE_TYPE_PARM
19087 && !TEMPLATE_TYPE_PARM_FOR_CLASS (TREE_TYPE (*parm
))
19088 && cp_type_quals (TREE_TYPE (*parm
)) == TYPE_UNQUALIFIED
19089 && (arg_expr
? lvalue_p (arg_expr
)
19090 /* try_one_overload doesn't provide an arg_expr, but
19091 functions are always lvalues. */
19092 : TREE_CODE (*arg
) == FUNCTION_TYPE
))
19093 *arg
= build_reference_type (*arg
);
19095 /* [temp.deduct.call]
19097 If P is a cv-qualified type, the top level cv-qualifiers
19098 of P's type are ignored for type deduction. If P is a
19099 reference type, the type referred to by P is used for
19101 *parm
= TYPE_MAIN_VARIANT (*parm
);
19102 if (TREE_CODE (*parm
) == REFERENCE_TYPE
)
19104 *parm
= TREE_TYPE (*parm
);
19105 result
|= UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
19108 /* DR 322. For conversion deduction, remove a reference type on parm
19109 too (which has been swapped into ARG). */
19110 if (strict
== DEDUCE_CONV
&& TREE_CODE (*arg
) == REFERENCE_TYPE
)
19111 *arg
= TREE_TYPE (*arg
);
19116 /* Subroutine of unify_one_argument. PARM is a function parameter of a
19117 template which does contain any deducible template parameters; check if
19118 ARG is a suitable match for it. STRICT, FLAGS and EXPLAIN_P are as in
19119 unify_one_argument. */
19122 check_non_deducible_conversion (tree parm
, tree arg
, int strict
,
19123 int flags
, bool explain_p
)
19128 type
= TREE_TYPE (arg
);
19132 if (same_type_p (parm
, type
))
19133 return unify_success (explain_p
);
19135 if (strict
== DEDUCE_CONV
)
19137 if (can_convert_arg (type
, parm
, NULL_TREE
, flags
,
19138 explain_p
? tf_warning_or_error
: tf_none
))
19139 return unify_success (explain_p
);
19141 else if (strict
!= DEDUCE_EXACT
)
19143 if (can_convert_arg (parm
, type
,
19144 TYPE_P (arg
) ? NULL_TREE
: arg
,
19145 flags
, explain_p
? tf_warning_or_error
: tf_none
))
19146 return unify_success (explain_p
);
19149 if (strict
== DEDUCE_EXACT
)
19150 return unify_type_mismatch (explain_p
, parm
, arg
);
19152 return unify_arg_conversion (explain_p
, parm
, type
, arg
);
19155 static bool uses_deducible_template_parms (tree type
);
19157 /* Returns true iff the expression EXPR is one from which a template
19158 argument can be deduced. In other words, if it's an undecorated
19159 use of a template non-type parameter. */
19162 deducible_expression (tree expr
)
19164 /* Strip implicit conversions. */
19165 while (CONVERT_EXPR_P (expr
))
19166 expr
= TREE_OPERAND (expr
, 0);
19167 return (TREE_CODE (expr
) == TEMPLATE_PARM_INDEX
);
19170 /* Returns true iff the array domain DOMAIN uses a template parameter in a
19171 deducible way; that is, if it has a max value of <PARM> - 1. */
19174 deducible_array_bound (tree domain
)
19176 if (domain
== NULL_TREE
)
19179 tree max
= TYPE_MAX_VALUE (domain
);
19180 if (TREE_CODE (max
) != MINUS_EXPR
)
19183 return deducible_expression (TREE_OPERAND (max
, 0));
19186 /* Returns true iff the template arguments ARGS use a template parameter
19187 in a deducible way. */
19190 deducible_template_args (tree args
)
19192 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
19195 tree elt
= TREE_VEC_ELT (args
, i
);
19196 if (ARGUMENT_PACK_P (elt
))
19197 deducible
= deducible_template_args (ARGUMENT_PACK_ARGS (elt
));
19200 if (PACK_EXPANSION_P (elt
))
19201 elt
= PACK_EXPANSION_PATTERN (elt
);
19202 if (TREE_CODE (elt
) == TEMPLATE_TEMPLATE_PARM
)
19204 else if (TYPE_P (elt
))
19205 deducible
= uses_deducible_template_parms (elt
);
19207 deducible
= deducible_expression (elt
);
19215 /* Returns true iff TYPE contains any deducible references to template
19216 parameters, as per 14.8.2.5. */
19219 uses_deducible_template_parms (tree type
)
19221 if (PACK_EXPANSION_P (type
))
19222 type
= PACK_EXPANSION_PATTERN (type
);
19229 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
19230 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
19236 if (POINTER_TYPE_P (type
))
19237 return uses_deducible_template_parms (TREE_TYPE (type
));
19239 /* T[integer-constant ]
19241 if (TREE_CODE (type
) == ARRAY_TYPE
)
19242 return (uses_deducible_template_parms (TREE_TYPE (type
))
19243 || deducible_array_bound (TYPE_DOMAIN (type
)));
19255 if (TYPE_PTRMEM_P (type
))
19256 return (uses_deducible_template_parms (TYPE_PTRMEM_CLASS_TYPE (type
))
19257 || (uses_deducible_template_parms
19258 (TYPE_PTRMEM_POINTED_TO_TYPE (type
))));
19260 /* template-name <T> (where template-name refers to a class template)
19261 template-name <i> (where template-name refers to a class template) */
19262 if (CLASS_TYPE_P (type
)
19263 && CLASSTYPE_TEMPLATE_INFO (type
)
19264 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type
)))
19265 return deducible_template_args (INNERMOST_TEMPLATE_ARGS
19266 (CLASSTYPE_TI_ARGS (type
)));
19271 if (TREE_CODE (type
) == FUNCTION_TYPE
19272 || TREE_CODE (type
) == METHOD_TYPE
)
19274 if (uses_deducible_template_parms (TREE_TYPE (type
)))
19276 tree parm
= TYPE_ARG_TYPES (type
);
19277 if (TREE_CODE (type
) == METHOD_TYPE
)
19278 parm
= TREE_CHAIN (parm
);
19279 for (; parm
; parm
= TREE_CHAIN (parm
))
19280 if (uses_deducible_template_parms (TREE_VALUE (parm
)))
19287 /* Subroutine of type_unification_real and unify_pack_expansion to
19288 handle unification of a single P/A pair. Parameters are as
19289 for those functions. */
19292 unify_one_argument (tree tparms
, tree targs
, tree parm
, tree arg
,
19293 int subr
, unification_kind_t strict
,
19296 tree arg_expr
= NULL_TREE
;
19299 if (arg
== error_mark_node
|| parm
== error_mark_node
)
19300 return unify_invalid (explain_p
);
19301 if (arg
== unknown_type_node
)
19302 /* We can't deduce anything from this, but we might get all the
19303 template args from other function args. */
19304 return unify_success (explain_p
);
19306 /* Implicit conversions (Clause 4) will be performed on a function
19307 argument to convert it to the type of the corresponding function
19308 parameter if the parameter type contains no template-parameters that
19309 participate in template argument deduction. */
19310 if (strict
!= DEDUCE_EXACT
19311 && TYPE_P (parm
) && !uses_deducible_template_parms (parm
))
19312 /* For function parameters with no deducible template parameters,
19313 just return. We'll check non-dependent conversions later. */
19314 return unify_success (explain_p
);
19319 arg_strict
= (UNIFY_ALLOW_OUTER_LEVEL
19320 | UNIFY_ALLOW_MORE_CV_QUAL
19321 | UNIFY_ALLOW_DERIVED
);
19325 arg_strict
= UNIFY_ALLOW_LESS_CV_QUAL
;
19329 arg_strict
= UNIFY_ALLOW_NONE
;
19333 gcc_unreachable ();
19336 /* We only do these transformations if this is the top-level
19337 parameter_type_list in a call or declaration matching; in other
19338 situations (nested function declarators, template argument lists) we
19339 won't be comparing a type to an expression, and we don't do any type
19345 gcc_assert (TREE_TYPE (arg
) != NULL_TREE
);
19346 if (type_unknown_p (arg
))
19348 /* [temp.deduct.type] A template-argument can be
19349 deduced from a pointer to function or pointer
19350 to member function argument if the set of
19351 overloaded functions does not contain function
19352 templates and at most one of a set of
19353 overloaded functions provides a unique
19355 resolve_overloaded_unification (tparms
, targs
, parm
,
19357 arg_strict
, explain_p
);
19358 /* If a unique match was not found, this is a
19359 non-deduced context, so we still succeed. */
19360 return unify_success (explain_p
);
19364 arg
= unlowered_expr_type (arg
);
19365 if (arg
== error_mark_node
)
19366 return unify_invalid (explain_p
);
19370 maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, arg_expr
);
19373 if ((TYPE_P (parm
) || TREE_CODE (parm
) == TEMPLATE_DECL
)
19374 != (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
))
19375 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
19377 /* For deduction from an init-list we need the actual list. */
19378 if (arg_expr
&& BRACE_ENCLOSED_INITIALIZER_P (arg_expr
))
19380 return unify (tparms
, targs
, parm
, arg
, arg_strict
, explain_p
);
19383 /* for_each_template_parm callback that always returns 0. */
19386 zero_r (tree
, void *)
19391 /* for_each_template_parm any_fn callback to handle deduction of a template
19392 type argument from the type of an array bound. */
19395 array_deduction_r (tree t
, void *data
)
19397 tree_pair_p d
= (tree_pair_p
)data
;
19398 tree
&tparms
= d
->purpose
;
19399 tree
&targs
= d
->value
;
19401 if (TREE_CODE (t
) == ARRAY_TYPE
)
19402 if (tree dom
= TYPE_DOMAIN (t
))
19403 if (tree max
= TYPE_MAX_VALUE (dom
))
19405 if (TREE_CODE (max
) == MINUS_EXPR
)
19406 max
= TREE_OPERAND (max
, 0);
19407 if (TREE_CODE (max
) == TEMPLATE_PARM_INDEX
)
19408 unify (tparms
, targs
, TREE_TYPE (max
), size_type_node
,
19409 UNIFY_ALLOW_NONE
, /*explain*/false);
19412 /* Keep walking. */
19416 /* Try to deduce any not-yet-deduced template type arguments from the type of
19417 an array bound. This is handled separately from unify because 14.8.2.5 says
19418 "The type of a type parameter is only deduced from an array bound if it is
19419 not otherwise deduced." */
19422 try_array_deduction (tree tparms
, tree targs
, tree parm
)
19424 tree_pair_s data
= { tparms
, targs
};
19425 hash_set
<tree
> visited
;
19426 for_each_template_parm (parm
, zero_r
, &data
, &visited
,
19427 /*nondeduced*/false, array_deduction_r
);
19430 /* Most parms like fn_type_unification.
19432 If SUBR is 1, we're being called recursively (to unify the
19433 arguments of a function or method parameter of a function
19436 CHECKS is a pointer to a vector of access checks encountered while
19437 substituting default template arguments. */
19440 type_unification_real (tree tparms
,
19444 unsigned int xnargs
,
19446 unification_kind_t strict
,
19448 vec
<deferred_access_check
, va_gc
> **checks
,
19453 int ntparms
= TREE_VEC_LENGTH (tparms
);
19454 int saw_undeduced
= 0;
19457 unsigned int nargs
;
19460 gcc_assert (TREE_CODE (tparms
) == TREE_VEC
);
19461 gcc_assert (xparms
== NULL_TREE
|| TREE_CODE (xparms
) == TREE_LIST
);
19462 gcc_assert (ntparms
> 0);
19464 tree targs
= INNERMOST_TEMPLATE_ARGS (full_targs
);
19466 /* Reset the number of non-defaulted template arguments contained
19468 NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
) = NULL_TREE
;
19476 while (parms
&& parms
!= void_list_node
19479 parm
= TREE_VALUE (parms
);
19481 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
19482 && (!TREE_CHAIN (parms
) || TREE_CHAIN (parms
) == void_list_node
))
19483 /* For a function parameter pack that occurs at the end of the
19484 parameter-declaration-list, the type A of each remaining
19485 argument of the call is compared with the type P of the
19486 declarator-id of the function parameter pack. */
19489 parms
= TREE_CHAIN (parms
);
19491 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
19492 /* For a function parameter pack that does not occur at the
19493 end of the parameter-declaration-list, the type of the
19494 parameter pack is a non-deduced context. */
19500 if (unify_one_argument (tparms
, full_targs
, parm
, arg
, subr
, strict
,
19506 && parms
!= void_list_node
19507 && TREE_CODE (TREE_VALUE (parms
)) == TYPE_PACK_EXPANSION
)
19509 /* Unify the remaining arguments with the pack expansion type. */
19511 tree parmvec
= make_tree_vec (1);
19513 /* Allocate a TREE_VEC and copy in all of the arguments */
19514 argvec
= make_tree_vec (nargs
- ia
);
19515 for (i
= 0; ia
< nargs
; ++ia
, ++i
)
19516 TREE_VEC_ELT (argvec
, i
) = args
[ia
];
19518 /* Copy the parameter into parmvec. */
19519 TREE_VEC_ELT (parmvec
, 0) = TREE_VALUE (parms
);
19520 if (unify_pack_expansion (tparms
, full_targs
, parmvec
, argvec
, strict
,
19521 /*subr=*/subr
, explain_p
))
19524 /* Advance to the end of the list of parameters. */
19525 parms
= TREE_CHAIN (parms
);
19528 /* Fail if we've reached the end of the parm list, and more args
19529 are present, and the parm list isn't variadic. */
19530 if (ia
< nargs
&& parms
== void_list_node
)
19531 return unify_too_many_arguments (explain_p
, nargs
, ia
);
19532 /* Fail if parms are left and they don't have default values and
19533 they aren't all deduced as empty packs (c++/57397). This is
19534 consistent with sufficient_parms_p. */
19535 if (parms
&& parms
!= void_list_node
19536 && TREE_PURPOSE (parms
) == NULL_TREE
)
19538 unsigned int count
= nargs
;
19543 type_pack_p
= TREE_CODE (TREE_VALUE (p
)) == TYPE_PACK_EXPANSION
;
19546 p
= TREE_CHAIN (p
);
19548 while (p
&& p
!= void_list_node
);
19549 if (count
!= nargs
)
19550 return unify_too_few_arguments (explain_p
, ia
, count
,
19556 tsubst_flags_t complain
= (explain_p
19557 ? tf_warning_or_error
19559 bool tried_array_deduction
= (cxx_dialect
< cxx17
);
19561 for (i
= 0; i
< ntparms
; i
++)
19563 tree targ
= TREE_VEC_ELT (targs
, i
);
19564 tree tparm
= TREE_VEC_ELT (tparms
, i
);
19566 /* Clear the "incomplete" flags on all argument packs now so that
19567 substituting them into later default arguments works. */
19568 if (targ
&& ARGUMENT_PACK_P (targ
))
19570 ARGUMENT_PACK_INCOMPLETE_P (targ
) = 0;
19571 ARGUMENT_PACK_EXPLICIT_ARGS (targ
) = NULL_TREE
;
19574 if (targ
|| tparm
== error_mark_node
)
19576 tparm
= TREE_VALUE (tparm
);
19578 if (TREE_CODE (tparm
) == TYPE_DECL
19579 && !tried_array_deduction
)
19581 try_array_deduction (tparms
, targs
, xparms
);
19582 tried_array_deduction
= true;
19583 if (TREE_VEC_ELT (targs
, i
))
19587 /* If this is an undeduced nontype parameter that depends on
19588 a type parameter, try another pass; its type may have been
19589 deduced from a later argument than the one from which
19590 this parameter can be deduced. */
19591 if (TREE_CODE (tparm
) == PARM_DECL
19592 && uses_template_parms (TREE_TYPE (tparm
))
19593 && saw_undeduced
< 2)
19599 /* Core issue #226 (C++0x) [temp.deduct]:
19601 If a template argument has not been deduced, its
19602 default template argument, if any, is used.
19604 When we are in C++98 mode, TREE_PURPOSE will either
19605 be NULL_TREE or ERROR_MARK_NODE, so we do not need
19606 to explicitly check cxx_dialect here. */
19607 if (TREE_PURPOSE (TREE_VEC_ELT (tparms
, i
)))
19608 /* OK, there is a default argument. Wait until after the
19609 conversion check to do substitution. */
19612 /* If the type parameter is a parameter pack, then it will
19613 be deduced to an empty parameter pack. */
19614 if (template_parameter_pack_p (tparm
))
19618 if (TREE_CODE (tparm
) == TEMPLATE_PARM_INDEX
)
19620 arg
= make_node (NONTYPE_ARGUMENT_PACK
);
19621 TREE_CONSTANT (arg
) = 1;
19624 arg
= cxx_make_type (TYPE_ARGUMENT_PACK
);
19626 SET_ARGUMENT_PACK_ARGS (arg
, make_tree_vec (0));
19628 TREE_VEC_ELT (targs
, i
) = arg
;
19632 return unify_parameter_deduction_failure (explain_p
, tparm
);
19635 /* DR 1391: All parameters have args, now check non-dependent parms for
19637 if (saw_undeduced
< 2)
19638 for (ia
= 0, parms
= xparms
, args
= xargs
, nargs
= xnargs
;
19639 parms
&& parms
!= void_list_node
&& ia
< nargs
; )
19641 parm
= TREE_VALUE (parms
);
19643 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
19644 && (!TREE_CHAIN (parms
)
19645 || TREE_CHAIN (parms
) == void_list_node
))
19646 /* For a function parameter pack that occurs at the end of the
19647 parameter-declaration-list, the type A of each remaining
19648 argument of the call is compared with the type P of the
19649 declarator-id of the function parameter pack. */
19652 parms
= TREE_CHAIN (parms
);
19654 if (TREE_CODE (parm
) == TYPE_PACK_EXPANSION
)
19655 /* For a function parameter pack that does not occur at the
19656 end of the parameter-declaration-list, the type of the
19657 parameter pack is a non-deduced context. */
19663 if (uses_template_parms (parm
))
19665 if (check_non_deducible_conversion (parm
, arg
, strict
, flags
,
19670 /* Now substitute into the default template arguments. */
19671 for (i
= 0; i
< ntparms
; i
++)
19673 tree targ
= TREE_VEC_ELT (targs
, i
);
19674 tree tparm
= TREE_VEC_ELT (tparms
, i
);
19676 if (targ
|| tparm
== error_mark_node
)
19678 tree parm
= TREE_VALUE (tparm
);
19680 if (TREE_CODE (parm
) == PARM_DECL
19681 && uses_template_parms (TREE_TYPE (parm
))
19682 && saw_undeduced
< 2)
19685 tree arg
= TREE_PURPOSE (tparm
);
19686 reopen_deferring_access_checks (*checks
);
19687 location_t save_loc
= input_location
;
19689 input_location
= DECL_SOURCE_LOCATION (parm
);
19690 arg
= tsubst_template_arg (arg
, full_targs
, complain
, NULL_TREE
);
19691 if (!uses_template_parms (arg
))
19692 arg
= convert_template_argument (parm
, arg
, full_targs
, complain
,
19694 else if (saw_undeduced
< 2)
19697 arg
= error_mark_node
;
19698 input_location
= save_loc
;
19699 *checks
= get_deferred_access_checks ();
19700 pop_deferring_access_checks ();
19701 if (arg
== error_mark_node
)
19705 TREE_VEC_ELT (targs
, i
) = arg
;
19706 /* The position of the first default template argument,
19707 is also the number of non-defaulted arguments in TARGS.
19709 if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
19710 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, i
);
19714 if (saw_undeduced
++ == 1)
19718 if (CHECKING_P
&& !NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
))
19719 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs
, TREE_VEC_LENGTH (targs
));
19721 return unify_success (explain_p
);
19724 /* Subroutine of type_unification_real. Args are like the variables
19725 at the call site. ARG is an overloaded function (or template-id);
19726 we try deducing template args from each of the overloads, and if
19727 only one succeeds, we go with that. Modifies TARGS and returns
19728 true on success. */
19731 resolve_overloaded_unification (tree tparms
,
19735 unification_kind_t strict
,
19739 tree tempargs
= copy_node (targs
);
19741 tree goodfn
= NULL_TREE
;
19744 if (TREE_CODE (arg
) == ADDR_EXPR
)
19746 arg
= TREE_OPERAND (arg
, 0);
19752 if (TREE_CODE (arg
) == COMPONENT_REF
)
19753 /* Handle `&x' where `x' is some static or non-static member
19755 arg
= TREE_OPERAND (arg
, 1);
19757 if (TREE_CODE (arg
) == OFFSET_REF
)
19758 arg
= TREE_OPERAND (arg
, 1);
19760 /* Strip baselink information. */
19761 if (BASELINK_P (arg
))
19762 arg
= BASELINK_FUNCTIONS (arg
);
19764 if (TREE_CODE (arg
) == TEMPLATE_ID_EXPR
)
19766 /* If we got some explicit template args, we need to plug them into
19767 the affected templates before we try to unify, in case the
19768 explicit args will completely resolve the templates in question. */
19771 tree expl_subargs
= TREE_OPERAND (arg
, 1);
19772 arg
= TREE_OPERAND (arg
, 0);
19774 for (lkp_iterator
iter (arg
); iter
; ++iter
)
19777 tree subargs
, elem
;
19779 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
19782 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
19783 expl_subargs
, NULL_TREE
, tf_none
,
19784 /*require_all_args=*/true,
19785 /*use_default_args=*/true);
19786 if (subargs
!= error_mark_node
19787 && !any_dependent_template_arguments_p (subargs
))
19789 elem
= TREE_TYPE (instantiate_template (fn
, subargs
, tf_none
));
19790 if (try_one_overload (tparms
, targs
, tempargs
, parm
,
19791 elem
, strict
, sub_strict
, addr_p
, explain_p
)
19792 && (!goodfn
|| !same_type_p (goodfn
, elem
)))
19801 /* If no templates (or more than one) are fully resolved by the
19802 explicit arguments, this template-id is a non-deduced context; it
19803 could still be OK if we deduce all template arguments for the
19804 enclosing call through other arguments. */
19808 else if (TREE_CODE (arg
) != OVERLOAD
19809 && TREE_CODE (arg
) != FUNCTION_DECL
)
19810 /* If ARG is, for example, "(0, &f)" then its type will be unknown
19811 -- but the deduction does not succeed because the expression is
19812 not just the function on its own. */
19815 for (lkp_iterator
iter (arg
); iter
; ++iter
)
19818 if (try_one_overload (tparms
, targs
, tempargs
, parm
, TREE_TYPE (fn
),
19819 strict
, sub_strict
, addr_p
, explain_p
)
19820 && (!goodfn
|| !decls_match (goodfn
, fn
)))
19827 /* [temp.deduct.type] A template-argument can be deduced from a pointer
19828 to function or pointer to member function argument if the set of
19829 overloaded functions does not contain function templates and at most
19830 one of a set of overloaded functions provides a unique match.
19832 So if we found multiple possibilities, we return success but don't
19833 deduce anything. */
19837 int i
= TREE_VEC_LENGTH (targs
);
19839 if (TREE_VEC_ELT (tempargs
, i
))
19841 tree old
= TREE_VEC_ELT (targs
, i
);
19842 tree new_
= TREE_VEC_ELT (tempargs
, i
);
19843 if (new_
&& old
&& ARGUMENT_PACK_P (old
)
19844 && ARGUMENT_PACK_EXPLICIT_ARGS (old
))
19845 /* Don't forget explicit template arguments in a pack. */
19846 ARGUMENT_PACK_EXPLICIT_ARGS (new_
)
19847 = ARGUMENT_PACK_EXPLICIT_ARGS (old
);
19848 TREE_VEC_ELT (targs
, i
) = new_
;
19857 /* Core DR 115: In contexts where deduction is done and fails, or in
19858 contexts where deduction is not done, if a template argument list is
19859 specified and it, along with any default template arguments, identifies
19860 a single function template specialization, then the template-id is an
19861 lvalue for the function template specialization. */
19864 resolve_nondeduced_context (tree orig_expr
, tsubst_flags_t complain
)
19866 tree expr
, offset
, baselink
;
19869 if (!type_unknown_p (orig_expr
))
19874 offset
= NULL_TREE
;
19875 baselink
= NULL_TREE
;
19877 if (TREE_CODE (expr
) == ADDR_EXPR
)
19879 expr
= TREE_OPERAND (expr
, 0);
19882 if (TREE_CODE (expr
) == OFFSET_REF
)
19885 expr
= TREE_OPERAND (expr
, 1);
19887 if (BASELINK_P (expr
))
19890 expr
= BASELINK_FUNCTIONS (expr
);
19893 if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
19896 tree goodfn
= NULL_TREE
;
19898 /* If we got some explicit template args, we need to plug them into
19899 the affected templates before we try to unify, in case the
19900 explicit args will completely resolve the templates in question. */
19902 tree expl_subargs
= TREE_OPERAND (expr
, 1);
19903 tree arg
= TREE_OPERAND (expr
, 0);
19904 tree badfn
= NULL_TREE
;
19905 tree badargs
= NULL_TREE
;
19907 for (lkp_iterator
iter (arg
); iter
; ++iter
)
19910 tree subargs
, elem
;
19912 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
19915 subargs
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (fn
),
19916 expl_subargs
, NULL_TREE
, tf_none
,
19917 /*require_all_args=*/true,
19918 /*use_default_args=*/true);
19919 if (subargs
!= error_mark_node
19920 && !any_dependent_template_arguments_p (subargs
))
19922 elem
= instantiate_template (fn
, subargs
, tf_none
);
19923 if (elem
== error_mark_node
)
19928 else if (elem
&& (!goodfn
|| !decls_match (goodfn
, elem
)))
19937 mark_used (goodfn
);
19940 expr
= build_baselink (BASELINK_BINFO (baselink
),
19941 BASELINK_ACCESS_BINFO (baselink
),
19942 expr
, BASELINK_OPTYPE (baselink
));
19946 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (offset
, 0)));
19947 expr
= build_offset_ref (base
, expr
, addr
, complain
);
19950 expr
= cp_build_addr_expr (expr
, complain
);
19953 else if (good
== 0 && badargs
&& (complain
& tf_error
))
19954 /* There were no good options and at least one bad one, so let the
19955 user know what the problem is. */
19956 instantiate_template (badfn
, badargs
, complain
);
19961 /* Subroutine of resolve_overloaded_unification; does deduction for a single
19962 overload. Fills TARGS with any deduced arguments, or error_mark_node if
19963 different overloads deduce different arguments for a given parm.
19964 ADDR_P is true if the expression for which deduction is being
19965 performed was of the form "& fn" rather than simply "fn".
19967 Returns 1 on success. */
19970 try_one_overload (tree tparms
,
19975 unification_kind_t strict
,
19984 if (arg
== error_mark_node
)
19987 /* [temp.deduct.type] A template-argument can be deduced from a pointer
19988 to function or pointer to member function argument if the set of
19989 overloaded functions does not contain function templates and at most
19990 one of a set of overloaded functions provides a unique match.
19992 So if this is a template, just return success. */
19994 if (uses_template_parms (arg
))
19997 if (TREE_CODE (arg
) == METHOD_TYPE
)
19998 arg
= build_ptrmemfunc_type (build_pointer_type (arg
));
20000 arg
= build_pointer_type (arg
);
20002 sub_strict
|= maybe_adjust_types_for_deduction (strict
, &parm
, &arg
, NULL
);
20004 /* We don't copy orig_targs for this because if we have already deduced
20005 some template args from previous args, unify would complain when we
20006 try to deduce a template parameter for the same argument, even though
20007 there isn't really a conflict. */
20008 nargs
= TREE_VEC_LENGTH (targs
);
20009 tempargs
= make_tree_vec (nargs
);
20011 if (unify (tparms
, tempargs
, parm
, arg
, sub_strict
, explain_p
))
20014 /* First make sure we didn't deduce anything that conflicts with
20015 explicitly specified args. */
20016 for (i
= nargs
; i
--; )
20018 tree elt
= TREE_VEC_ELT (tempargs
, i
);
20019 tree oldelt
= TREE_VEC_ELT (orig_targs
, i
);
20023 else if (uses_template_parms (elt
))
20024 /* Since we're unifying against ourselves, we will fill in
20025 template args used in the function parm list with our own
20026 template parms. Discard them. */
20027 TREE_VEC_ELT (tempargs
, i
) = NULL_TREE
;
20028 else if (oldelt
&& ARGUMENT_PACK_P (oldelt
))
20030 /* Check that the argument at each index of the deduced argument pack
20031 is equivalent to the corresponding explicitly specified argument.
20032 We may have deduced more arguments than were explicitly specified,
20035 /* We used to assert ARGUMENT_PACK_INCOMPLETE_P (oldelt) here, but
20036 that's wrong if we deduce the same argument pack from multiple
20037 function arguments: it's only incomplete the first time. */
20039 tree explicit_pack
= ARGUMENT_PACK_ARGS (oldelt
);
20040 tree deduced_pack
= ARGUMENT_PACK_ARGS (elt
);
20042 if (TREE_VEC_LENGTH (deduced_pack
)
20043 < TREE_VEC_LENGTH (explicit_pack
))
20046 for (int j
= 0; j
< TREE_VEC_LENGTH (explicit_pack
); j
++)
20047 if (!template_args_equal (TREE_VEC_ELT (explicit_pack
, j
),
20048 TREE_VEC_ELT (deduced_pack
, j
)))
20051 else if (oldelt
&& !template_args_equal (oldelt
, elt
))
20055 for (i
= nargs
; i
--; )
20057 tree elt
= TREE_VEC_ELT (tempargs
, i
);
20060 TREE_VEC_ELT (targs
, i
) = elt
;
20066 /* PARM is a template class (perhaps with unbound template
20067 parameters). ARG is a fully instantiated type. If ARG can be
20068 bound to PARM, return ARG, otherwise return NULL_TREE. TPARMS and
20069 TARGS are as for unify. */
20072 try_class_unification (tree tparms
, tree targs
, tree parm
, tree arg
,
20075 tree copy_of_targs
;
20077 if (!CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
20079 else if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20080 /* Matches anything. */;
20081 else if (most_general_template (CLASSTYPE_TI_TEMPLATE (arg
))
20082 != most_general_template (CLASSTYPE_TI_TEMPLATE (parm
)))
20085 /* We need to make a new template argument vector for the call to
20086 unify. If we used TARGS, we'd clutter it up with the result of
20087 the attempted unification, even if this class didn't work out.
20088 We also don't want to commit ourselves to all the unifications
20089 we've already done, since unification is supposed to be done on
20090 an argument-by-argument basis. In other words, consider the
20091 following pathological case:
20093 template <int I, int J, int K>
20096 template <int I, int J>
20097 struct S<I, J, 2> : public S<I, I, I>, S<J, J, J> {};
20099 template <int I, int J, int K>
20100 void f(S<I, J, K>, S<I, I, I>);
20109 Now, by the time we consider the unification involving `s2', we
20110 already know that we must have `f<0, 0, 0>'. But, even though
20111 `S<0, 1, 2>' is derived from `S<0, 0, 0>', the code is invalid
20112 because there are two ways to unify base classes of S<0, 1, 2>
20113 with S<I, I, I>. If we kept the already deduced knowledge, we
20114 would reject the possibility I=1. */
20115 copy_of_targs
= make_tree_vec (TREE_VEC_LENGTH (targs
));
20117 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20119 if (unify_bound_ttp_args (tparms
, copy_of_targs
, parm
, arg
, explain_p
))
20124 /* If unification failed, we're done. */
20125 if (unify (tparms
, copy_of_targs
, CLASSTYPE_TI_ARGS (parm
),
20126 CLASSTYPE_TI_ARGS (arg
), UNIFY_ALLOW_NONE
, explain_p
))
20132 /* Given a template type PARM and a class type ARG, find the unique
20133 base type in ARG that is an instance of PARM. We do not examine
20134 ARG itself; only its base-classes. If there is not exactly one
20135 appropriate base class, return NULL_TREE. PARM may be the type of
20136 a partial specialization, as well as a plain template type. Used
20139 static enum template_base_result
20140 get_template_base (tree tparms
, tree targs
, tree parm
, tree arg
,
20141 bool explain_p
, tree
*result
)
20143 tree rval
= NULL_TREE
;
20146 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg
)));
20148 binfo
= TYPE_BINFO (complete_type (arg
));
20151 /* The type could not be completed. */
20152 *result
= NULL_TREE
;
20153 return tbr_incomplete_type
;
20156 /* Walk in inheritance graph order. The search order is not
20157 important, and this avoids multiple walks of virtual bases. */
20158 for (binfo
= TREE_CHAIN (binfo
); binfo
; binfo
= TREE_CHAIN (binfo
))
20160 tree r
= try_class_unification (tparms
, targs
, parm
,
20161 BINFO_TYPE (binfo
), explain_p
);
20165 /* If there is more than one satisfactory baseclass, then:
20169 If they yield more than one possible deduced A, the type
20173 if (rval
&& !same_type_p (r
, rval
))
20175 *result
= NULL_TREE
;
20176 return tbr_ambiguous_baseclass
;
20184 return tbr_success
;
20187 /* Returns the level of DECL, which declares a template parameter. */
20190 template_decl_level (tree decl
)
20192 switch (TREE_CODE (decl
))
20195 case TEMPLATE_DECL
:
20196 return TEMPLATE_TYPE_LEVEL (TREE_TYPE (decl
));
20199 return TEMPLATE_PARM_LEVEL (DECL_INITIAL (decl
));
20202 gcc_unreachable ();
20207 /* Decide whether ARG can be unified with PARM, considering only the
20208 cv-qualifiers of each type, given STRICT as documented for unify.
20209 Returns nonzero iff the unification is OK on that basis. */
20212 check_cv_quals_for_unify (int strict
, tree arg
, tree parm
)
20214 int arg_quals
= cp_type_quals (arg
);
20215 int parm_quals
= cp_type_quals (parm
);
20217 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
20218 && !(strict
& UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
20220 /* Although a CVR qualifier is ignored when being applied to a
20221 substituted template parameter ([8.3.2]/1 for example), that
20222 does not allow us to unify "const T" with "int&" because both
20223 types are not of the form "cv-list T" [14.8.2.5 temp.deduct.type].
20224 It is ok when we're allowing additional CV qualifiers
20225 at the outer level [14.8.2.1]/3,1st bullet. */
20226 if ((TREE_CODE (arg
) == REFERENCE_TYPE
20227 || TREE_CODE (arg
) == FUNCTION_TYPE
20228 || TREE_CODE (arg
) == METHOD_TYPE
)
20229 && (parm_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)))
20232 if ((!POINTER_TYPE_P (arg
) && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
)
20233 && (parm_quals
& TYPE_QUAL_RESTRICT
))
20237 if (!(strict
& (UNIFY_ALLOW_MORE_CV_QUAL
| UNIFY_ALLOW_OUTER_MORE_CV_QUAL
))
20238 && (arg_quals
& parm_quals
) != parm_quals
)
20241 if (!(strict
& (UNIFY_ALLOW_LESS_CV_QUAL
| UNIFY_ALLOW_OUTER_LESS_CV_QUAL
))
20242 && (parm_quals
& arg_quals
) != arg_quals
)
20248 /* Determines the LEVEL and INDEX for the template parameter PARM. */
20250 template_parm_level_and_index (tree parm
, int* level
, int* index
)
20252 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
20253 || TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
20254 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20256 *index
= TEMPLATE_TYPE_IDX (parm
);
20257 *level
= TEMPLATE_TYPE_LEVEL (parm
);
20261 *index
= TEMPLATE_PARM_IDX (parm
);
20262 *level
= TEMPLATE_PARM_LEVEL (parm
);
20266 #define RECUR_AND_CHECK_FAILURE(TP, TA, P, A, S, EP) \
20268 if (unify (TP, TA, P, A, S, EP)) \
20272 /* Unifies the remaining arguments in PACKED_ARGS with the pack
20273 expansion at the end of PACKED_PARMS. Returns 0 if the type
20274 deduction succeeds, 1 otherwise. STRICT is the same as in
20275 fn_type_unification. CALL_ARGS_P is true iff PACKED_ARGS is actually a
20276 function call argument list. We'll need to adjust the arguments to make them
20277 types. SUBR tells us if this is from a recursive call to
20278 type_unification_real, or for comparing two template argument
20282 unify_pack_expansion (tree tparms
, tree targs
, tree packed_parms
,
20283 tree packed_args
, unification_kind_t strict
,
20284 bool subr
, bool explain_p
)
20287 = TREE_VEC_ELT (packed_parms
, TREE_VEC_LENGTH (packed_parms
) - 1);
20288 tree pattern
= PACK_EXPANSION_PATTERN (parm
);
20289 tree pack
, packs
= NULL_TREE
;
20290 int i
, start
= TREE_VEC_LENGTH (packed_parms
) - 1;
20292 /* Add in any args remembered from an earlier partial instantiation. */
20293 targs
= add_to_template_args (PACK_EXPANSION_EXTRA_ARGS (parm
), targs
);
20295 packed_args
= expand_template_argument_pack (packed_args
);
20297 int len
= TREE_VEC_LENGTH (packed_args
);
20299 /* Determine the parameter packs we will be deducing from the
20300 pattern, and record their current deductions. */
20301 for (pack
= PACK_EXPANSION_PARAMETER_PACKS (parm
);
20302 pack
; pack
= TREE_CHAIN (pack
))
20304 tree parm_pack
= TREE_VALUE (pack
);
20307 /* Determine the index and level of this parameter pack. */
20308 template_parm_level_and_index (parm_pack
, &level
, &idx
);
20310 /* Keep track of the parameter packs and their corresponding
20312 packs
= tree_cons (parm_pack
, TMPL_ARG (targs
, level
, idx
), packs
);
20313 TREE_TYPE (packs
) = make_tree_vec (len
- start
);
20316 /* Loop through all of the arguments that have not yet been
20317 unified and unify each with the pattern. */
20318 for (i
= start
; i
< len
; i
++)
20321 bool any_explicit
= false;
20322 tree arg
= TREE_VEC_ELT (packed_args
, i
);
20324 /* For each parameter pack, set its TMPL_ARG to either NULL_TREE
20325 or the element of its argument pack at the current index if
20326 this argument was explicitly specified. */
20327 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
20331 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
20334 if (TREE_VALUE (pack
)
20335 && (pargs
= ARGUMENT_PACK_EXPLICIT_ARGS (TREE_VALUE (pack
)))
20336 && (i
- start
< TREE_VEC_LENGTH (pargs
)))
20338 any_explicit
= true;
20339 arg
= TREE_VEC_ELT (pargs
, i
- start
);
20341 TMPL_ARG (targs
, level
, idx
) = arg
;
20344 /* If we had explicit template arguments, substitute them into the
20345 pattern before deduction. */
20348 /* Some arguments might still be unspecified or dependent. */
20350 ++processing_template_decl
;
20351 dependent
= any_dependent_template_arguments_p (targs
);
20353 --processing_template_decl
;
20354 parm
= tsubst (pattern
, targs
,
20355 explain_p
? tf_warning_or_error
: tf_none
,
20358 --processing_template_decl
;
20359 if (parm
== error_mark_node
)
20365 /* Unify the pattern with the current argument. */
20366 if (unify_one_argument (tparms
, targs
, parm
, arg
, subr
, strict
,
20370 /* For each parameter pack, collect the deduced value. */
20371 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
20374 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
20376 TREE_VEC_ELT (TREE_TYPE (pack
), i
- start
) =
20377 TMPL_ARG (targs
, level
, idx
);
20381 /* Verify that the results of unification with the parameter packs
20382 produce results consistent with what we've seen before, and make
20383 the deduced argument packs available. */
20384 for (pack
= packs
; pack
; pack
= TREE_CHAIN (pack
))
20386 tree old_pack
= TREE_VALUE (pack
);
20387 tree new_args
= TREE_TYPE (pack
);
20388 int i
, len
= TREE_VEC_LENGTH (new_args
);
20390 bool nondeduced_p
= false;
20392 /* By default keep the original deduced argument pack.
20393 If necessary, more specific code is going to update the
20394 resulting deduced argument later down in this function. */
20395 template_parm_level_and_index (TREE_PURPOSE (pack
), &level
, &idx
);
20396 TMPL_ARG (targs
, level
, idx
) = old_pack
;
20398 /* If NEW_ARGS contains any NULL_TREE entries, we didn't
20399 actually deduce anything. */
20400 for (i
= 0; i
< len
&& !nondeduced_p
; ++i
)
20401 if (TREE_VEC_ELT (new_args
, i
) == NULL_TREE
)
20402 nondeduced_p
= true;
20406 if (old_pack
&& ARGUMENT_PACK_INCOMPLETE_P (old_pack
))
20408 /* If we had fewer function args than explicit template args,
20409 just use the explicits. */
20410 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
20411 int explicit_len
= TREE_VEC_LENGTH (explicit_args
);
20412 if (len
< explicit_len
)
20413 new_args
= explicit_args
;
20419 /* Build the deduced *_ARGUMENT_PACK. */
20420 if (TREE_CODE (TREE_PURPOSE (pack
)) == TEMPLATE_PARM_INDEX
)
20422 result
= make_node (NONTYPE_ARGUMENT_PACK
);
20423 TREE_CONSTANT (result
) = 1;
20426 result
= cxx_make_type (TYPE_ARGUMENT_PACK
);
20428 SET_ARGUMENT_PACK_ARGS (result
, new_args
);
20430 /* Note the deduced argument packs for this parameter
20432 TMPL_ARG (targs
, level
, idx
) = result
;
20434 else if (ARGUMENT_PACK_INCOMPLETE_P (old_pack
)
20435 && (ARGUMENT_PACK_ARGS (old_pack
)
20436 == ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
)))
20438 /* We only had the explicitly-provided arguments before, but
20439 now we have a complete set of arguments. */
20440 tree explicit_args
= ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
);
20442 SET_ARGUMENT_PACK_ARGS (old_pack
, new_args
);
20443 ARGUMENT_PACK_INCOMPLETE_P (old_pack
) = 1;
20444 ARGUMENT_PACK_EXPLICIT_ARGS (old_pack
) = explicit_args
;
20448 tree bad_old_arg
= NULL_TREE
, bad_new_arg
= NULL_TREE
;
20449 tree old_args
= ARGUMENT_PACK_ARGS (old_pack
);
20451 if (!comp_template_args (old_args
, new_args
,
20452 &bad_old_arg
, &bad_new_arg
))
20453 /* Inconsistent unification of this parameter pack. */
20454 return unify_parameter_pack_inconsistent (explain_p
,
20460 return unify_success (explain_p
);
20463 /* Handle unification of the domain of an array. PARM_DOM and ARG_DOM are
20464 INTEGER_TYPEs representing the TYPE_DOMAIN of ARRAY_TYPEs. The other
20465 parameters and return value are as for unify. */
20468 unify_array_domain (tree tparms
, tree targs
,
20469 tree parm_dom
, tree arg_dom
,
20477 /* Our representation of array types uses "N - 1" as the
20478 TYPE_MAX_VALUE for an array with "N" elements, if "N" is
20479 not an integer constant. We cannot unify arbitrarily
20480 complex expressions, so we eliminate the MINUS_EXPRs
20482 parm_max
= TYPE_MAX_VALUE (parm_dom
);
20483 parm_cst
= TREE_CODE (parm_max
) == INTEGER_CST
;
20486 gcc_assert (TREE_CODE (parm_max
) == MINUS_EXPR
);
20487 parm_max
= TREE_OPERAND (parm_max
, 0);
20489 arg_max
= TYPE_MAX_VALUE (arg_dom
);
20490 arg_cst
= TREE_CODE (arg_max
) == INTEGER_CST
;
20493 /* The ARG_MAX may not be a simple MINUS_EXPR, if we are
20494 trying to unify the type of a variable with the type
20495 of a template parameter. For example:
20497 template <unsigned int N>
20498 void f (char (&) [N]);
20505 Here, the type of the ARG will be "int [g(i)]", and
20506 may be a SAVE_EXPR, etc. */
20507 if (TREE_CODE (arg_max
) != MINUS_EXPR
)
20508 return unify_vla_arg (explain_p
, arg_dom
);
20509 arg_max
= TREE_OPERAND (arg_max
, 0);
20512 /* If only one of the bounds used a MINUS_EXPR, compensate
20513 by adding one to the other bound. */
20514 if (parm_cst
&& !arg_cst
)
20515 parm_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
20519 else if (arg_cst
&& !parm_cst
)
20520 arg_max
= fold_build2_loc (input_location
, PLUS_EXPR
,
20525 return unify (tparms
, targs
, parm_max
, arg_max
,
20526 UNIFY_ALLOW_INTEGER
, explain_p
);
20529 /* Returns whether T, a P or A in unify, is a type, template or expression. */
20531 enum pa_kind_t
{ pa_type
, pa_tmpl
, pa_expr
};
20536 if (PACK_EXPANSION_P (t
))
20537 t
= PACK_EXPANSION_PATTERN (t
);
20538 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
20539 || TREE_CODE (t
) == UNBOUND_CLASS_TEMPLATE
20540 || DECL_TYPE_TEMPLATE_P (t
))
20542 else if (TYPE_P (t
))
20548 /* Deduce the value of template parameters. TPARMS is the (innermost)
20549 set of template parameters to a template. TARGS is the bindings
20550 for those template parameters, as determined thus far; TARGS may
20551 include template arguments for outer levels of template parameters
20552 as well. PARM is a parameter to a template function, or a
20553 subcomponent of that parameter; ARG is the corresponding argument.
20554 This function attempts to match PARM with ARG in a manner
20555 consistent with the existing assignments in TARGS. If more values
20556 are deduced, then TARGS is updated.
20558 Returns 0 if the type deduction succeeds, 1 otherwise. The
20559 parameter STRICT is a bitwise or of the following flags:
20562 Require an exact match between PARM and ARG.
20563 UNIFY_ALLOW_MORE_CV_QUAL:
20564 Allow the deduced ARG to be more cv-qualified (by qualification
20565 conversion) than ARG.
20566 UNIFY_ALLOW_LESS_CV_QUAL:
20567 Allow the deduced ARG to be less cv-qualified than ARG.
20568 UNIFY_ALLOW_DERIVED:
20569 Allow the deduced ARG to be a template base class of ARG,
20570 or a pointer to a template base class of the type pointed to by
20572 UNIFY_ALLOW_INTEGER:
20573 Allow any integral type to be deduced. See the TEMPLATE_PARM_INDEX
20574 case for more information.
20575 UNIFY_ALLOW_OUTER_LEVEL:
20576 This is the outermost level of a deduction. Used to determine validity
20577 of qualification conversions. A valid qualification conversion must
20578 have const qualified pointers leading up to the inner type which
20579 requires additional CV quals, except at the outer level, where const
20580 is not required [conv.qual]. It would be normal to set this flag in
20581 addition to setting UNIFY_ALLOW_MORE_CV_QUAL.
20582 UNIFY_ALLOW_OUTER_MORE_CV_QUAL:
20583 This is the outermost level of a deduction, and PARM can be more CV
20584 qualified at this point.
20585 UNIFY_ALLOW_OUTER_LESS_CV_QUAL:
20586 This is the outermost level of a deduction, and PARM can be less CV
20587 qualified at this point. */
20590 unify (tree tparms
, tree targs
, tree parm
, tree arg
, int strict
,
20596 int strict_in
= strict
;
20597 tsubst_flags_t complain
= (explain_p
20598 ? tf_warning_or_error
20601 /* I don't think this will do the right thing with respect to types.
20602 But the only case I've seen it in so far has been array bounds, where
20603 signedness is the only information lost, and I think that will be
20605 while (CONVERT_EXPR_P (parm
))
20606 parm
= TREE_OPERAND (parm
, 0);
20608 if (arg
== error_mark_node
)
20609 return unify_invalid (explain_p
);
20610 if (arg
== unknown_type_node
20611 || arg
== init_list_type_node
)
20612 /* We can't deduce anything from this, but we might get all the
20613 template args from other function args. */
20614 return unify_success (explain_p
);
20616 if (parm
== any_targ_node
|| arg
== any_targ_node
)
20617 return unify_success (explain_p
);
20619 /* If PARM uses template parameters, then we can't bail out here,
20620 even if ARG == PARM, since we won't record unifications for the
20621 template parameters. We might need them if we're trying to
20622 figure out which of two things is more specialized. */
20623 if (arg
== parm
&& !uses_template_parms (parm
))
20624 return unify_success (explain_p
);
20626 /* Handle init lists early, so the rest of the function can assume
20627 we're dealing with a type. */
20628 if (BRACE_ENCLOSED_INITIALIZER_P (arg
))
20632 tree orig_parm
= parm
;
20634 /* Replace T with std::initializer_list<T> for deduction. */
20635 if (TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
20636 && flag_deduce_init_list
)
20637 parm
= listify (parm
);
20639 if (!is_std_init_list (parm
)
20640 && TREE_CODE (parm
) != ARRAY_TYPE
)
20641 /* We can only deduce from an initializer list argument if the
20642 parameter is std::initializer_list or an array; otherwise this
20643 is a non-deduced context. */
20644 return unify_success (explain_p
);
20646 if (TREE_CODE (parm
) == ARRAY_TYPE
)
20647 elttype
= TREE_TYPE (parm
);
20650 elttype
= TREE_VEC_ELT (CLASSTYPE_TI_ARGS (parm
), 0);
20651 /* Deduction is defined in terms of a single type, so just punt
20652 on the (bizarre) std::initializer_list<T...>. */
20653 if (PACK_EXPANSION_P (elttype
))
20654 return unify_success (explain_p
);
20657 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg
), i
, elt
)
20659 int elt_strict
= strict
;
20661 if (elt
== error_mark_node
)
20662 return unify_invalid (explain_p
);
20664 if (!BRACE_ENCLOSED_INITIALIZER_P (elt
))
20666 tree type
= TREE_TYPE (elt
);
20667 if (type
== error_mark_node
)
20668 return unify_invalid (explain_p
);
20669 /* It should only be possible to get here for a call. */
20670 gcc_assert (elt_strict
& UNIFY_ALLOW_OUTER_LEVEL
);
20671 elt_strict
|= maybe_adjust_types_for_deduction
20672 (DEDUCE_CALL
, &elttype
, &type
, elt
);
20676 RECUR_AND_CHECK_FAILURE (tparms
, targs
, elttype
, elt
, elt_strict
,
20680 if (TREE_CODE (parm
) == ARRAY_TYPE
20681 && deducible_array_bound (TYPE_DOMAIN (parm
)))
20683 /* Also deduce from the length of the initializer list. */
20684 tree max
= size_int (CONSTRUCTOR_NELTS (arg
));
20685 tree idx
= compute_array_index_type (NULL_TREE
, max
, tf_none
);
20686 if (idx
== error_mark_node
)
20687 return unify_invalid (explain_p
);
20688 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
20692 /* If the std::initializer_list<T> deduction worked, replace the
20693 deduced A with std::initializer_list<A>. */
20694 if (orig_parm
!= parm
)
20696 idx
= TEMPLATE_TYPE_IDX (orig_parm
);
20697 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
20698 targ
= listify (targ
);
20699 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = targ
;
20701 return unify_success (explain_p
);
20704 /* If parm and arg aren't the same kind of thing (template, type, or
20705 expression), fail early. */
20706 if (pa_kind (parm
) != pa_kind (arg
))
20707 return unify_invalid (explain_p
);
20709 /* Immediately reject some pairs that won't unify because of
20710 cv-qualification mismatches. */
20711 if (TREE_CODE (arg
) == TREE_CODE (parm
)
20713 /* It is the elements of the array which hold the cv quals of an array
20714 type, and the elements might be template type parms. We'll check
20715 when we recurse. */
20716 && TREE_CODE (arg
) != ARRAY_TYPE
20717 /* We check the cv-qualifiers when unifying with template type
20718 parameters below. We want to allow ARG `const T' to unify with
20719 PARM `T' for example, when computing which of two templates
20720 is more specialized, for example. */
20721 && TREE_CODE (arg
) != TEMPLATE_TYPE_PARM
20722 && !check_cv_quals_for_unify (strict_in
, arg
, parm
))
20723 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
20725 if (!(strict
& UNIFY_ALLOW_OUTER_LEVEL
)
20726 && TYPE_P (parm
) && !CP_TYPE_CONST_P (parm
))
20727 strict
&= ~UNIFY_ALLOW_MORE_CV_QUAL
;
20728 strict
&= ~UNIFY_ALLOW_OUTER_LEVEL
;
20729 strict
&= ~UNIFY_ALLOW_DERIVED
;
20730 strict
&= ~UNIFY_ALLOW_OUTER_MORE_CV_QUAL
;
20731 strict
&= ~UNIFY_ALLOW_OUTER_LESS_CV_QUAL
;
20733 switch (TREE_CODE (parm
))
20735 case TYPENAME_TYPE
:
20737 case UNBOUND_CLASS_TEMPLATE
:
20738 /* In a type which contains a nested-name-specifier, template
20739 argument values cannot be deduced for template parameters used
20740 within the nested-name-specifier. */
20741 return unify_success (explain_p
);
20743 case TEMPLATE_TYPE_PARM
:
20744 case TEMPLATE_TEMPLATE_PARM
:
20745 case BOUND_TEMPLATE_TEMPLATE_PARM
:
20746 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
20747 if (error_operand_p (tparm
))
20748 return unify_invalid (explain_p
);
20750 if (TEMPLATE_TYPE_LEVEL (parm
)
20751 != template_decl_level (tparm
))
20752 /* The PARM is not one we're trying to unify. Just check
20753 to see if it matches ARG. */
20755 if (TREE_CODE (arg
) == TREE_CODE (parm
)
20756 && (is_auto (parm
) ? is_auto (arg
)
20757 : same_type_p (parm
, arg
)))
20758 return unify_success (explain_p
);
20760 return unify_type_mismatch (explain_p
, parm
, arg
);
20762 idx
= TEMPLATE_TYPE_IDX (parm
);
20763 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
20764 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, idx
));
20765 if (error_operand_p (tparm
))
20766 return unify_invalid (explain_p
);
20768 /* Check for mixed types and values. */
20769 if ((TREE_CODE (parm
) == TEMPLATE_TYPE_PARM
20770 && TREE_CODE (tparm
) != TYPE_DECL
)
20771 || (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
20772 && TREE_CODE (tparm
) != TEMPLATE_DECL
))
20773 gcc_unreachable ();
20775 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20777 if ((strict_in
& UNIFY_ALLOW_DERIVED
)
20778 && CLASS_TYPE_P (arg
))
20780 /* First try to match ARG directly. */
20781 tree t
= try_class_unification (tparms
, targs
, parm
, arg
,
20785 /* Otherwise, look for a suitable base of ARG, as below. */
20786 enum template_base_result r
;
20787 r
= get_template_base (tparms
, targs
, parm
, arg
,
20790 return unify_no_common_base (explain_p
, r
, parm
, arg
);
20794 /* ARG must be constructed from a template class or a template
20795 template parameter. */
20796 else if (TREE_CODE (arg
) != BOUND_TEMPLATE_TEMPLATE_PARM
20797 && !CLASSTYPE_SPECIALIZATION_OF_PRIMARY_TEMPLATE_P (arg
))
20798 return unify_template_deduction_failure (explain_p
, parm
, arg
);
20800 /* Deduce arguments T, i from TT<T> or TT<i>. */
20801 if (unify_bound_ttp_args (tparms
, targs
, parm
, arg
, explain_p
))
20804 arg
= TYPE_TI_TEMPLATE (arg
);
20806 /* Fall through to deduce template name. */
20809 if (TREE_CODE (parm
) == TEMPLATE_TEMPLATE_PARM
20810 || TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
20812 /* Deduce template name TT from TT, TT<>, TT<T> and TT<i>. */
20814 /* Simple cases: Value already set, does match or doesn't. */
20815 if (targ
!= NULL_TREE
&& template_args_equal (targ
, arg
))
20816 return unify_success (explain_p
);
20818 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
20822 /* If PARM is `const T' and ARG is only `int', we don't have
20823 a match unless we are allowing additional qualification.
20824 If ARG is `const int' and PARM is just `T' that's OK;
20825 that binds `const int' to `T'. */
20826 if (!check_cv_quals_for_unify (strict_in
| UNIFY_ALLOW_LESS_CV_QUAL
,
20828 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
20830 /* Consider the case where ARG is `const volatile int' and
20831 PARM is `const T'. Then, T should be `volatile int'. */
20832 arg
= cp_build_qualified_type_real
20833 (arg
, cp_type_quals (arg
) & ~cp_type_quals (parm
), tf_none
);
20834 if (arg
== error_mark_node
)
20835 return unify_invalid (explain_p
);
20837 /* Simple cases: Value already set, does match or doesn't. */
20838 if (targ
!= NULL_TREE
&& same_type_p (targ
, arg
))
20839 return unify_success (explain_p
);
20841 return unify_inconsistency (explain_p
, parm
, targ
, arg
);
20843 /* Make sure that ARG is not a variable-sized array. (Note
20844 that were talking about variable-sized arrays (like
20845 `int[n]'), rather than arrays of unknown size (like
20846 `int[]').) We'll get very confused by such a type since
20847 the bound of the array is not constant, and therefore
20848 not mangleable. Besides, such types are not allowed in
20849 ISO C++, so we can do as we please here. We do allow
20850 them for 'auto' deduction, since that isn't ABI-exposed. */
20851 if (!is_auto (parm
) && variably_modified_type_p (arg
, NULL_TREE
))
20852 return unify_vla_arg (explain_p
, arg
);
20854 /* Strip typedefs as in convert_template_argument. */
20855 arg
= canonicalize_type_argument (arg
, tf_none
);
20858 /* If ARG is a parameter pack or an expansion, we cannot unify
20859 against it unless PARM is also a parameter pack. */
20860 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
20861 && !template_parameter_pack_p (parm
))
20862 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
20864 /* If the argument deduction results is a METHOD_TYPE,
20865 then there is a problem.
20866 METHOD_TYPE doesn't map to any real C++ type the result of
20867 the deduction can not be of that type. */
20868 if (TREE_CODE (arg
) == METHOD_TYPE
)
20869 return unify_method_type_error (explain_p
, arg
);
20871 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
20872 return unify_success (explain_p
);
20874 case TEMPLATE_PARM_INDEX
:
20875 tparm
= TREE_VALUE (TREE_VEC_ELT (tparms
, 0));
20876 if (error_operand_p (tparm
))
20877 return unify_invalid (explain_p
);
20879 if (TEMPLATE_PARM_LEVEL (parm
)
20880 != template_decl_level (tparm
))
20882 /* The PARM is not one we're trying to unify. Just check
20883 to see if it matches ARG. */
20884 int result
= !(TREE_CODE (arg
) == TREE_CODE (parm
)
20885 && cp_tree_equal (parm
, arg
));
20887 unify_expression_unequal (explain_p
, parm
, arg
);
20891 idx
= TEMPLATE_PARM_IDX (parm
);
20892 targ
= TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
);
20896 int x
= !cp_tree_equal (targ
, arg
);
20898 unify_inconsistency (explain_p
, parm
, targ
, arg
);
20902 /* [temp.deduct.type] If, in the declaration of a function template
20903 with a non-type template-parameter, the non-type
20904 template-parameter is used in an expression in the function
20905 parameter-list and, if the corresponding template-argument is
20906 deduced, the template-argument type shall match the type of the
20907 template-parameter exactly, except that a template-argument
20908 deduced from an array bound may be of any integral type.
20909 The non-type parameter might use already deduced type parameters. */
20910 tparm
= tsubst (TREE_TYPE (parm
), targs
, 0, NULL_TREE
);
20911 if (tree a
= type_uses_auto (tparm
))
20913 tparm
= do_auto_deduction (tparm
, arg
, a
, complain
, adc_unify
);
20914 if (tparm
== error_mark_node
)
20918 if (!TREE_TYPE (arg
))
20919 /* Template-parameter dependent expression. Just accept it for now.
20920 It will later be processed in convert_template_argument. */
20922 else if (same_type_p (non_reference (TREE_TYPE (arg
)),
20923 non_reference (tparm
)))
20925 else if ((strict
& UNIFY_ALLOW_INTEGER
)
20926 && CP_INTEGRAL_TYPE_P (tparm
))
20927 /* Convert the ARG to the type of PARM; the deduced non-type
20928 template argument must exactly match the types of the
20929 corresponding parameter. */
20930 arg
= fold (build_nop (tparm
, arg
));
20931 else if (uses_template_parms (tparm
))
20933 /* We haven't deduced the type of this parameter yet. */
20934 if (cxx_dialect
>= cxx17
20935 /* We deduce from array bounds in try_array_deduction. */
20936 && !(strict
& UNIFY_ALLOW_INTEGER
))
20938 /* Deduce it from the non-type argument. */
20939 tree atype
= TREE_TYPE (arg
);
20940 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
20942 UNIFY_ALLOW_NONE
, explain_p
);
20945 /* Try again later. */
20946 return unify_success (explain_p
);
20949 return unify_type_mismatch (explain_p
, tparm
, TREE_TYPE (arg
));
20951 /* If ARG is a parameter pack or an expansion, we cannot unify
20952 against it unless PARM is also a parameter pack. */
20953 if ((template_parameter_pack_p (arg
) || PACK_EXPANSION_P (arg
))
20954 && !TEMPLATE_PARM_PARAMETER_PACK (parm
))
20955 return unify_parameter_pack_mismatch (explain_p
, parm
, arg
);
20958 bool removed_attr
= false;
20959 arg
= strip_typedefs_expr (arg
, &removed_attr
);
20961 TREE_VEC_ELT (INNERMOST_TEMPLATE_ARGS (targs
), idx
) = arg
;
20962 return unify_success (explain_p
);
20966 /* A pointer-to-member constant can be unified only with
20967 another constant. */
20968 if (TREE_CODE (arg
) != PTRMEM_CST
)
20969 return unify_ptrmem_cst_mismatch (explain_p
, parm
, arg
);
20971 /* Just unify the class member. It would be useless (and possibly
20972 wrong, depending on the strict flags) to unify also
20973 PTRMEM_CST_CLASS, because we want to be sure that both parm and
20974 arg refer to the same variable, even if through different
20975 classes. For instance:
20977 struct A { int x; };
20980 Unification of &A::x and &B::x must succeed. */
20981 return unify (tparms
, targs
, PTRMEM_CST_MEMBER (parm
),
20982 PTRMEM_CST_MEMBER (arg
), strict
, explain_p
);
20987 if (!TYPE_PTR_P (arg
))
20988 return unify_type_mismatch (explain_p
, parm
, arg
);
20990 /* [temp.deduct.call]
20992 A can be another pointer or pointer to member type that can
20993 be converted to the deduced A via a qualification
20994 conversion (_conv.qual_).
20996 We pass down STRICT here rather than UNIFY_ALLOW_NONE.
20997 This will allow for additional cv-qualification of the
20998 pointed-to types if appropriate. */
21000 if (TREE_CODE (TREE_TYPE (arg
)) == RECORD_TYPE
)
21001 /* The derived-to-base conversion only persists through one
21002 level of pointers. */
21003 strict
|= (strict_in
& UNIFY_ALLOW_DERIVED
);
21005 return unify (tparms
, targs
, TREE_TYPE (parm
),
21006 TREE_TYPE (arg
), strict
, explain_p
);
21009 case REFERENCE_TYPE
:
21010 if (TREE_CODE (arg
) != REFERENCE_TYPE
)
21011 return unify_type_mismatch (explain_p
, parm
, arg
);
21012 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
21013 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
21016 if (TREE_CODE (arg
) != ARRAY_TYPE
)
21017 return unify_type_mismatch (explain_p
, parm
, arg
);
21018 if ((TYPE_DOMAIN (parm
) == NULL_TREE
)
21019 != (TYPE_DOMAIN (arg
) == NULL_TREE
))
21020 return unify_type_mismatch (explain_p
, parm
, arg
);
21021 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
21022 strict
& UNIFY_ALLOW_MORE_CV_QUAL
, explain_p
);
21023 if (TYPE_DOMAIN (parm
) != NULL_TREE
)
21024 return unify_array_domain (tparms
, targs
, TYPE_DOMAIN (parm
),
21025 TYPE_DOMAIN (arg
), explain_p
);
21026 return unify_success (explain_p
);
21033 case ENUMERAL_TYPE
:
21036 if (TREE_CODE (arg
) != TREE_CODE (parm
))
21037 return unify_type_mismatch (explain_p
, parm
, arg
);
21039 /* We have already checked cv-qualification at the top of the
21041 if (!same_type_ignoring_top_level_qualifiers_p (arg
, parm
))
21042 return unify_type_mismatch (explain_p
, parm
, arg
);
21044 /* As far as unification is concerned, this wins. Later checks
21045 will invalidate it if necessary. */
21046 return unify_success (explain_p
);
21048 /* Types INTEGER_CST and MINUS_EXPR can come from array bounds. */
21049 /* Type INTEGER_CST can come from ordinary constant template args. */
21051 while (CONVERT_EXPR_P (arg
))
21052 arg
= TREE_OPERAND (arg
, 0);
21054 if (TREE_CODE (arg
) != INTEGER_CST
)
21055 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
21056 return (tree_int_cst_equal (parm
, arg
)
21057 ? unify_success (explain_p
)
21058 : unify_template_argument_mismatch (explain_p
, parm
, arg
));
21062 int i
, len
, argslen
;
21063 int parm_variadic_p
= 0;
21065 if (TREE_CODE (arg
) != TREE_VEC
)
21066 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
21068 len
= TREE_VEC_LENGTH (parm
);
21069 argslen
= TREE_VEC_LENGTH (arg
);
21071 /* Check for pack expansions in the parameters. */
21072 for (i
= 0; i
< len
; ++i
)
21074 if (PACK_EXPANSION_P (TREE_VEC_ELT (parm
, i
)))
21077 /* We can unify against something with a trailing
21079 parm_variadic_p
= 1;
21081 /* [temp.deduct.type]/9: If the template argument list of
21082 P contains a pack expansion that is not the last
21083 template argument, the entire template argument list
21084 is a non-deduced context. */
21085 return unify_success (explain_p
);
21089 /* If we don't have enough arguments to satisfy the parameters
21090 (not counting the pack expression at the end), or we have
21091 too many arguments for a parameter list that doesn't end in
21092 a pack expression, we can't unify. */
21093 if (parm_variadic_p
21094 ? argslen
< len
- parm_variadic_p
21096 return unify_arity (explain_p
, TREE_VEC_LENGTH (arg
), len
);
21098 /* Unify all of the parameters that precede the (optional)
21099 pack expression. */
21100 for (i
= 0; i
< len
- parm_variadic_p
; ++i
)
21102 RECUR_AND_CHECK_FAILURE (tparms
, targs
,
21103 TREE_VEC_ELT (parm
, i
),
21104 TREE_VEC_ELT (arg
, i
),
21105 UNIFY_ALLOW_NONE
, explain_p
);
21107 if (parm_variadic_p
)
21108 return unify_pack_expansion (tparms
, targs
, parm
, arg
,
21110 /*subr=*/true, explain_p
);
21111 return unify_success (explain_p
);
21116 if (TREE_CODE (arg
) != TREE_CODE (parm
))
21117 return unify_type_mismatch (explain_p
, parm
, arg
);
21119 if (TYPE_PTRMEMFUNC_P (parm
))
21121 if (!TYPE_PTRMEMFUNC_P (arg
))
21122 return unify_type_mismatch (explain_p
, parm
, arg
);
21124 return unify (tparms
, targs
,
21125 TYPE_PTRMEMFUNC_FN_TYPE (parm
),
21126 TYPE_PTRMEMFUNC_FN_TYPE (arg
),
21127 strict
, explain_p
);
21129 else if (TYPE_PTRMEMFUNC_P (arg
))
21130 return unify_type_mismatch (explain_p
, parm
, arg
);
21132 if (CLASSTYPE_TEMPLATE_INFO (parm
))
21134 tree t
= NULL_TREE
;
21136 if (strict_in
& UNIFY_ALLOW_DERIVED
)
21138 /* First, we try to unify the PARM and ARG directly. */
21139 t
= try_class_unification (tparms
, targs
,
21140 parm
, arg
, explain_p
);
21144 /* Fallback to the special case allowed in
21145 [temp.deduct.call]:
21147 If P is a class, and P has the form
21148 template-id, then A can be a derived class of
21149 the deduced A. Likewise, if P is a pointer to
21150 a class of the form template-id, A can be a
21151 pointer to a derived class pointed to by the
21153 enum template_base_result r
;
21154 r
= get_template_base (tparms
, targs
, parm
, arg
,
21159 /* Don't give the derived diagnostic if we're
21160 already dealing with the same template. */
21162 = (CLASSTYPE_TEMPLATE_INFO (arg
)
21163 && (CLASSTYPE_TI_TEMPLATE (parm
)
21164 == CLASSTYPE_TI_TEMPLATE (arg
)));
21165 return unify_no_common_base (explain_p
&& !same_template
,
21170 else if (CLASSTYPE_TEMPLATE_INFO (arg
)
21171 && (CLASSTYPE_TI_TEMPLATE (parm
)
21172 == CLASSTYPE_TI_TEMPLATE (arg
)))
21173 /* Perhaps PARM is something like S<U> and ARG is S<int>.
21174 Then, we should unify `int' and `U'. */
21177 /* There's no chance of unification succeeding. */
21178 return unify_type_mismatch (explain_p
, parm
, arg
);
21180 return unify (tparms
, targs
, CLASSTYPE_TI_ARGS (parm
),
21181 CLASSTYPE_TI_ARGS (t
), UNIFY_ALLOW_NONE
, explain_p
);
21183 else if (!same_type_ignoring_top_level_qualifiers_p (parm
, arg
))
21184 return unify_type_mismatch (explain_p
, parm
, arg
);
21185 return unify_success (explain_p
);
21188 case FUNCTION_TYPE
:
21190 unsigned int nargs
;
21195 if (TREE_CODE (arg
) != TREE_CODE (parm
))
21196 return unify_type_mismatch (explain_p
, parm
, arg
);
21198 /* CV qualifications for methods can never be deduced, they must
21199 match exactly. We need to check them explicitly here,
21200 because type_unification_real treats them as any other
21201 cv-qualified parameter. */
21202 if (TREE_CODE (parm
) == METHOD_TYPE
21203 && (!check_cv_quals_for_unify
21205 class_of_this_parm (arg
),
21206 class_of_this_parm (parm
))))
21207 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
21208 if (TREE_CODE (arg
) == FUNCTION_TYPE
21209 && type_memfn_quals (parm
) != type_memfn_quals (arg
))
21210 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
21211 if (type_memfn_rqual (parm
) != type_memfn_rqual (arg
))
21212 return unify_type_mismatch (explain_p
, parm
, arg
);
21214 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_TYPE (parm
),
21215 TREE_TYPE (arg
), UNIFY_ALLOW_NONE
, explain_p
);
21217 nargs
= list_length (TYPE_ARG_TYPES (arg
));
21218 args
= XALLOCAVEC (tree
, nargs
);
21219 for (a
= TYPE_ARG_TYPES (arg
), i
= 0;
21220 a
!= NULL_TREE
&& a
!= void_list_node
;
21221 a
= TREE_CHAIN (a
), ++i
)
21222 args
[i
] = TREE_VALUE (a
);
21225 if (type_unification_real (tparms
, targs
, TYPE_ARG_TYPES (parm
),
21226 args
, nargs
, 1, DEDUCE_EXACT
,
21227 LOOKUP_NORMAL
, NULL
, explain_p
))
21230 if (flag_noexcept_type
)
21232 tree pspec
= TYPE_RAISES_EXCEPTIONS (parm
);
21233 tree aspec
= canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (arg
));
21234 if (pspec
== NULL_TREE
) pspec
= noexcept_false_spec
;
21235 if (aspec
== NULL_TREE
) aspec
= noexcept_false_spec
;
21236 if (TREE_PURPOSE (pspec
) && TREE_PURPOSE (aspec
)
21237 && uses_template_parms (TREE_PURPOSE (pspec
)))
21238 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TREE_PURPOSE (pspec
),
21239 TREE_PURPOSE (aspec
),
21240 UNIFY_ALLOW_NONE
, explain_p
);
21241 else if (nothrow_spec_p (pspec
) && !nothrow_spec_p (aspec
))
21242 return unify_type_mismatch (explain_p
, parm
, arg
);
21249 /* Unify a pointer to member with a pointer to member function, which
21250 deduces the type of the member as a function type. */
21251 if (TYPE_PTRMEMFUNC_P (arg
))
21253 /* Check top-level cv qualifiers */
21254 if (!check_cv_quals_for_unify (UNIFY_ALLOW_NONE
, arg
, parm
))
21255 return unify_cv_qual_mismatch (explain_p
, parm
, arg
);
21257 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
21258 TYPE_PTRMEMFUNC_OBJECT_TYPE (arg
),
21259 UNIFY_ALLOW_NONE
, explain_p
);
21261 /* Determine the type of the function we are unifying against. */
21262 tree fntype
= static_fn_type (arg
);
21264 return unify (tparms
, targs
, TREE_TYPE (parm
), fntype
, strict
, explain_p
);
21267 if (TREE_CODE (arg
) != OFFSET_TYPE
)
21268 return unify_type_mismatch (explain_p
, parm
, arg
);
21269 RECUR_AND_CHECK_FAILURE (tparms
, targs
, TYPE_OFFSET_BASETYPE (parm
),
21270 TYPE_OFFSET_BASETYPE (arg
),
21271 UNIFY_ALLOW_NONE
, explain_p
);
21272 return unify (tparms
, targs
, TREE_TYPE (parm
), TREE_TYPE (arg
),
21273 strict
, explain_p
);
21276 if (DECL_TEMPLATE_PARM_P (parm
))
21277 return unify (tparms
, targs
, DECL_INITIAL (parm
), arg
, strict
, explain_p
);
21278 if (arg
!= scalar_constant_value (parm
))
21279 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
21280 return unify_success (explain_p
);
21283 case TEMPLATE_DECL
:
21284 /* Matched cases are handled by the ARG == PARM test above. */
21285 return unify_template_argument_mismatch (explain_p
, parm
, arg
);
21288 /* We might get a variable as a non-type template argument in parm if the
21289 corresponding parameter is type-dependent. Make any necessary
21290 adjustments based on whether arg is a reference. */
21291 if (CONSTANT_CLASS_P (arg
))
21292 parm
= fold_non_dependent_expr (parm
);
21293 else if (REFERENCE_REF_P (arg
))
21295 tree sub
= TREE_OPERAND (arg
, 0);
21297 if (TREE_CODE (sub
) == ADDR_EXPR
)
21298 arg
= TREE_OPERAND (sub
, 0);
21300 /* Now use the normal expression code to check whether they match. */
21303 case TYPE_ARGUMENT_PACK
:
21304 case NONTYPE_ARGUMENT_PACK
:
21305 return unify (tparms
, targs
, ARGUMENT_PACK_ARGS (parm
),
21306 ARGUMENT_PACK_ARGS (arg
), strict
, explain_p
);
21309 case DECLTYPE_TYPE
:
21310 case UNDERLYING_TYPE
:
21311 /* Cannot deduce anything from TYPEOF_TYPE, DECLTYPE_TYPE,
21312 or UNDERLYING_TYPE nodes. */
21313 return unify_success (explain_p
);
21316 /* Unification fails if we hit an error node. */
21317 return unify_invalid (explain_p
);
21320 if (REFERENCE_REF_P (parm
))
21322 bool pexp
= PACK_EXPANSION_P (arg
);
21324 arg
= PACK_EXPANSION_PATTERN (arg
);
21325 if (REFERENCE_REF_P (arg
))
21326 arg
= TREE_OPERAND (arg
, 0);
21328 arg
= make_pack_expansion (arg
);
21329 return unify (tparms
, targs
, TREE_OPERAND (parm
, 0), arg
,
21330 strict
, explain_p
);
21335 /* An unresolved overload is a nondeduced context. */
21336 if (is_overloaded_fn (parm
) || type_unknown_p (parm
))
21337 return unify_success (explain_p
);
21338 gcc_assert (EXPR_P (parm
) || TREE_CODE (parm
) == TRAIT_EXPR
);
21340 /* We must be looking at an expression. This can happen with
21344 void foo(S<I>, S<I + 2>);
21346 This is a "nondeduced context":
21350 The nondeduced contexts are:
21352 --A type that is a template-id in which one or more of
21353 the template-arguments is an expression that references
21354 a template-parameter.
21356 In these cases, we assume deduction succeeded, but don't
21357 actually infer any unifications. */
21359 if (!uses_template_parms (parm
)
21360 && !template_args_equal (parm
, arg
))
21361 return unify_expression_unequal (explain_p
, parm
, arg
);
21363 return unify_success (explain_p
);
21366 #undef RECUR_AND_CHECK_FAILURE
21368 /* Note that DECL can be defined in this translation unit, if
21372 mark_definable (tree decl
)
21375 DECL_NOT_REALLY_EXTERN (decl
) = 1;
21376 FOR_EACH_CLONE (clone
, decl
)
21377 DECL_NOT_REALLY_EXTERN (clone
) = 1;
21380 /* Called if RESULT is explicitly instantiated, or is a member of an
21381 explicitly instantiated class. */
21384 mark_decl_instantiated (tree result
, int extern_p
)
21386 SET_DECL_EXPLICIT_INSTANTIATION (result
);
21388 /* If this entity has already been written out, it's too late to
21389 make any modifications. */
21390 if (TREE_ASM_WRITTEN (result
))
21393 /* For anonymous namespace we don't need to do anything. */
21394 if (decl_anon_ns_mem_p (result
))
21396 gcc_assert (!TREE_PUBLIC (result
));
21400 if (TREE_CODE (result
) != FUNCTION_DECL
)
21401 /* The TREE_PUBLIC flag for function declarations will have been
21402 set correctly by tsubst. */
21403 TREE_PUBLIC (result
) = 1;
21405 /* This might have been set by an earlier implicit instantiation. */
21406 DECL_COMDAT (result
) = 0;
21409 DECL_NOT_REALLY_EXTERN (result
) = 0;
21412 mark_definable (result
);
21413 mark_needed (result
);
21414 /* Always make artificials weak. */
21415 if (DECL_ARTIFICIAL (result
) && flag_weak
)
21416 comdat_linkage (result
);
21417 /* For WIN32 we also want to put explicit instantiations in
21418 linkonce sections. */
21419 else if (TREE_PUBLIC (result
))
21420 maybe_make_one_only (result
);
21423 /* If EXTERN_P, then this function will not be emitted -- unless
21424 followed by an explicit instantiation, at which point its linkage
21425 will be adjusted. If !EXTERN_P, then this function will be
21426 emitted here. In neither circumstance do we want
21427 import_export_decl to adjust the linkage. */
21428 DECL_INTERFACE_KNOWN (result
) = 1;
21431 /* Subroutine of more_specialized_fn: check whether TARGS is missing any
21432 important template arguments. If any are missing, we check whether
21433 they're important by using error_mark_node for substituting into any
21434 args that were used for partial ordering (the ones between ARGS and END)
21435 and seeing if it bubbles up. */
21438 check_undeduced_parms (tree targs
, tree args
, tree end
)
21440 bool found
= false;
21442 for (i
= TREE_VEC_LENGTH (targs
) - 1; i
>= 0; --i
)
21443 if (TREE_VEC_ELT (targs
, i
) == NULL_TREE
)
21446 TREE_VEC_ELT (targs
, i
) = error_mark_node
;
21450 tree substed
= tsubst_arg_types (args
, targs
, end
, tf_none
, NULL_TREE
);
21451 if (substed
== error_mark_node
)
21457 /* Given two function templates PAT1 and PAT2, return:
21459 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order].
21460 -1 if PAT2 is more specialized than PAT1.
21461 0 if neither is more specialized.
21463 LEN indicates the number of parameters we should consider
21464 (defaulted parameters should not be considered).
21466 The 1998 std underspecified function template partial ordering, and
21467 DR214 addresses the issue. We take pairs of arguments, one from
21468 each of the templates, and deduce them against each other. One of
21469 the templates will be more specialized if all the *other*
21470 template's arguments deduce against its arguments and at least one
21471 of its arguments *does* *not* deduce against the other template's
21472 corresponding argument. Deduction is done as for class templates.
21473 The arguments used in deduction have reference and top level cv
21474 qualifiers removed. Iff both arguments were originally reference
21475 types *and* deduction succeeds in both directions, an lvalue reference
21476 wins against an rvalue reference and otherwise the template
21477 with the more cv-qualified argument wins for that pairing (if
21478 neither is more cv-qualified, they both are equal). Unlike regular
21479 deduction, after all the arguments have been deduced in this way,
21480 we do *not* verify the deduced template argument values can be
21481 substituted into non-deduced contexts.
21483 The logic can be a bit confusing here, because we look at deduce1 and
21484 targs1 to see if pat2 is at least as specialized, and vice versa; if we
21485 can find template arguments for pat1 to make arg1 look like arg2, that
21486 means that arg2 is at least as specialized as arg1. */
21489 more_specialized_fn (tree pat1
, tree pat2
, int len
)
21491 tree decl1
= DECL_TEMPLATE_RESULT (pat1
);
21492 tree decl2
= DECL_TEMPLATE_RESULT (pat2
);
21493 tree targs1
= make_tree_vec (DECL_NTPARMS (pat1
));
21494 tree targs2
= make_tree_vec (DECL_NTPARMS (pat2
));
21495 tree tparms1
= DECL_INNERMOST_TEMPLATE_PARMS (pat1
);
21496 tree tparms2
= DECL_INNERMOST_TEMPLATE_PARMS (pat2
);
21497 tree args1
= TYPE_ARG_TYPES (TREE_TYPE (decl1
));
21498 tree args2
= TYPE_ARG_TYPES (TREE_TYPE (decl2
));
21499 tree origs1
, origs2
;
21500 bool lose1
= false;
21501 bool lose2
= false;
21503 /* Remove the this parameter from non-static member functions. If
21504 one is a non-static member function and the other is not a static
21505 member function, remove the first parameter from that function
21506 also. This situation occurs for operator functions where we
21507 locate both a member function (with this pointer) and non-member
21508 operator (with explicit first operand). */
21509 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1
))
21511 len
--; /* LEN is the number of significant arguments for DECL1 */
21512 args1
= TREE_CHAIN (args1
);
21513 if (!DECL_STATIC_FUNCTION_P (decl2
))
21514 args2
= TREE_CHAIN (args2
);
21516 else if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2
))
21518 args2
= TREE_CHAIN (args2
);
21519 if (!DECL_STATIC_FUNCTION_P (decl1
))
21522 args1
= TREE_CHAIN (args1
);
21526 /* If only one is a conversion operator, they are unordered. */
21527 if (DECL_CONV_FN_P (decl1
) != DECL_CONV_FN_P (decl2
))
21530 /* Consider the return type for a conversion function */
21531 if (DECL_CONV_FN_P (decl1
))
21533 args1
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl1
)), args1
);
21534 args2
= tree_cons (NULL_TREE
, TREE_TYPE (TREE_TYPE (decl2
)), args2
);
21538 processing_template_decl
++;
21544 /* Stop when an ellipsis is seen. */
21545 && args1
!= NULL_TREE
&& args2
!= NULL_TREE
)
21547 tree arg1
= TREE_VALUE (args1
);
21548 tree arg2
= TREE_VALUE (args2
);
21549 int deduce1
, deduce2
;
21555 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
21556 && TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
21558 /* When both arguments are pack expansions, we need only
21559 unify the patterns themselves. */
21560 arg1
= PACK_EXPANSION_PATTERN (arg1
);
21561 arg2
= PACK_EXPANSION_PATTERN (arg2
);
21563 /* This is the last comparison we need to do. */
21567 /* DR 1847: If a particular P contains no template-parameters that
21568 participate in template argument deduction, that P is not used to
21569 determine the ordering. */
21570 if (!uses_deducible_template_parms (arg1
)
21571 && !uses_deducible_template_parms (arg2
))
21574 if (TREE_CODE (arg1
) == REFERENCE_TYPE
)
21576 ref1
= TYPE_REF_IS_RVALUE (arg1
) + 1;
21577 arg1
= TREE_TYPE (arg1
);
21578 quals1
= cp_type_quals (arg1
);
21581 if (TREE_CODE (arg2
) == REFERENCE_TYPE
)
21583 ref2
= TYPE_REF_IS_RVALUE (arg2
) + 1;
21584 arg2
= TREE_TYPE (arg2
);
21585 quals2
= cp_type_quals (arg2
);
21588 arg1
= TYPE_MAIN_VARIANT (arg1
);
21589 arg2
= TYPE_MAIN_VARIANT (arg2
);
21591 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
)
21593 int i
, len2
= remaining_arguments (args2
);
21594 tree parmvec
= make_tree_vec (1);
21595 tree argvec
= make_tree_vec (len2
);
21598 /* Setup the parameter vector, which contains only ARG1. */
21599 TREE_VEC_ELT (parmvec
, 0) = arg1
;
21601 /* Setup the argument vector, which contains the remaining
21603 for (i
= 0; i
< len2
; i
++, ta
= TREE_CHAIN (ta
))
21604 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
21606 deduce1
= (unify_pack_expansion (tparms1
, targs1
, parmvec
,
21607 argvec
, DEDUCE_EXACT
,
21608 /*subr=*/true, /*explain_p=*/false)
21611 /* We cannot deduce in the other direction, because ARG1 is
21612 a pack expansion but ARG2 is not. */
21615 else if (TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
21617 int i
, len1
= remaining_arguments (args1
);
21618 tree parmvec
= make_tree_vec (1);
21619 tree argvec
= make_tree_vec (len1
);
21622 /* Setup the parameter vector, which contains only ARG1. */
21623 TREE_VEC_ELT (parmvec
, 0) = arg2
;
21625 /* Setup the argument vector, which contains the remaining
21627 for (i
= 0; i
< len1
; i
++, ta
= TREE_CHAIN (ta
))
21628 TREE_VEC_ELT (argvec
, i
) = TREE_VALUE (ta
);
21630 deduce2
= (unify_pack_expansion (tparms2
, targs2
, parmvec
,
21631 argvec
, DEDUCE_EXACT
,
21632 /*subr=*/true, /*explain_p=*/false)
21635 /* We cannot deduce in the other direction, because ARG2 is
21636 a pack expansion but ARG1 is not.*/
21642 /* The normal case, where neither argument is a pack
21644 deduce1
= (unify (tparms1
, targs1
, arg1
, arg2
,
21645 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
21647 deduce2
= (unify (tparms2
, targs2
, arg2
, arg1
,
21648 UNIFY_ALLOW_NONE
, /*explain_p=*/false)
21652 /* If we couldn't deduce arguments for tparms1 to make arg1 match
21653 arg2, then arg2 is not as specialized as arg1. */
21659 /* "If, for a given type, deduction succeeds in both directions
21660 (i.e., the types are identical after the transformations above)
21661 and both P and A were reference types (before being replaced with
21662 the type referred to above):
21663 - if the type from the argument template was an lvalue reference and
21664 the type from the parameter template was not, the argument type is
21665 considered to be more specialized than the other; otherwise,
21666 - if the type from the argument template is more cv-qualified
21667 than the type from the parameter template (as described above),
21668 the argument type is considered to be more specialized than the other;
21670 - neither type is more specialized than the other." */
21672 if (deduce1
&& deduce2
)
21674 if (ref1
&& ref2
&& ref1
!= ref2
)
21681 else if (quals1
!= quals2
&& quals1
>= 0 && quals2
>= 0)
21683 if ((quals1
& quals2
) == quals2
)
21685 if ((quals1
& quals2
) == quals1
)
21690 if (lose1
&& lose2
)
21691 /* We've failed to deduce something in either direction.
21692 These must be unordered. */
21697 if (TREE_CODE (arg1
) == TYPE_PACK_EXPANSION
21698 || TREE_CODE (arg2
) == TYPE_PACK_EXPANSION
)
21699 /* We have already processed all of the arguments in our
21700 handing of the pack expansion type. */
21703 args1
= TREE_CHAIN (args1
);
21704 args2
= TREE_CHAIN (args2
);
21707 /* "In most cases, all template parameters must have values in order for
21708 deduction to succeed, but for partial ordering purposes a template
21709 parameter may remain without a value provided it is not used in the
21710 types being used for partial ordering."
21712 Thus, if we are missing any of the targs1 we need to substitute into
21713 origs1, then pat2 is not as specialized as pat1. This can happen when
21714 there is a nondeduced context. */
21715 if (!lose2
&& check_undeduced_parms (targs1
, origs1
, args1
))
21717 if (!lose1
&& check_undeduced_parms (targs2
, origs2
, args2
))
21720 processing_template_decl
--;
21722 /* If both deductions succeed, the partial ordering selects the more
21723 constrained template. */
21724 if (!lose1
&& !lose2
)
21726 tree c1
= get_constraints (DECL_TEMPLATE_RESULT (pat1
));
21727 tree c2
= get_constraints (DECL_TEMPLATE_RESULT (pat2
));
21728 lose1
= !subsumes_constraints (c1
, c2
);
21729 lose2
= !subsumes_constraints (c2
, c1
);
21732 /* All things being equal, if the next argument is a pack expansion
21733 for one function but not for the other, prefer the
21734 non-variadic function. FIXME this is bogus; see c++/41958. */
21736 && args1
&& TREE_VALUE (args1
)
21737 && args2
&& TREE_VALUE (args2
))
21739 lose1
= TREE_CODE (TREE_VALUE (args1
)) == TYPE_PACK_EXPANSION
;
21740 lose2
= TREE_CODE (TREE_VALUE (args2
)) == TYPE_PACK_EXPANSION
;
21743 if (lose1
== lose2
)
21751 /* Determine which of two partial specializations of TMPL is more
21754 PAT1 is a TREE_LIST whose TREE_VALUE is the TEMPLATE_DECL corresponding
21755 to the first partial specialization. The TREE_PURPOSE is the
21756 innermost set of template parameters for the partial
21757 specialization. PAT2 is similar, but for the second template.
21759 Return 1 if the first partial specialization is more specialized;
21760 -1 if the second is more specialized; 0 if neither is more
21763 See [temp.class.order] for information about determining which of
21764 two templates is more specialized. */
21767 more_specialized_partial_spec (tree tmpl
, tree pat1
, tree pat2
)
21771 bool any_deductions
= false;
21773 tree tmpl1
= TREE_VALUE (pat1
);
21774 tree tmpl2
= TREE_VALUE (pat2
);
21775 tree specargs1
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl1
)));
21776 tree specargs2
= TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (tmpl2
)));
21778 /* Just like what happens for functions, if we are ordering between
21779 different template specializations, we may encounter dependent
21780 types in the arguments, and we need our dependency check functions
21781 to behave correctly. */
21782 ++processing_template_decl
;
21783 targs
= get_partial_spec_bindings (tmpl
, tmpl1
, specargs2
);
21787 any_deductions
= true;
21790 targs
= get_partial_spec_bindings (tmpl
, tmpl2
, specargs1
);
21794 any_deductions
= true;
21796 --processing_template_decl
;
21798 /* If both deductions succeed, the partial ordering selects the more
21799 constrained template. */
21800 if (!winner
&& any_deductions
)
21801 return more_constrained (tmpl1
, tmpl2
);
21803 /* In the case of a tie where at least one of the templates
21804 has a parameter pack at the end, the template with the most
21805 non-packed parameters wins. */
21808 && (template_args_variadic_p (TREE_PURPOSE (pat1
))
21809 || template_args_variadic_p (TREE_PURPOSE (pat2
))))
21811 tree args1
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat1
));
21812 tree args2
= INNERMOST_TEMPLATE_ARGS (TREE_PURPOSE (pat2
));
21813 int len1
= TREE_VEC_LENGTH (args1
);
21814 int len2
= TREE_VEC_LENGTH (args2
);
21816 /* We don't count the pack expansion at the end. */
21817 if (template_args_variadic_p (TREE_PURPOSE (pat1
)))
21819 if (template_args_variadic_p (TREE_PURPOSE (pat2
)))
21824 else if (len1
< len2
)
21831 /* Return the template arguments that will produce the function signature
21832 DECL from the function template FN, with the explicit template
21833 arguments EXPLICIT_ARGS. If CHECK_RETTYPE is true, the return type must
21834 also match. Return NULL_TREE if no satisfactory arguments could be
21838 get_bindings (tree fn
, tree decl
, tree explicit_args
, bool check_rettype
)
21840 int ntparms
= DECL_NTPARMS (fn
);
21841 tree targs
= make_tree_vec (ntparms
);
21842 tree decl_type
= TREE_TYPE (decl
);
21843 tree decl_arg_types
;
21845 unsigned int nargs
, ix
;
21848 gcc_assert (decl
!= DECL_TEMPLATE_RESULT (fn
));
21850 /* Never do unification on the 'this' parameter. */
21851 decl_arg_types
= skip_artificial_parms_for (decl
,
21852 TYPE_ARG_TYPES (decl_type
));
21854 nargs
= list_length (decl_arg_types
);
21855 args
= XALLOCAVEC (tree
, nargs
);
21856 for (arg
= decl_arg_types
, ix
= 0;
21857 arg
!= NULL_TREE
&& arg
!= void_list_node
;
21858 arg
= TREE_CHAIN (arg
), ++ix
)
21859 args
[ix
] = TREE_VALUE (arg
);
21861 if (fn_type_unification (fn
, explicit_args
, targs
,
21863 (check_rettype
|| DECL_CONV_FN_P (fn
)
21864 ? TREE_TYPE (decl_type
) : NULL_TREE
),
21865 DEDUCE_EXACT
, LOOKUP_NORMAL
, /*explain_p=*/false,
21867 == error_mark_node
)
21873 /* Return the innermost template arguments that, when applied to a partial
21874 specialization SPEC_TMPL of TMPL, yield the ARGS.
21876 For example, suppose we have:
21878 template <class T, class U> struct S {};
21879 template <class T> struct S<T*, int> {};
21881 Then, suppose we want to get `S<double*, int>'. SPEC_TMPL will be the
21882 partial specialization and the ARGS will be {double*, int}. The resulting
21883 vector will be {double}, indicating that `T' is bound to `double'. */
21886 get_partial_spec_bindings (tree tmpl
, tree spec_tmpl
, tree args
)
21888 tree tparms
= DECL_INNERMOST_TEMPLATE_PARMS (spec_tmpl
);
21890 = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (spec_tmpl
)));
21891 int i
, ntparms
= TREE_VEC_LENGTH (tparms
);
21893 tree innermost_deduced_args
;
21895 innermost_deduced_args
= make_tree_vec (ntparms
);
21896 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
21898 deduced_args
= copy_node (args
);
21899 SET_TMPL_ARGS_LEVEL (deduced_args
,
21900 TMPL_ARGS_DEPTH (deduced_args
),
21901 innermost_deduced_args
);
21904 deduced_args
= innermost_deduced_args
;
21906 bool tried_array_deduction
= (cxx_dialect
< cxx17
);
21908 if (unify (tparms
, deduced_args
,
21909 INNERMOST_TEMPLATE_ARGS (spec_args
),
21910 INNERMOST_TEMPLATE_ARGS (args
),
21911 UNIFY_ALLOW_NONE
, /*explain_p=*/false))
21914 for (i
= 0; i
< ntparms
; ++i
)
21915 if (! TREE_VEC_ELT (innermost_deduced_args
, i
))
21917 if (!tried_array_deduction
)
21919 try_array_deduction (tparms
, innermost_deduced_args
,
21920 INNERMOST_TEMPLATE_ARGS (spec_args
));
21921 tried_array_deduction
= true;
21922 if (TREE_VEC_ELT (innermost_deduced_args
, i
))
21928 tree tinst
= build_tree_list (spec_tmpl
, deduced_args
);
21929 if (!push_tinst_level (tinst
))
21931 excessive_deduction_depth
= true;
21935 /* Verify that nondeduced template arguments agree with the type
21936 obtained from argument deduction.
21940 struct A { typedef int X; };
21941 template <class T, class U> struct C {};
21942 template <class T> struct C<T, typename T::X> {};
21944 Then with the instantiation `C<A, int>', we can deduce that
21945 `T' is `A' but unify () does not check whether `typename T::X'
21947 spec_args
= tsubst (spec_args
, deduced_args
, tf_none
, NULL_TREE
);
21949 if (spec_args
!= error_mark_node
)
21950 spec_args
= coerce_template_parms (DECL_INNERMOST_TEMPLATE_PARMS (tmpl
),
21951 INNERMOST_TEMPLATE_ARGS (spec_args
),
21952 tmpl
, tf_none
, false, false);
21954 pop_tinst_level ();
21956 if (spec_args
== error_mark_node
21957 /* We only need to check the innermost arguments; the other
21958 arguments will always agree. */
21959 || !comp_template_args_porder (INNERMOST_TEMPLATE_ARGS (spec_args
),
21960 INNERMOST_TEMPLATE_ARGS (args
)))
21963 /* Now that we have bindings for all of the template arguments,
21964 ensure that the arguments deduced for the template template
21965 parameters have compatible template parameter lists. See the use
21966 of template_template_parm_bindings_ok_p in fn_type_unification
21967 for more information. */
21968 if (!template_template_parm_bindings_ok_p (tparms
, deduced_args
))
21971 return deduced_args
;
21974 // Compare two function templates T1 and T2 by deducing bindings
21975 // from one against the other. If both deductions succeed, compare
21976 // constraints to see which is more constrained.
21978 more_specialized_inst (tree t1
, tree t2
)
21983 if (get_bindings (t1
, DECL_TEMPLATE_RESULT (t2
), NULL_TREE
, true))
21989 if (get_bindings (t2
, DECL_TEMPLATE_RESULT (t1
), NULL_TREE
, true))
21995 // If both deductions succeed, then one may be more constrained.
21996 if (count
== 2 && fate
== 0)
21997 fate
= more_constrained (t1
, t2
);
22002 /* TEMPLATES is a TREE_LIST. Each TREE_VALUE is a TEMPLATE_DECL.
22003 Return the TREE_LIST node with the most specialized template, if
22004 any. If there is no most specialized template, the error_mark_node
22007 Note that this function does not look at, or modify, the
22008 TREE_PURPOSE or TREE_TYPE of any of the nodes. Since the node
22009 returned is one of the elements of INSTANTIATIONS, callers may
22010 store information in the TREE_PURPOSE or TREE_TYPE of the nodes,
22011 and retrieve it from the value returned. */
22014 most_specialized_instantiation (tree templates
)
22018 ++processing_template_decl
;
22021 for (fn
= TREE_CHAIN (templates
); fn
; fn
= TREE_CHAIN (fn
))
22023 gcc_assert (TREE_VALUE (champ
) != TREE_VALUE (fn
));
22024 int fate
= more_specialized_inst (TREE_VALUE (champ
), TREE_VALUE (fn
));
22029 /* Equally specialized, move to next function. If there
22030 is no next function, nothing's most specialized. */
22031 fn
= TREE_CHAIN (fn
);
22039 /* Now verify that champ is better than everything earlier in the
22040 instantiation list. */
22041 for (fn
= templates
; fn
!= champ
; fn
= TREE_CHAIN (fn
)) {
22042 if (more_specialized_inst (TREE_VALUE (champ
), TREE_VALUE (fn
)) != 1)
22049 processing_template_decl
--;
22052 return error_mark_node
;
22057 /* If DECL is a specialization of some template, return the most
22058 general such template. Otherwise, returns NULL_TREE.
22060 For example, given:
22062 template <class T> struct S { template <class U> void f(U); };
22064 if TMPL is `template <class U> void S<int>::f(U)' this will return
22065 the full template. This function will not trace past partial
22066 specializations, however. For example, given in addition:
22068 template <class T> struct S<T*> { template <class U> void f(U); };
22070 if TMPL is `template <class U> void S<int*>::f(U)' this will return
22071 `template <class T> template <class U> S<T*>::f(U)'. */
22074 most_general_template (tree decl
)
22076 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
22078 if (tree tinfo
= get_template_info (decl
))
22079 decl
= TI_TEMPLATE (tinfo
);
22080 /* The TI_TEMPLATE can be an IDENTIFIER_NODE for a
22081 template friend, or a FIELD_DECL for a capture pack. */
22082 if (TREE_CODE (decl
) != TEMPLATE_DECL
)
22086 /* Look for more and more general templates. */
22087 while (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
22089 /* The DECL_TI_TEMPLATE can be an IDENTIFIER_NODE in some cases.
22090 (See cp-tree.h for details.) */
22091 if (TREE_CODE (DECL_TI_TEMPLATE (decl
)) != TEMPLATE_DECL
)
22094 if (CLASS_TYPE_P (TREE_TYPE (decl
))
22095 && !TYPE_DECL_ALIAS_P (TYPE_NAME (TREE_TYPE (decl
)))
22096 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl
)))
22099 /* Stop if we run into an explicitly specialized class template. */
22100 if (!DECL_NAMESPACE_SCOPE_P (decl
)
22101 && DECL_CONTEXT (decl
)
22102 && CLASSTYPE_TEMPLATE_SPECIALIZATION (DECL_CONTEXT (decl
)))
22105 decl
= DECL_TI_TEMPLATE (decl
);
22111 /* Return the most specialized of the template partial specializations
22112 which can produce TARGET, a specialization of some class or variable
22113 template. The value returned is actually a TREE_LIST; the TREE_VALUE is
22114 a TEMPLATE_DECL node corresponding to the partial specialization, while
22115 the TREE_PURPOSE is the set of template arguments that must be
22116 substituted into the template pattern in order to generate TARGET.
22118 If the choice of partial specialization is ambiguous, a diagnostic
22119 is issued, and the error_mark_node is returned. If there are no
22120 partial specializations matching TARGET, then NULL_TREE is
22121 returned, indicating that the primary template should be used. */
22124 most_specialized_partial_spec (tree target
, tsubst_flags_t complain
)
22126 tree list
= NULL_TREE
;
22131 tree outer_args
= NULL_TREE
;
22134 if (TYPE_P (target
))
22136 tree tinfo
= CLASSTYPE_TEMPLATE_INFO (target
);
22137 tmpl
= TI_TEMPLATE (tinfo
);
22138 args
= TI_ARGS (tinfo
);
22140 else if (TREE_CODE (target
) == TEMPLATE_ID_EXPR
)
22142 tmpl
= TREE_OPERAND (target
, 0);
22143 args
= TREE_OPERAND (target
, 1);
22145 else if (VAR_P (target
))
22147 tree tinfo
= DECL_TEMPLATE_INFO (target
);
22148 tmpl
= TI_TEMPLATE (tinfo
);
22149 args
= TI_ARGS (tinfo
);
22152 gcc_unreachable ();
22154 tree main_tmpl
= most_general_template (tmpl
);
22156 /* For determining which partial specialization to use, only the
22157 innermost args are interesting. */
22158 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
))
22160 outer_args
= strip_innermost_template_args (args
, 1);
22161 args
= INNERMOST_TEMPLATE_ARGS (args
);
22164 for (t
= DECL_TEMPLATE_SPECIALIZATIONS (main_tmpl
); t
; t
= TREE_CHAIN (t
))
22167 tree spec_tmpl
= TREE_VALUE (t
);
22171 /* Substitute in the template args from the enclosing class. */
22172 ++processing_template_decl
;
22173 spec_tmpl
= tsubst (spec_tmpl
, outer_args
, tf_none
, NULL_TREE
);
22174 --processing_template_decl
;
22177 if (spec_tmpl
== error_mark_node
)
22178 return error_mark_node
;
22180 spec_args
= get_partial_spec_bindings (tmpl
, spec_tmpl
, args
);
22184 spec_args
= add_to_template_args (outer_args
, spec_args
);
22186 /* Keep the candidate only if the constraints are satisfied,
22187 or if we're not compiling with concepts. */
22189 || constraints_satisfied_p (spec_tmpl
, spec_args
))
22191 list
= tree_cons (spec_args
, TREE_VALUE (t
), list
);
22192 TREE_TYPE (list
) = TREE_TYPE (t
);
22200 ambiguous_p
= false;
22203 t
= TREE_CHAIN (t
);
22204 for (; t
; t
= TREE_CHAIN (t
))
22206 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
22213 t
= TREE_CHAIN (t
);
22216 ambiguous_p
= true;
22225 for (t
= list
; t
&& t
!= champ
; t
= TREE_CHAIN (t
))
22227 fate
= more_specialized_partial_spec (tmpl
, champ
, t
);
22230 ambiguous_p
= true;
22238 char *spaces
= NULL
;
22239 if (!(complain
& tf_error
))
22240 return error_mark_node
;
22241 if (TYPE_P (target
))
22242 error ("ambiguous template instantiation for %q#T", target
);
22244 error ("ambiguous template instantiation for %q#D", target
);
22245 str
= ngettext ("candidate is:", "candidates are:", list_length (list
));
22246 for (t
= list
; t
; t
= TREE_CHAIN (t
))
22248 tree subst
= build_tree_list (TREE_VALUE (t
), TREE_PURPOSE (t
));
22249 inform (DECL_SOURCE_LOCATION (TREE_VALUE (t
)),
22250 "%s %#qS", spaces
? spaces
: str
, subst
);
22251 spaces
= spaces
? spaces
: get_spaces (str
);
22254 return error_mark_node
;
22260 /* Explicitly instantiate DECL. */
22263 do_decl_instantiation (tree decl
, tree storage
)
22265 tree result
= NULL_TREE
;
22268 if (!decl
|| decl
== error_mark_node
)
22269 /* An error occurred, for which grokdeclarator has already issued
22270 an appropriate message. */
22272 else if (! DECL_LANG_SPECIFIC (decl
))
22274 error ("explicit instantiation of non-template %q#D", decl
);
22278 bool var_templ
= (DECL_TEMPLATE_INFO (decl
)
22279 && variable_template_p (DECL_TI_TEMPLATE (decl
)));
22281 if (VAR_P (decl
) && !var_templ
)
22283 /* There is an asymmetry here in the way VAR_DECLs and
22284 FUNCTION_DECLs are handled by grokdeclarator. In the case of
22285 the latter, the DECL we get back will be marked as a
22286 template instantiation, and the appropriate
22287 DECL_TEMPLATE_INFO will be set up. This does not happen for
22288 VAR_DECLs so we do the lookup here. Probably, grokdeclarator
22289 should handle VAR_DECLs as it currently handles
22291 if (!DECL_CLASS_SCOPE_P (decl
))
22293 error ("%qD is not a static data member of a class template", decl
);
22296 result
= lookup_field (DECL_CONTEXT (decl
), DECL_NAME (decl
), 0, false);
22297 if (!result
|| !VAR_P (result
))
22299 error ("no matching template for %qD found", decl
);
22302 if (!same_type_p (TREE_TYPE (result
), TREE_TYPE (decl
)))
22304 error ("type %qT for explicit instantiation %qD does not match "
22305 "declared type %qT", TREE_TYPE (result
), decl
,
22310 else if (TREE_CODE (decl
) != FUNCTION_DECL
&& !var_templ
)
22312 error ("explicit instantiation of %q#D", decl
);
22318 /* Check for various error cases. Note that if the explicit
22319 instantiation is valid the RESULT will currently be marked as an
22320 *implicit* instantiation; DECL_EXPLICIT_INSTANTIATION is not set
22321 until we get here. */
22323 if (DECL_TEMPLATE_SPECIALIZATION (result
))
22325 /* DR 259 [temp.spec].
22327 Both an explicit instantiation and a declaration of an explicit
22328 specialization shall not appear in a program unless the explicit
22329 instantiation follows a declaration of the explicit specialization.
22331 For a given set of template parameters, if an explicit
22332 instantiation of a template appears after a declaration of an
22333 explicit specialization for that template, the explicit
22334 instantiation has no effect. */
22337 else if (DECL_EXPLICIT_INSTANTIATION (result
))
22341 No program shall explicitly instantiate any template more
22344 We check DECL_NOT_REALLY_EXTERN so as not to complain when
22345 the first instantiation was `extern' and the second is not,
22346 and EXTERN_P for the opposite case. */
22347 if (DECL_NOT_REALLY_EXTERN (result
) && !extern_p
)
22348 permerror (input_location
, "duplicate explicit instantiation of %q#D", result
);
22349 /* If an "extern" explicit instantiation follows an ordinary
22350 explicit instantiation, the template is instantiated. */
22354 else if (!DECL_IMPLICIT_INSTANTIATION (result
))
22356 error ("no matching template for %qD found", result
);
22359 else if (!DECL_TEMPLATE_INFO (result
))
22361 permerror (input_location
, "explicit instantiation of non-template %q#D", result
);
22365 if (storage
== NULL_TREE
)
22367 else if (storage
== ridpointers
[(int) RID_EXTERN
])
22369 if (!in_system_header_at (input_location
) && (cxx_dialect
== cxx98
))
22370 pedwarn (input_location
, OPT_Wpedantic
,
22371 "ISO C++ 1998 forbids the use of %<extern%> on explicit "
22376 error ("storage class %qD applied to template instantiation", storage
);
22378 check_explicit_instantiation_namespace (result
);
22379 mark_decl_instantiated (result
, extern_p
);
22381 instantiate_decl (result
, /*defer_ok=*/true,
22382 /*expl_inst_class_mem_p=*/false);
22386 mark_class_instantiated (tree t
, int extern_p
)
22388 SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t
);
22389 SET_CLASSTYPE_INTERFACE_KNOWN (t
);
22390 CLASSTYPE_INTERFACE_ONLY (t
) = extern_p
;
22391 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = extern_p
;
22394 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
22395 rest_of_type_compilation (t
, 1);
22399 /* Called from do_type_instantiation through binding_table_foreach to
22400 do recursive instantiation for the type bound in ENTRY. */
22402 bt_instantiate_type_proc (binding_entry entry
, void *data
)
22404 tree storage
= *(tree
*) data
;
22406 if (MAYBE_CLASS_TYPE_P (entry
->type
)
22407 && !uses_template_parms (CLASSTYPE_TI_ARGS (entry
->type
)))
22408 do_type_instantiation (TYPE_MAIN_DECL (entry
->type
), storage
, 0);
22411 /* Perform an explicit instantiation of template class T. STORAGE, if
22412 non-null, is the RID for extern, inline or static. COMPLAIN is
22413 nonzero if this is called from the parser, zero if called recursively,
22414 since the standard is unclear (as detailed below). */
22417 do_type_instantiation (tree t
, tree storage
, tsubst_flags_t complain
)
22422 int previous_instantiation_extern_p
= 0;
22424 if (TREE_CODE (t
) == TYPE_DECL
)
22427 if (! CLASS_TYPE_P (t
) || ! CLASSTYPE_TEMPLATE_INFO (t
))
22430 (TYPE_TEMPLATE_INFO (t
)) ? TYPE_TI_TEMPLATE (t
) : NULL
;
22432 error ("explicit instantiation of non-class template %qD", tmpl
);
22434 error ("explicit instantiation of non-template type %qT", t
);
22440 if (!COMPLETE_TYPE_P (t
))
22442 if (complain
& tf_error
)
22443 error ("explicit instantiation of %q#T before definition of template",
22448 if (storage
!= NULL_TREE
)
22450 if (!in_system_header_at (input_location
))
22452 if (storage
== ridpointers
[(int) RID_EXTERN
])
22454 if (cxx_dialect
== cxx98
)
22455 pedwarn (input_location
, OPT_Wpedantic
,
22456 "ISO C++ 1998 forbids the use of %<extern%> on "
22457 "explicit instantiations");
22460 pedwarn (input_location
, OPT_Wpedantic
,
22461 "ISO C++ forbids the use of %qE"
22462 " on explicit instantiations", storage
);
22465 if (storage
== ridpointers
[(int) RID_INLINE
])
22467 else if (storage
== ridpointers
[(int) RID_EXTERN
])
22469 else if (storage
== ridpointers
[(int) RID_STATIC
])
22473 error ("storage class %qD applied to template instantiation",
22479 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
22481 /* DR 259 [temp.spec].
22483 Both an explicit instantiation and a declaration of an explicit
22484 specialization shall not appear in a program unless the explicit
22485 instantiation follows a declaration of the explicit specialization.
22487 For a given set of template parameters, if an explicit
22488 instantiation of a template appears after a declaration of an
22489 explicit specialization for that template, the explicit
22490 instantiation has no effect. */
22493 else if (CLASSTYPE_EXPLICIT_INSTANTIATION (t
))
22497 No program shall explicitly instantiate any template more
22500 If PREVIOUS_INSTANTIATION_EXTERN_P, then the first explicit
22501 instantiation was `extern'. If EXTERN_P then the second is.
22502 These cases are OK. */
22503 previous_instantiation_extern_p
= CLASSTYPE_INTERFACE_ONLY (t
);
22505 if (!previous_instantiation_extern_p
&& !extern_p
22506 && (complain
& tf_error
))
22507 permerror (input_location
, "duplicate explicit instantiation of %q#T", t
);
22509 /* If we've already instantiated the template, just return now. */
22510 if (!CLASSTYPE_INTERFACE_ONLY (t
))
22514 check_explicit_instantiation_namespace (TYPE_NAME (t
));
22515 mark_class_instantiated (t
, extern_p
);
22520 /* In contrast to implicit instantiation, where only the
22521 declarations, and not the definitions, of members are
22522 instantiated, we have here:
22526 The explicit instantiation of a class template specialization
22527 implies the instantiation of all of its members not
22528 previously explicitly specialized in the translation unit
22529 containing the explicit instantiation.
22531 Of course, we can't instantiate member template classes, since we
22532 don't have any arguments for them. Note that the standard is
22533 unclear on whether the instantiation of the members are
22534 *explicit* instantiations or not. However, the most natural
22535 interpretation is that it should be an explicit
22537 for (tree fld
= TYPE_FIELDS (t
); fld
; fld
= DECL_CHAIN (fld
))
22539 || (TREE_CODE (fld
) == FUNCTION_DECL
22541 && user_provided_p (fld
)))
22542 && DECL_TEMPLATE_INSTANTIATION (fld
))
22544 mark_decl_instantiated (fld
, extern_p
);
22546 instantiate_decl (fld
, /*defer_ok=*/true,
22547 /*expl_inst_class_mem_p=*/true);
22550 if (CLASSTYPE_NESTED_UTDS (t
))
22551 binding_table_foreach (CLASSTYPE_NESTED_UTDS (t
),
22552 bt_instantiate_type_proc
, &storage
);
22555 /* Given a function DECL, which is a specialization of TMPL, modify
22556 DECL to be a re-instantiation of TMPL with the same template
22557 arguments. TMPL should be the template into which tsubst'ing
22558 should occur for DECL, not the most general template.
22560 One reason for doing this is a scenario like this:
22563 void f(const T&, int i);
22565 void g() { f(3, 7); }
22568 void f(const T& t, const int i) { }
22570 Note that when the template is first instantiated, with
22571 instantiate_template, the resulting DECL will have no name for the
22572 first parameter, and the wrong type for the second. So, when we go
22573 to instantiate the DECL, we regenerate it. */
22576 regenerate_decl_from_template (tree decl
, tree tmpl
, tree args
)
22578 /* The arguments used to instantiate DECL, from the most general
22582 code_pattern
= DECL_TEMPLATE_RESULT (tmpl
);
22584 /* Make sure that we can see identifiers, and compute access
22586 push_access_scope (decl
);
22588 if (TREE_CODE (decl
) == FUNCTION_DECL
)
22596 args_depth
= TMPL_ARGS_DEPTH (args
);
22597 parms_depth
= TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl
));
22598 if (args_depth
> parms_depth
)
22599 args
= get_innermost_template_args (args
, parms_depth
);
22601 specs
= tsubst_exception_specification (TREE_TYPE (code_pattern
),
22602 args
, tf_error
, NULL_TREE
,
22603 /*defer_ok*/false);
22604 if (specs
&& specs
!= error_mark_node
)
22605 TREE_TYPE (decl
) = build_exception_variant (TREE_TYPE (decl
),
22608 /* Merge parameter declarations. */
22609 decl_parm
= skip_artificial_parms_for (decl
,
22610 DECL_ARGUMENTS (decl
));
22612 = skip_artificial_parms_for (code_pattern
,
22613 DECL_ARGUMENTS (code_pattern
));
22614 while (decl_parm
&& !DECL_PACK_P (pattern_parm
))
22619 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
22620 DECL_NAME (decl_parm
) = DECL_NAME (pattern_parm
);
22621 parm_type
= tsubst (TREE_TYPE (pattern_parm
), args
, tf_error
,
22623 parm_type
= type_decays_to (parm_type
);
22624 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
22625 TREE_TYPE (decl_parm
) = parm_type
;
22626 attributes
= DECL_ATTRIBUTES (pattern_parm
);
22627 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
22629 DECL_ATTRIBUTES (decl_parm
) = attributes
;
22630 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
22632 decl_parm
= DECL_CHAIN (decl_parm
);
22633 pattern_parm
= DECL_CHAIN (pattern_parm
);
22635 /* Merge any parameters that match with the function parameter
22637 if (pattern_parm
&& DECL_PACK_P (pattern_parm
))
22640 tree expanded_types
;
22641 /* Expand the TYPE_PACK_EXPANSION that provides the types for
22642 the parameters in this function parameter pack. */
22643 expanded_types
= tsubst_pack_expansion (TREE_TYPE (pattern_parm
),
22644 args
, tf_error
, NULL_TREE
);
22645 len
= TREE_VEC_LENGTH (expanded_types
);
22646 for (i
= 0; i
< len
; i
++)
22651 if (DECL_NAME (decl_parm
) != DECL_NAME (pattern_parm
))
22652 /* Rename the parameter to include the index. */
22653 DECL_NAME (decl_parm
) =
22654 make_ith_pack_parameter_name (DECL_NAME (pattern_parm
), i
);
22655 parm_type
= TREE_VEC_ELT (expanded_types
, i
);
22656 parm_type
= type_decays_to (parm_type
);
22657 if (!same_type_p (TREE_TYPE (decl_parm
), parm_type
))
22658 TREE_TYPE (decl_parm
) = parm_type
;
22659 attributes
= DECL_ATTRIBUTES (pattern_parm
);
22660 if (DECL_ATTRIBUTES (decl_parm
) != attributes
)
22662 DECL_ATTRIBUTES (decl_parm
) = attributes
;
22663 cplus_decl_attributes (&decl_parm
, attributes
, /*flags=*/0);
22665 decl_parm
= DECL_CHAIN (decl_parm
);
22668 /* Merge additional specifiers from the CODE_PATTERN. */
22669 if (DECL_DECLARED_INLINE_P (code_pattern
)
22670 && !DECL_DECLARED_INLINE_P (decl
))
22671 DECL_DECLARED_INLINE_P (decl
) = 1;
22673 else if (VAR_P (decl
))
22675 start_lambda_scope (decl
);
22676 DECL_INITIAL (decl
) =
22677 tsubst_expr (DECL_INITIAL (code_pattern
), args
,
22678 tf_error
, DECL_TI_TEMPLATE (decl
),
22679 /*integral_constant_expression_p=*/false);
22680 finish_lambda_scope ();
22681 if (VAR_HAD_UNKNOWN_BOUND (decl
))
22682 TREE_TYPE (decl
) = tsubst (TREE_TYPE (code_pattern
), args
,
22683 tf_error
, DECL_TI_TEMPLATE (decl
));
22686 gcc_unreachable ();
22688 pop_access_scope (decl
);
22691 /* Return the TEMPLATE_DECL into which DECL_TI_ARGS(DECL) should be
22692 substituted to get DECL. */
22695 template_for_substitution (tree decl
)
22697 tree tmpl
= DECL_TI_TEMPLATE (decl
);
22699 /* Set TMPL to the template whose DECL_TEMPLATE_RESULT is the pattern
22700 for the instantiation. This is not always the most general
22701 template. Consider, for example:
22704 struct S { template <class U> void f();
22705 template <> void f<int>(); };
22707 and an instantiation of S<double>::f<int>. We want TD to be the
22708 specialization S<T>::f<int>, not the more general S<T>::f<U>. */
22709 while (/* An instantiation cannot have a definition, so we need a
22710 more general template. */
22711 DECL_TEMPLATE_INSTANTIATION (tmpl
)
22712 /* We must also deal with friend templates. Given:
22714 template <class T> struct S {
22715 template <class U> friend void f() {};
22718 S<int>::f<U> say, is not an instantiation of S<T>::f<U>,
22719 so far as the language is concerned, but that's still
22720 where we get the pattern for the instantiation from. On
22721 other hand, if the definition comes outside the class, say:
22723 template <class T> struct S {
22724 template <class U> friend void f();
22726 template <class U> friend void f() {}
22728 we don't need to look any further. That's what the check for
22729 DECL_INITIAL is for. */
22730 || (TREE_CODE (decl
) == FUNCTION_DECL
22731 && DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (tmpl
)
22732 && !DECL_INITIAL (DECL_TEMPLATE_RESULT (tmpl
))))
22734 /* The present template, TD, should not be a definition. If it
22735 were a definition, we should be using it! Note that we
22736 cannot restructure the loop to just keep going until we find
22737 a template with a definition, since that might go too far if
22738 a specialization was declared, but not defined. */
22740 /* Fetch the more general template. */
22741 tmpl
= DECL_TI_TEMPLATE (tmpl
);
22747 /* Returns true if we need to instantiate this template instance even if we
22748 know we aren't going to emit it. */
22751 always_instantiate_p (tree decl
)
22753 /* We always instantiate inline functions so that we can inline them. An
22754 explicit instantiation declaration prohibits implicit instantiation of
22755 non-inline functions. With high levels of optimization, we would
22756 normally inline non-inline functions -- but we're not allowed to do
22757 that for "extern template" functions. Therefore, we check
22758 DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
22759 return ((TREE_CODE (decl
) == FUNCTION_DECL
22760 && (DECL_DECLARED_INLINE_P (decl
)
22761 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
)))))
22762 /* And we need to instantiate static data members so that
22763 their initializers are available in integral constant
22766 && decl_maybe_constant_var_p (decl
)));
22769 /* If FN has a noexcept-specifier that hasn't been instantiated yet,
22770 instantiate it now, modifying TREE_TYPE (fn). Returns false on
22771 error, true otherwise. */
22774 maybe_instantiate_noexcept (tree fn
, tsubst_flags_t complain
)
22776 tree fntype
, spec
, noex
, clone
;
22778 /* Don't instantiate a noexcept-specification from template context. */
22779 if (processing_template_decl
)
22782 if (DECL_CLONED_FUNCTION_P (fn
))
22783 fn
= DECL_CLONED_FUNCTION (fn
);
22784 fntype
= TREE_TYPE (fn
);
22785 spec
= TYPE_RAISES_EXCEPTIONS (fntype
);
22787 if (!spec
|| !TREE_PURPOSE (spec
))
22790 noex
= TREE_PURPOSE (spec
);
22792 if (TREE_CODE (noex
) == DEFERRED_NOEXCEPT
)
22794 static hash_set
<tree
>* fns
= new hash_set
<tree
>;
22795 bool added
= false;
22796 if (DEFERRED_NOEXCEPT_PATTERN (noex
) == NULL_TREE
)
22797 spec
= get_defaulted_eh_spec (fn
, complain
);
22798 else if (!(added
= !fns
->add (fn
)))
22800 /* If hash_set::add returns true, the element was already there. */
22801 location_t loc
= EXPR_LOC_OR_LOC (DEFERRED_NOEXCEPT_PATTERN (noex
),
22802 DECL_SOURCE_LOCATION (fn
));
22804 "exception specification of %qD depends on itself",
22806 spec
= noexcept_false_spec
;
22808 else if (push_tinst_level (fn
))
22810 push_access_scope (fn
);
22811 push_deferring_access_checks (dk_no_deferred
);
22812 input_location
= DECL_SOURCE_LOCATION (fn
);
22813 noex
= tsubst_copy_and_build (DEFERRED_NOEXCEPT_PATTERN (noex
),
22814 DEFERRED_NOEXCEPT_ARGS (noex
),
22815 tf_warning_or_error
, fn
,
22816 /*function_p=*/false,
22817 /*integral_constant_expression_p=*/true);
22818 pop_deferring_access_checks ();
22819 pop_access_scope (fn
);
22820 pop_tinst_level ();
22821 spec
= build_noexcept_spec (noex
, tf_warning_or_error
);
22822 if (spec
== error_mark_node
)
22823 spec
= noexcept_false_spec
;
22826 spec
= noexcept_false_spec
;
22831 if (spec
== error_mark_node
)
22834 TREE_TYPE (fn
) = build_exception_variant (fntype
, spec
);
22837 FOR_EACH_CLONE (clone
, fn
)
22839 if (TREE_TYPE (clone
) == fntype
)
22840 TREE_TYPE (clone
) = TREE_TYPE (fn
);
22842 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
), spec
);
22848 /* We're starting to process the function INST, an instantiation of PATTERN;
22849 add their parameters to local_specializations. */
22852 register_parameter_specializations (tree pattern
, tree inst
)
22854 tree tmpl_parm
= DECL_ARGUMENTS (pattern
);
22855 tree spec_parm
= DECL_ARGUMENTS (inst
);
22856 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (inst
))
22858 register_local_specialization (spec_parm
, tmpl_parm
);
22859 spec_parm
= skip_artificial_parms_for (inst
, spec_parm
);
22860 tmpl_parm
= skip_artificial_parms_for (pattern
, tmpl_parm
);
22862 for (; tmpl_parm
; tmpl_parm
= DECL_CHAIN (tmpl_parm
))
22864 if (!DECL_PACK_P (tmpl_parm
))
22866 register_local_specialization (spec_parm
, tmpl_parm
);
22867 spec_parm
= DECL_CHAIN (spec_parm
);
22871 /* Register the (value) argument pack as a specialization of
22872 TMPL_PARM, then move on. */
22873 tree argpack
= extract_fnparm_pack (tmpl_parm
, &spec_parm
);
22874 register_local_specialization (argpack
, tmpl_parm
);
22877 gcc_assert (!spec_parm
);
22880 /* Produce the definition of D, a _DECL generated from a template. If
22881 DEFER_OK is true, then we don't have to actually do the
22882 instantiation now; we just have to do it sometime. Normally it is
22883 an error if this is an explicit instantiation but D is undefined.
22884 EXPL_INST_CLASS_MEM_P is true iff D is a member of an explicitly
22885 instantiated class template. */
22888 instantiate_decl (tree d
, bool defer_ok
, bool expl_inst_class_mem_p
)
22890 tree tmpl
= DECL_TI_TEMPLATE (d
);
22897 bool pattern_defined
;
22898 location_t saved_loc
= input_location
;
22899 int saved_unevaluated_operand
= cp_unevaluated_operand
;
22900 int saved_inhibit_evaluation_warnings
= c_inhibit_evaluation_warnings
;
22904 /* This function should only be used to instantiate templates for
22905 functions and static member variables. */
22906 gcc_assert (VAR_OR_FUNCTION_DECL_P (d
));
22908 /* A concept is never instantiated. */
22909 gcc_assert (!DECL_DECLARED_CONCEPT_P (d
));
22911 /* Variables are never deferred; if instantiation is required, they
22912 are instantiated right away. That allows for better code in the
22913 case that an expression refers to the value of the variable --
22914 if the variable has a constant value the referring expression can
22915 take advantage of that fact. */
22919 /* Don't instantiate cloned functions. Instead, instantiate the
22920 functions they cloned. */
22921 if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_CLONED_FUNCTION_P (d
))
22922 d
= DECL_CLONED_FUNCTION (d
);
22924 if (DECL_TEMPLATE_INSTANTIATED (d
)
22925 || (TREE_CODE (d
) == FUNCTION_DECL
22926 && DECL_DEFAULTED_FN (d
) && DECL_INITIAL (d
))
22927 || DECL_TEMPLATE_SPECIALIZATION (d
))
22928 /* D has already been instantiated or explicitly specialized, so
22929 there's nothing for us to do here.
22931 It might seem reasonable to check whether or not D is an explicit
22932 instantiation, and, if so, stop here. But when an explicit
22933 instantiation is deferred until the end of the compilation,
22934 DECL_EXPLICIT_INSTANTIATION is set, even though we still need to do
22935 the instantiation. */
22938 /* Check to see whether we know that this template will be
22939 instantiated in some other file, as with "extern template"
22941 external_p
= (DECL_INTERFACE_KNOWN (d
) && DECL_REALLY_EXTERN (d
));
22943 /* In general, we do not instantiate such templates. */
22944 if (external_p
&& !always_instantiate_p (d
))
22947 gen_tmpl
= most_general_template (tmpl
);
22948 gen_args
= DECL_TI_ARGS (d
);
22950 if (tmpl
!= gen_tmpl
)
22951 /* We should already have the extra args. */
22952 gcc_assert (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (gen_tmpl
))
22953 == TMPL_ARGS_DEPTH (gen_args
));
22954 /* And what's in the hash table should match D. */
22955 gcc_assert ((spec
= retrieve_specialization (gen_tmpl
, gen_args
, 0)) == d
22956 || spec
== NULL_TREE
);
22958 /* This needs to happen before any tsubsting. */
22959 if (! push_tinst_level (d
))
22962 timevar_push (TV_TEMPLATE_INST
);
22964 /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
22965 for the instantiation. */
22966 td
= template_for_substitution (d
);
22971 /* Look up an explicit specialization, if any. */
22972 tree tid
= lookup_template_variable (gen_tmpl
, gen_args
);
22973 tree elt
= most_specialized_partial_spec (tid
, tf_warning_or_error
);
22974 if (elt
&& elt
!= error_mark_node
)
22976 td
= TREE_VALUE (elt
);
22977 args
= TREE_PURPOSE (elt
);
22981 code_pattern
= DECL_TEMPLATE_RESULT (td
);
22983 /* We should never be trying to instantiate a member of a class
22984 template or partial specialization. */
22985 gcc_assert (d
!= code_pattern
);
22987 if ((DECL_NAMESPACE_SCOPE_P (d
) && !DECL_INITIALIZED_IN_CLASS_P (d
))
22988 || DECL_TEMPLATE_SPECIALIZATION (td
))
22989 /* In the case of a friend template whose definition is provided
22990 outside the class, we may have too many arguments. Drop the
22991 ones we don't need. The same is true for specializations. */
22992 args
= get_innermost_template_args
22993 (args
, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td
)));
22995 if (TREE_CODE (d
) == FUNCTION_DECL
)
22997 deleted_p
= DECL_DELETED_FN (code_pattern
);
22998 pattern_defined
= ((DECL_SAVED_TREE (code_pattern
) != NULL_TREE
22999 && DECL_INITIAL (code_pattern
) != error_mark_node
)
23000 || DECL_DEFAULTED_OUTSIDE_CLASS_P (code_pattern
)
23006 if (DECL_CLASS_SCOPE_P (code_pattern
))
23007 pattern_defined
= (! DECL_IN_AGGR_P (code_pattern
)
23008 || DECL_INLINE_VAR_P (code_pattern
));
23010 pattern_defined
= ! DECL_EXTERNAL (code_pattern
);
23013 /* We may be in the middle of deferred access check. Disable it now. */
23014 push_deferring_access_checks (dk_no_deferred
);
23016 /* Unless an explicit instantiation directive has already determined
23017 the linkage of D, remember that a definition is available for
23019 if (pattern_defined
23020 && !DECL_INTERFACE_KNOWN (d
)
23021 && !DECL_NOT_REALLY_EXTERN (d
))
23022 mark_definable (d
);
23024 DECL_SOURCE_LOCATION (td
) = DECL_SOURCE_LOCATION (code_pattern
);
23025 DECL_SOURCE_LOCATION (d
) = DECL_SOURCE_LOCATION (code_pattern
);
23026 input_location
= DECL_SOURCE_LOCATION (d
);
23028 /* If D is a member of an explicitly instantiated class template,
23029 and no definition is available, treat it like an implicit
23031 if (!pattern_defined
&& expl_inst_class_mem_p
23032 && DECL_EXPLICIT_INSTANTIATION (d
))
23034 /* Leave linkage flags alone on instantiations with anonymous
23036 if (TREE_PUBLIC (d
))
23038 DECL_NOT_REALLY_EXTERN (d
) = 0;
23039 DECL_INTERFACE_KNOWN (d
) = 0;
23041 SET_DECL_IMPLICIT_INSTANTIATION (d
);
23044 /* Defer all other templates, unless we have been explicitly
23045 forbidden from doing so. */
23046 if (/* If there is no definition, we cannot instantiate the
23049 /* If it's OK to postpone instantiation, do so. */
23051 /* If this is a static data member that will be defined
23052 elsewhere, we don't want to instantiate the entire data
23053 member, but we do want to instantiate the initializer so that
23054 we can substitute that elsewhere. */
23055 || (external_p
&& VAR_P (d
))
23056 /* Handle here a deleted function too, avoid generating
23057 its body (c++/61080). */
23060 /* The definition of the static data member is now required so
23061 we must substitute the initializer. */
23063 && !DECL_INITIAL (d
)
23064 && DECL_INITIAL (code_pattern
))
23068 bool const_init
= false;
23069 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
23071 ns
= decl_namespace_context (d
);
23072 push_nested_namespace (ns
);
23074 push_nested_class (DECL_CONTEXT (d
));
23075 init
= tsubst_expr (DECL_INITIAL (code_pattern
),
23077 tf_warning_or_error
, NULL_TREE
,
23078 /*integral_constant_expression_p=*/false);
23079 /* If instantiating the initializer involved instantiating this
23080 again, don't call cp_finish_decl twice. */
23081 if (!DECL_INITIAL (d
))
23083 /* Make sure the initializer is still constant, in case of
23084 circular dependency (template/instantiate6.C). */
23086 = DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
23087 cp_finish_decl (d
, init
, /*init_const_expr_p=*/const_init
,
23088 /*asmspec_tree=*/NULL_TREE
,
23089 LOOKUP_ONLYCONVERTING
);
23092 pop_nested_class ();
23093 pop_nested_namespace (ns
);
23096 /* We restore the source position here because it's used by
23097 add_pending_template. */
23098 input_location
= saved_loc
;
23100 if (at_eof
&& !pattern_defined
23101 && DECL_EXPLICIT_INSTANTIATION (d
)
23102 && DECL_NOT_REALLY_EXTERN (d
))
23105 The definition of a non-exported function template, a
23106 non-exported member function template, or a non-exported
23107 member function or static data member of a class template
23108 shall be present in every translation unit in which it is
23109 explicitly instantiated. */
23110 permerror (input_location
, "explicit instantiation of %qD "
23111 "but no definition available", d
);
23113 /* If we're in unevaluated context, we just wanted to get the
23114 constant value; this isn't an odr use, so don't queue
23115 a full instantiation. */
23116 if (cp_unevaluated_operand
!= 0)
23118 /* ??? Historically, we have instantiated inline functions, even
23119 when marked as "extern template". */
23120 if (!(external_p
&& VAR_P (d
)))
23121 add_pending_template (d
);
23124 /* Tell the repository that D is available in this translation unit
23125 -- and see if it is supposed to be instantiated here. */
23126 if (TREE_PUBLIC (d
) && !DECL_REALLY_EXTERN (d
) && !repo_emit_p (d
))
23128 /* In a PCH file, despite the fact that the repository hasn't
23129 requested instantiation in the PCH it is still possible that
23130 an instantiation will be required in a file that includes the
23133 add_pending_template (d
);
23134 /* Instantiate inline functions so that the inliner can do its
23135 job, even though we'll not be emitting a copy of this
23137 if (!(TREE_CODE (d
) == FUNCTION_DECL
&& possibly_inlined_p (d
)))
23141 bool push_to_top
, nested
;
23143 fn_context
= decl_function_context (d
);
23144 nested
= current_function_decl
!= NULL_TREE
;
23145 push_to_top
= !(nested
&& fn_context
== current_function_decl
);
23147 vec
<tree
> omp_privatization_save
;
23149 save_omp_privatization_clauses (omp_privatization_save
);
23152 push_to_top_level ();
23155 push_function_context ();
23156 cp_unevaluated_operand
= 0;
23157 c_inhibit_evaluation_warnings
= 0;
23160 /* Mark D as instantiated so that recursive calls to
23161 instantiate_decl do not try to instantiate it again. */
23162 DECL_TEMPLATE_INSTANTIATED (d
) = 1;
23164 /* Regenerate the declaration in case the template has been modified
23165 by a subsequent redeclaration. */
23166 regenerate_decl_from_template (d
, td
, args
);
23168 /* We already set the file and line above. Reset them now in case
23169 they changed as a result of calling regenerate_decl_from_template. */
23170 input_location
= DECL_SOURCE_LOCATION (d
);
23175 bool const_init
= false;
23177 /* Clear out DECL_RTL; whatever was there before may not be right
23178 since we've reset the type of the declaration. */
23179 SET_DECL_RTL (d
, NULL
);
23180 DECL_IN_AGGR_P (d
) = 0;
23182 /* The initializer is placed in DECL_INITIAL by
23183 regenerate_decl_from_template so we don't need to
23184 push/pop_access_scope again here. Pull it out so that
23185 cp_finish_decl can process it. */
23186 init
= DECL_INITIAL (d
);
23187 DECL_INITIAL (d
) = NULL_TREE
;
23188 DECL_INITIALIZED_P (d
) = 0;
23190 /* Clear DECL_EXTERNAL so that cp_finish_decl will process the
23191 initializer. That function will defer actual emission until
23192 we have a chance to determine linkage. */
23193 DECL_EXTERNAL (d
) = 0;
23195 /* Enter the scope of D so that access-checking works correctly. */
23196 bool enter_context
= DECL_CLASS_SCOPE_P (d
);
23198 push_nested_class (DECL_CONTEXT (d
));
23200 const_init
= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (code_pattern
);
23201 cp_finish_decl (d
, init
, const_init
, NULL_TREE
, 0);
23204 pop_nested_class ();
23206 if (variable_template_p (gen_tmpl
))
23207 note_variable_template_instantiation (d
);
23209 else if (TREE_CODE (d
) == FUNCTION_DECL
&& DECL_DEFAULTED_FN (code_pattern
))
23210 synthesize_method (d
);
23211 else if (TREE_CODE (d
) == FUNCTION_DECL
)
23213 /* Set up the list of local specializations. */
23214 local_specialization_stack
lss (push_to_top
? lss_blank
: lss_copy
);
23215 tree block
= NULL_TREE
;
23217 /* Set up context. */
23218 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
23219 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
23220 block
= push_stmt_list ();
23222 start_preparsed_function (d
, NULL_TREE
, SF_PRE_PARSED
);
23224 /* Some typedefs referenced from within the template code need to be
23225 access checked at template instantiation time, i.e now. These
23226 types were added to the template at parsing time. Let's get those
23227 and perform the access checks then. */
23228 perform_typedefs_access_check (DECL_TEMPLATE_RESULT (td
),
23231 /* Create substitution entries for the parameters. */
23232 register_parameter_specializations (code_pattern
, d
);
23234 /* Substitute into the body of the function. */
23235 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
23236 tsubst_omp_udr (DECL_SAVED_TREE (code_pattern
), args
,
23237 tf_warning_or_error
, tmpl
);
23240 tsubst_expr (DECL_SAVED_TREE (code_pattern
), args
,
23241 tf_warning_or_error
, tmpl
,
23242 /*integral_constant_expression_p=*/false);
23244 /* Set the current input_location to the end of the function
23245 so that finish_function knows where we are. */
23247 = DECL_STRUCT_FUNCTION (code_pattern
)->function_end_locus
;
23249 /* Remember if we saw an infinite loop in the template. */
23250 current_function_infinite_loop
23251 = DECL_STRUCT_FUNCTION (code_pattern
)->language
->infinite_loop
;
23254 /* Finish the function. */
23255 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
)
23256 && TREE_CODE (DECL_CONTEXT (code_pattern
)) == FUNCTION_DECL
)
23257 DECL_SAVED_TREE (d
) = pop_stmt_list (block
);
23260 d
= finish_function (/*inline_p=*/false);
23261 expand_or_defer_fn (d
);
23264 if (DECL_OMP_DECLARE_REDUCTION_P (code_pattern
))
23265 cp_check_omp_declare_reduction (d
);
23268 /* We're not deferring instantiation any more. */
23269 TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (d
)) = 0;
23272 pop_from_top_level ();
23274 pop_function_context ();
23277 restore_omp_privatization_clauses (omp_privatization_save
);
23280 pop_deferring_access_checks ();
23281 timevar_pop (TV_TEMPLATE_INST
);
23282 pop_tinst_level ();
23283 input_location
= saved_loc
;
23284 cp_unevaluated_operand
= saved_unevaluated_operand
;
23285 c_inhibit_evaluation_warnings
= saved_inhibit_evaluation_warnings
;
23290 /* Run through the list of templates that we wish we could
23291 instantiate, and instantiate any we can. RETRIES is the
23292 number of times we retry pending template instantiation. */
23295 instantiate_pending_templates (int retries
)
23298 location_t saved_loc
= input_location
;
23300 /* Instantiating templates may trigger vtable generation. This in turn
23301 may require further template instantiations. We place a limit here
23302 to avoid infinite loop. */
23303 if (pending_templates
&& retries
>= max_tinst_depth
)
23305 tree decl
= pending_templates
->tinst
->decl
;
23307 fatal_error (input_location
,
23308 "template instantiation depth exceeds maximum of %d"
23309 " instantiating %q+D, possibly from virtual table generation"
23310 " (use -ftemplate-depth= to increase the maximum)",
23311 max_tinst_depth
, decl
);
23312 if (TREE_CODE (decl
) == FUNCTION_DECL
)
23313 /* Pretend that we defined it. */
23314 DECL_INITIAL (decl
) = error_mark_node
;
23320 struct pending_template
**t
= &pending_templates
;
23321 struct pending_template
*last
= NULL
;
23325 tree instantiation
= reopen_tinst_level ((*t
)->tinst
);
23326 bool complete
= false;
23328 if (TYPE_P (instantiation
))
23330 if (!COMPLETE_TYPE_P (instantiation
))
23332 instantiate_class_template (instantiation
);
23333 if (CLASSTYPE_TEMPLATE_INSTANTIATION (instantiation
))
23334 for (tree fld
= TYPE_FIELDS (instantiation
);
23335 fld
; fld
= TREE_CHAIN (fld
))
23337 || (TREE_CODE (fld
) == FUNCTION_DECL
23338 && !DECL_ARTIFICIAL (fld
)))
23339 && DECL_TEMPLATE_INSTANTIATION (fld
))
23340 instantiate_decl (fld
,
23341 /*defer_ok=*/false,
23342 /*expl_inst_class_mem_p=*/false);
23344 if (COMPLETE_TYPE_P (instantiation
))
23348 complete
= COMPLETE_TYPE_P (instantiation
);
23352 if (!DECL_TEMPLATE_SPECIALIZATION (instantiation
)
23353 && !DECL_TEMPLATE_INSTANTIATED (instantiation
))
23356 = instantiate_decl (instantiation
,
23357 /*defer_ok=*/false,
23358 /*expl_inst_class_mem_p=*/false);
23359 if (DECL_TEMPLATE_INSTANTIATED (instantiation
))
23363 complete
= (DECL_TEMPLATE_SPECIALIZATION (instantiation
)
23364 || DECL_TEMPLATE_INSTANTIATED (instantiation
));
23368 /* If INSTANTIATION has been instantiated, then we don't
23369 need to consider it again in the future. */
23377 current_tinst_level
= NULL
;
23379 last_pending_template
= last
;
23381 while (reconsider
);
23383 input_location
= saved_loc
;
23386 /* Substitute ARGVEC into T, which is a list of initializers for
23387 either base class or a non-static data member. The TREE_PURPOSEs
23388 are DECLs, and the TREE_VALUEs are the initializer values. Used by
23389 instantiate_decl. */
23392 tsubst_initializer_list (tree t
, tree argvec
)
23394 tree inits
= NULL_TREE
;
23396 for (; t
; t
= TREE_CHAIN (t
))
23400 tree expanded_bases
= NULL_TREE
;
23401 tree expanded_arguments
= NULL_TREE
;
23404 if (TREE_CODE (TREE_PURPOSE (t
)) == TYPE_PACK_EXPANSION
)
23409 /* Expand the base class expansion type into separate base
23411 expanded_bases
= tsubst_pack_expansion (TREE_PURPOSE (t
), argvec
,
23412 tf_warning_or_error
,
23414 if (expanded_bases
== error_mark_node
)
23417 /* We'll be building separate TREE_LISTs of arguments for
23419 len
= TREE_VEC_LENGTH (expanded_bases
);
23420 expanded_arguments
= make_tree_vec (len
);
23421 for (i
= 0; i
< len
; i
++)
23422 TREE_VEC_ELT (expanded_arguments
, i
) = NULL_TREE
;
23424 /* Build a dummy EXPR_PACK_EXPANSION that will be used to
23425 expand each argument in the TREE_VALUE of t. */
23426 expr
= make_node (EXPR_PACK_EXPANSION
);
23427 PACK_EXPANSION_LOCAL_P (expr
) = true;
23428 PACK_EXPANSION_PARAMETER_PACKS (expr
) =
23429 PACK_EXPANSION_PARAMETER_PACKS (TREE_PURPOSE (t
));
23431 if (TREE_VALUE (t
) == void_type_node
)
23432 /* VOID_TYPE_NODE is used to indicate
23433 value-initialization. */
23435 for (i
= 0; i
< len
; i
++)
23436 TREE_VEC_ELT (expanded_arguments
, i
) = void_type_node
;
23440 /* Substitute parameter packs into each argument in the
23442 in_base_initializer
= 1;
23443 for (arg
= TREE_VALUE (t
); arg
; arg
= TREE_CHAIN (arg
))
23445 tree expanded_exprs
;
23447 /* Expand the argument. */
23448 SET_PACK_EXPANSION_PATTERN (expr
, TREE_VALUE (arg
));
23450 = tsubst_pack_expansion (expr
, argvec
,
23451 tf_warning_or_error
,
23453 if (expanded_exprs
== error_mark_node
)
23456 /* Prepend each of the expanded expressions to the
23457 corresponding TREE_LIST in EXPANDED_ARGUMENTS. */
23458 for (i
= 0; i
< len
; i
++)
23460 TREE_VEC_ELT (expanded_arguments
, i
) =
23461 tree_cons (NULL_TREE
,
23462 TREE_VEC_ELT (expanded_exprs
, i
),
23463 TREE_VEC_ELT (expanded_arguments
, i
));
23466 in_base_initializer
= 0;
23468 /* Reverse all of the TREE_LISTs in EXPANDED_ARGUMENTS,
23469 since we built them backwards. */
23470 for (i
= 0; i
< len
; i
++)
23472 TREE_VEC_ELT (expanded_arguments
, i
) =
23473 nreverse (TREE_VEC_ELT (expanded_arguments
, i
));
23478 for (i
= 0; i
< len
; ++i
)
23480 if (expanded_bases
)
23482 decl
= TREE_VEC_ELT (expanded_bases
, i
);
23483 decl
= expand_member_init (decl
);
23484 init
= TREE_VEC_ELT (expanded_arguments
, i
);
23489 decl
= tsubst_copy (TREE_PURPOSE (t
), argvec
,
23490 tf_warning_or_error
, NULL_TREE
);
23492 decl
= expand_member_init (decl
);
23493 if (decl
&& !DECL_P (decl
))
23494 in_base_initializer
= 1;
23496 init
= TREE_VALUE (t
);
23498 if (init
!= void_type_node
)
23499 init
= tsubst_expr (init
, argvec
,
23500 tf_warning_or_error
, NULL_TREE
,
23501 /*integral_constant_expression_p=*/false);
23502 if (init
== NULL_TREE
&& tmp
!= NULL_TREE
)
23503 /* If we had an initializer but it instantiated to nothing,
23504 value-initialize the object. This will only occur when
23505 the initializer was a pack expansion where the parameter
23506 packs used in that expansion were of length zero. */
23507 init
= void_type_node
;
23508 in_base_initializer
= 0;
23513 init
= build_tree_list (decl
, init
);
23514 TREE_CHAIN (init
) = inits
;
23522 /* Set CURRENT_ACCESS_SPECIFIER based on the protection of DECL. */
23525 set_current_access_from_decl (tree decl
)
23527 if (TREE_PRIVATE (decl
))
23528 current_access_specifier
= access_private_node
;
23529 else if (TREE_PROTECTED (decl
))
23530 current_access_specifier
= access_protected_node
;
23532 current_access_specifier
= access_public_node
;
23535 /* Instantiate an enumerated type. TAG is the template type, NEWTAG
23536 is the instantiation (which should have been created with
23537 start_enum) and ARGS are the template arguments to use. */
23540 tsubst_enum (tree tag
, tree newtag
, tree args
)
23544 if (SCOPED_ENUM_P (newtag
))
23545 begin_scope (sk_scoped_enum
, newtag
);
23547 for (e
= TYPE_VALUES (tag
); e
; e
= TREE_CHAIN (e
))
23552 decl
= TREE_VALUE (e
);
23553 /* Note that in a template enum, the TREE_VALUE is the
23554 CONST_DECL, not the corresponding INTEGER_CST. */
23555 value
= tsubst_expr (DECL_INITIAL (decl
),
23556 args
, tf_warning_or_error
, NULL_TREE
,
23557 /*integral_constant_expression_p=*/true);
23559 /* Give this enumeration constant the correct access. */
23560 set_current_access_from_decl (decl
);
23562 /* Actually build the enumerator itself. Here we're assuming that
23563 enumerators can't have dependent attributes. */
23564 build_enumerator (DECL_NAME (decl
), value
, newtag
,
23565 DECL_ATTRIBUTES (decl
), DECL_SOURCE_LOCATION (decl
));
23568 if (SCOPED_ENUM_P (newtag
))
23571 finish_enum_value_list (newtag
);
23572 finish_enum (newtag
);
23574 DECL_SOURCE_LOCATION (TYPE_NAME (newtag
))
23575 = DECL_SOURCE_LOCATION (TYPE_NAME (tag
));
23578 /* DECL is a FUNCTION_DECL that is a template specialization. Return
23579 its type -- but without substituting the innermost set of template
23580 arguments. So, innermost set of template parameters will appear in
23584 get_mostly_instantiated_function_type (tree decl
)
23586 /* For a function, DECL_TI_TEMPLATE is partially instantiated. */
23587 return TREE_TYPE (DECL_TI_TEMPLATE (decl
));
23590 /* Return truthvalue if we're processing a template different from
23591 the last one involved in diagnostics. */
23593 problematic_instantiation_changed (void)
23595 return current_tinst_level
!= last_error_tinst_level
;
23598 /* Remember current template involved in diagnostics. */
23600 record_last_problematic_instantiation (void)
23602 last_error_tinst_level
= current_tinst_level
;
23605 struct tinst_level
*
23606 current_instantiation (void)
23608 return current_tinst_level
;
23611 /* Return TRUE if current_function_decl is being instantiated, false
23615 instantiating_current_function_p (void)
23617 return (current_instantiation ()
23618 && current_instantiation ()->decl
== current_function_decl
);
23621 /* [temp.param] Check that template non-type parm TYPE is of an allowable
23622 type. Return false for ok, true for disallowed. Issue error and
23623 inform messages under control of COMPLAIN. */
23626 invalid_nontype_parm_type_p (tree type
, tsubst_flags_t complain
)
23628 if (INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
23630 else if (POINTER_TYPE_P (type
))
23632 else if (TYPE_PTRMEM_P (type
))
23634 else if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
23636 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
23638 else if (TREE_CODE (type
) == DECLTYPE_TYPE
)
23640 else if (TREE_CODE (type
) == NULLPTR_TYPE
)
23642 /* A bound template template parm could later be instantiated to have a valid
23643 nontype parm type via an alias template. */
23644 else if (cxx_dialect
>= cxx11
23645 && TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
23648 if (complain
& tf_error
)
23650 if (type
== error_mark_node
)
23651 inform (input_location
, "invalid template non-type parameter");
23653 error ("%q#T is not a valid type for a template non-type parameter",
23659 /* Returns TRUE if TYPE is dependent, in the sense of [temp.dep.type].
23660 Assumes that TYPE really is a type, and not the ERROR_MARK_NODE.*/
23663 dependent_type_p_r (tree type
)
23669 A type is dependent if it is:
23671 -- a template parameter. Template template parameters are types
23672 for us (since TYPE_P holds true for them) so we handle
23674 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
23675 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
)
23677 /* -- a qualified-id with a nested-name-specifier which contains a
23678 class-name that names a dependent type or whose unqualified-id
23679 names a dependent type. */
23680 if (TREE_CODE (type
) == TYPENAME_TYPE
)
23683 /* An alias template specialization can be dependent even if the
23684 resulting type is not. */
23685 if (dependent_alias_template_spec_p (type
))
23688 /* -- a cv-qualified type where the cv-unqualified type is
23690 No code is necessary for this bullet; the code below handles
23691 cv-qualified types, and we don't want to strip aliases with
23692 TYPE_MAIN_VARIANT because of DR 1558. */
23693 /* -- a compound type constructed from any dependent type. */
23694 if (TYPE_PTRMEM_P (type
))
23695 return (dependent_type_p (TYPE_PTRMEM_CLASS_TYPE (type
))
23696 || dependent_type_p (TYPE_PTRMEM_POINTED_TO_TYPE
23698 else if (TYPE_PTR_P (type
)
23699 || TREE_CODE (type
) == REFERENCE_TYPE
)
23700 return dependent_type_p (TREE_TYPE (type
));
23701 else if (TREE_CODE (type
) == FUNCTION_TYPE
23702 || TREE_CODE (type
) == METHOD_TYPE
)
23706 if (dependent_type_p (TREE_TYPE (type
)))
23708 for (arg_type
= TYPE_ARG_TYPES (type
);
23710 arg_type
= TREE_CHAIN (arg_type
))
23711 if (dependent_type_p (TREE_VALUE (arg_type
)))
23713 if (cxx_dialect
>= cxx17
)
23715 /* A value-dependent noexcept-specifier makes the type dependent. */
23716 tree spec
= TYPE_RAISES_EXCEPTIONS (type
);
23717 if (spec
&& TREE_PURPOSE (spec
)
23718 && value_dependent_expression_p (TREE_PURPOSE (spec
)))
23723 /* -- an array type constructed from any dependent type or whose
23724 size is specified by a constant expression that is
23727 We checked for type- and value-dependence of the bounds in
23728 compute_array_index_type, so TYPE_DEPENDENT_P is already set. */
23729 if (TREE_CODE (type
) == ARRAY_TYPE
)
23731 if (TYPE_DOMAIN (type
)
23732 && dependent_type_p (TYPE_DOMAIN (type
)))
23734 return dependent_type_p (TREE_TYPE (type
));
23737 /* -- a template-id in which either the template name is a template
23739 if (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
23741 /* ... or any of the template arguments is a dependent type or
23742 an expression that is type-dependent or value-dependent. */
23743 else if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_INFO (type
)
23744 && (any_dependent_template_arguments_p
23745 (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type
)))))
23748 /* All TYPEOF_TYPEs, DECLTYPE_TYPEs, and UNDERLYING_TYPEs are
23749 dependent; if the argument of the `typeof' expression is not
23750 type-dependent, then it should already been have resolved. */
23751 if (TREE_CODE (type
) == TYPEOF_TYPE
23752 || TREE_CODE (type
) == DECLTYPE_TYPE
23753 || TREE_CODE (type
) == UNDERLYING_TYPE
)
23756 /* A template argument pack is dependent if any of its packed
23758 if (TREE_CODE (type
) == TYPE_ARGUMENT_PACK
)
23760 tree args
= ARGUMENT_PACK_ARGS (type
);
23761 int i
, len
= TREE_VEC_LENGTH (args
);
23762 for (i
= 0; i
< len
; ++i
)
23763 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
23767 /* All TYPE_PACK_EXPANSIONs are dependent, because parameter packs must
23768 be template parameters. */
23769 if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
23772 if (any_dependent_type_attributes_p (TYPE_ATTRIBUTES (type
)))
23775 /* The standard does not specifically mention types that are local
23776 to template functions or local classes, but they should be
23777 considered dependent too. For example:
23779 template <int I> void f() {
23784 The size of `E' cannot be known until the value of `I' has been
23785 determined. Therefore, `E' must be considered dependent. */
23786 scope
= TYPE_CONTEXT (type
);
23787 if (scope
&& TYPE_P (scope
))
23788 return dependent_type_p (scope
);
23789 /* Don't use type_dependent_expression_p here, as it can lead
23790 to infinite recursion trying to determine whether a lambda
23791 nested in a lambda is dependent (c++/47687). */
23792 else if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
23793 && DECL_LANG_SPECIFIC (scope
)
23794 && DECL_TEMPLATE_INFO (scope
)
23795 && (any_dependent_template_arguments_p
23796 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (scope
)))))
23799 /* Other types are non-dependent. */
23803 /* Returns TRUE if TYPE is dependent, in the sense of
23804 [temp.dep.type]. Note that a NULL type is considered dependent. */
23807 dependent_type_p (tree type
)
23809 /* If there are no template parameters in scope, then there can't be
23810 any dependent types. */
23811 if (!processing_template_decl
)
23813 /* If we are not processing a template, then nobody should be
23814 providing us with a dependent type. */
23816 gcc_assert (TREE_CODE (type
) != TEMPLATE_TYPE_PARM
|| is_auto (type
));
23820 /* If the type is NULL, we have not computed a type for the entity
23821 in question; in that case, the type is dependent. */
23825 /* Erroneous types can be considered non-dependent. */
23826 if (type
== error_mark_node
)
23829 /* Getting here with global_type_node means we improperly called this
23830 function on the TREE_TYPE of an IDENTIFIER_NODE. */
23831 gcc_checking_assert (type
!= global_type_node
);
23833 /* If we have not already computed the appropriate value for TYPE,
23835 if (!TYPE_DEPENDENT_P_VALID (type
))
23837 TYPE_DEPENDENT_P (type
) = dependent_type_p_r (type
);
23838 TYPE_DEPENDENT_P_VALID (type
) = 1;
23841 return TYPE_DEPENDENT_P (type
);
23844 /* Returns TRUE if SCOPE is a dependent scope, in which we can't do any
23845 lookup. In other words, a dependent type that is not the current
23849 dependent_scope_p (tree scope
)
23851 return (scope
&& TYPE_P (scope
) && dependent_type_p (scope
)
23852 && !currently_open_class (scope
));
23855 /* T is a SCOPE_REF; return whether we need to consider it
23856 instantiation-dependent so that we can check access at instantiation
23857 time even though we know which member it resolves to. */
23860 instantiation_dependent_scope_ref_p (tree t
)
23862 if (DECL_P (TREE_OPERAND (t
, 1))
23863 && CLASS_TYPE_P (TREE_OPERAND (t
, 0))
23864 && accessible_in_template_p (TREE_OPERAND (t
, 0),
23865 TREE_OPERAND (t
, 1)))
23871 /* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
23872 [temp.dep.constexpr]. EXPRESSION is already known to be a constant
23875 /* Note that this predicate is not appropriate for general expressions;
23876 only constant expressions (that satisfy potential_constant_expression)
23877 can be tested for value dependence. */
23880 value_dependent_expression_p (tree expression
)
23882 if (!processing_template_decl
|| expression
== NULL_TREE
)
23885 /* A name declared with a dependent type. */
23886 if (DECL_P (expression
) && type_dependent_expression_p (expression
))
23889 switch (TREE_CODE (expression
))
23892 /* A dependent member function of the current instantiation. */
23893 return dependent_type_p (BINFO_TYPE (BASELINK_BINFO (expression
)));
23895 case FUNCTION_DECL
:
23896 /* A dependent member function of the current instantiation. */
23897 if (DECL_CLASS_SCOPE_P (expression
)
23898 && dependent_type_p (DECL_CONTEXT (expression
)))
23902 case IDENTIFIER_NODE
:
23903 /* A name that has not been looked up -- must be dependent. */
23906 case TEMPLATE_PARM_INDEX
:
23907 /* A non-type template parm. */
23911 /* A non-type template parm. */
23912 if (DECL_TEMPLATE_PARM_P (expression
))
23914 return value_dependent_expression_p (DECL_INITIAL (expression
));
23917 /* A constant with literal type and is initialized
23918 with an expression that is value-dependent.
23920 Note that a non-dependent parenthesized initializer will have
23921 already been replaced with its constant value, so if we see
23922 a TREE_LIST it must be dependent. */
23923 if (DECL_INITIAL (expression
)
23924 && decl_constant_var_p (expression
)
23925 && (TREE_CODE (DECL_INITIAL (expression
)) == TREE_LIST
23926 /* cp_finish_decl doesn't fold reference initializers. */
23927 || TREE_CODE (TREE_TYPE (expression
)) == REFERENCE_TYPE
23928 || type_dependent_expression_p (DECL_INITIAL (expression
))
23929 || value_dependent_expression_p (DECL_INITIAL (expression
))))
23931 if (DECL_HAS_VALUE_EXPR_P (expression
))
23933 tree value_expr
= DECL_VALUE_EXPR (expression
);
23934 if (type_dependent_expression_p (value_expr
))
23939 case DYNAMIC_CAST_EXPR
:
23940 case STATIC_CAST_EXPR
:
23941 case CONST_CAST_EXPR
:
23942 case REINTERPRET_CAST_EXPR
:
23944 /* These expressions are value-dependent if the type to which
23945 the cast occurs is dependent or the expression being casted
23946 is value-dependent. */
23948 tree type
= TREE_TYPE (expression
);
23950 if (dependent_type_p (type
))
23953 /* A functional cast has a list of operands. */
23954 expression
= TREE_OPERAND (expression
, 0);
23957 /* If there are no operands, it must be an expression such
23958 as "int()". This should not happen for aggregate types
23959 because it would form non-constant expressions. */
23960 gcc_assert (cxx_dialect
>= cxx11
23961 || INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
23966 if (TREE_CODE (expression
) == TREE_LIST
)
23967 return any_value_dependent_elements_p (expression
);
23969 return value_dependent_expression_p (expression
);
23973 if (SIZEOF_EXPR_TYPE_P (expression
))
23974 return dependent_type_p (TREE_TYPE (TREE_OPERAND (expression
, 0)));
23978 /* A `sizeof' expression is value-dependent if the operand is
23979 type-dependent or is a pack expansion. */
23980 expression
= TREE_OPERAND (expression
, 0);
23981 if (PACK_EXPANSION_P (expression
))
23983 else if (TYPE_P (expression
))
23984 return dependent_type_p (expression
);
23985 return instantiation_dependent_uneval_expression_p (expression
);
23987 case AT_ENCODE_EXPR
:
23988 /* An 'encode' expression is value-dependent if the operand is
23990 expression
= TREE_OPERAND (expression
, 0);
23991 return dependent_type_p (expression
);
23993 case NOEXCEPT_EXPR
:
23994 expression
= TREE_OPERAND (expression
, 0);
23995 return instantiation_dependent_uneval_expression_p (expression
);
23998 /* All instantiation-dependent expressions should also be considered
23999 value-dependent. */
24000 return instantiation_dependent_scope_ref_p (expression
);
24002 case COMPONENT_REF
:
24003 return (value_dependent_expression_p (TREE_OPERAND (expression
, 0))
24004 || value_dependent_expression_p (TREE_OPERAND (expression
, 1)));
24006 case NONTYPE_ARGUMENT_PACK
:
24007 /* A NONTYPE_ARGUMENT_PACK is value-dependent if any packed argument
24008 is value-dependent. */
24010 tree values
= ARGUMENT_PACK_ARGS (expression
);
24011 int i
, len
= TREE_VEC_LENGTH (values
);
24013 for (i
= 0; i
< len
; ++i
)
24014 if (value_dependent_expression_p (TREE_VEC_ELT (values
, i
)))
24022 tree type2
= TRAIT_EXPR_TYPE2 (expression
);
24024 if (dependent_type_p (TRAIT_EXPR_TYPE1 (expression
)))
24030 if (TREE_CODE (type2
) != TREE_LIST
)
24031 return dependent_type_p (type2
);
24033 for (; type2
; type2
= TREE_CHAIN (type2
))
24034 if (dependent_type_p (TREE_VALUE (type2
)))
24041 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
24042 || (value_dependent_expression_p (TREE_OPERAND (expression
, 2))));
24045 return ((value_dependent_expression_p (TREE_OPERAND (expression
, 0)))
24046 || (value_dependent_expression_p (TREE_OPERAND (expression
, 1))));
24050 tree op
= TREE_OPERAND (expression
, 0);
24051 return (value_dependent_expression_p (op
)
24052 || has_value_dependent_address (op
));
24055 case REQUIRES_EXPR
:
24056 /* Treat all requires-expressions as value-dependent so
24057 we don't try to fold them. */
24061 return dependent_type_p (TREE_OPERAND (expression
, 0));
24065 if (value_dependent_expression_p (CALL_EXPR_FN (expression
)))
24067 tree fn
= get_callee_fndecl (expression
);
24069 nargs
= call_expr_nargs (expression
);
24070 for (i
= 0; i
< nargs
; ++i
)
24072 tree op
= CALL_EXPR_ARG (expression
, i
);
24073 /* In a call to a constexpr member function, look through the
24074 implicit ADDR_EXPR on the object argument so that it doesn't
24075 cause the call to be considered value-dependent. We also
24076 look through it in potential_constant_expression. */
24077 if (i
== 0 && fn
&& DECL_DECLARED_CONSTEXPR_P (fn
)
24078 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
24079 && TREE_CODE (op
) == ADDR_EXPR
)
24080 op
= TREE_OPERAND (op
, 0);
24081 if (value_dependent_expression_p (op
))
24087 case TEMPLATE_ID_EXPR
:
24088 /* If a TEMPLATE_ID_EXPR involves a dependent name, it will be
24090 return type_dependent_expression_p (expression
)
24091 || variable_concept_p (TREE_OPERAND (expression
, 0));
24097 if (dependent_type_p (TREE_TYPE (expression
)))
24099 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), ix
, val
)
24100 if (value_dependent_expression_p (val
))
24106 /* Treat a GNU statement expression as dependent to avoid crashing
24107 under instantiate_non_dependent_expr; it can't be constant. */
24111 /* A constant expression is value-dependent if any subexpression is
24112 value-dependent. */
24113 switch (TREE_CODE_CLASS (TREE_CODE (expression
)))
24115 case tcc_reference
:
24117 case tcc_comparison
:
24119 case tcc_expression
:
24122 int i
, len
= cp_tree_operand_length (expression
);
24124 for (i
= 0; i
< len
; i
++)
24126 tree t
= TREE_OPERAND (expression
, i
);
24128 /* In some cases, some of the operands may be missing.
24129 (For example, in the case of PREDECREMENT_EXPR, the
24130 amount to increment by may be missing.) That doesn't
24131 make the expression dependent. */
24132 if (t
&& value_dependent_expression_p (t
))
24143 /* The expression is not value-dependent. */
24147 /* Returns TRUE if the EXPRESSION is type-dependent, in the sense of
24148 [temp.dep.expr]. Note that an expression with no type is
24149 considered dependent. Other parts of the compiler arrange for an
24150 expression with type-dependent subexpressions to have no type, so
24151 this function doesn't have to be fully recursive. */
24154 type_dependent_expression_p (tree expression
)
24156 if (!processing_template_decl
)
24159 if (expression
== NULL_TREE
|| expression
== error_mark_node
)
24162 /* An unresolved name is always dependent. */
24163 if (identifier_p (expression
)
24164 || TREE_CODE (expression
) == USING_DECL
24165 || TREE_CODE (expression
) == WILDCARD_DECL
)
24168 /* A fold expression is type-dependent. */
24169 if (TREE_CODE (expression
) == UNARY_LEFT_FOLD_EXPR
24170 || TREE_CODE (expression
) == UNARY_RIGHT_FOLD_EXPR
24171 || TREE_CODE (expression
) == BINARY_LEFT_FOLD_EXPR
24172 || TREE_CODE (expression
) == BINARY_RIGHT_FOLD_EXPR
)
24175 /* Some expression forms are never type-dependent. */
24176 if (TREE_CODE (expression
) == PSEUDO_DTOR_EXPR
24177 || TREE_CODE (expression
) == SIZEOF_EXPR
24178 || TREE_CODE (expression
) == ALIGNOF_EXPR
24179 || TREE_CODE (expression
) == AT_ENCODE_EXPR
24180 || TREE_CODE (expression
) == NOEXCEPT_EXPR
24181 || TREE_CODE (expression
) == TRAIT_EXPR
24182 || TREE_CODE (expression
) == TYPEID_EXPR
24183 || TREE_CODE (expression
) == DELETE_EXPR
24184 || TREE_CODE (expression
) == VEC_DELETE_EXPR
24185 || TREE_CODE (expression
) == THROW_EXPR
24186 || TREE_CODE (expression
) == REQUIRES_EXPR
)
24189 /* The types of these expressions depends only on the type to which
24190 the cast occurs. */
24191 if (TREE_CODE (expression
) == DYNAMIC_CAST_EXPR
24192 || TREE_CODE (expression
) == STATIC_CAST_EXPR
24193 || TREE_CODE (expression
) == CONST_CAST_EXPR
24194 || TREE_CODE (expression
) == REINTERPRET_CAST_EXPR
24195 || TREE_CODE (expression
) == IMPLICIT_CONV_EXPR
24196 || TREE_CODE (expression
) == CAST_EXPR
)
24197 return dependent_type_p (TREE_TYPE (expression
));
24199 /* The types of these expressions depends only on the type created
24200 by the expression. */
24201 if (TREE_CODE (expression
) == NEW_EXPR
24202 || TREE_CODE (expression
) == VEC_NEW_EXPR
)
24204 /* For NEW_EXPR tree nodes created inside a template, either
24205 the object type itself or a TREE_LIST may appear as the
24207 tree type
= TREE_OPERAND (expression
, 1);
24208 if (TREE_CODE (type
) == TREE_LIST
)
24209 /* This is an array type. We need to check array dimensions
24211 return dependent_type_p (TREE_VALUE (TREE_PURPOSE (type
)))
24212 || value_dependent_expression_p
24213 (TREE_OPERAND (TREE_VALUE (type
), 1));
24215 return dependent_type_p (type
);
24218 if (TREE_CODE (expression
) == SCOPE_REF
)
24220 tree scope
= TREE_OPERAND (expression
, 0);
24221 tree name
= TREE_OPERAND (expression
, 1);
24223 /* 14.6.2.2 [temp.dep.expr]: An id-expression is type-dependent if it
24224 contains an identifier associated by name lookup with one or more
24225 declarations declared with a dependent type, or...a
24226 nested-name-specifier or qualified-id that names a member of an
24227 unknown specialization. */
24228 return (type_dependent_expression_p (name
)
24229 || dependent_scope_p (scope
));
24232 if (TREE_CODE (expression
) == TEMPLATE_DECL
24233 && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression
))
24234 return uses_outer_template_parms (expression
);
24236 if (TREE_CODE (expression
) == STMT_EXPR
)
24237 expression
= stmt_expr_value_expr (expression
);
24239 if (BRACE_ENCLOSED_INITIALIZER_P (expression
))
24244 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expression
), i
, elt
)
24246 if (type_dependent_expression_p (elt
))
24252 /* A static data member of the current instantiation with incomplete
24253 array type is type-dependent, as the definition and specializations
24254 can have different bounds. */
24255 if (VAR_P (expression
)
24256 && DECL_CLASS_SCOPE_P (expression
)
24257 && dependent_type_p (DECL_CONTEXT (expression
))
24258 && VAR_HAD_UNKNOWN_BOUND (expression
))
24261 /* An array of unknown bound depending on a variadic parameter, eg:
24263 template<typename... Args>
24264 void foo (Args... args)
24266 int arr[] = { args... };
24269 template<int... vals>
24272 int arr[] = { vals... };
24275 If the array has no length and has an initializer, it must be that
24276 we couldn't determine its length in cp_complete_array_type because
24277 it is dependent. */
24278 if (VAR_P (expression
)
24279 && TREE_TYPE (expression
) != NULL_TREE
24280 && TREE_CODE (TREE_TYPE (expression
)) == ARRAY_TYPE
24281 && !TYPE_DOMAIN (TREE_TYPE (expression
))
24282 && DECL_INITIAL (expression
))
24285 /* A function or variable template-id is type-dependent if it has any
24286 dependent template arguments. */
24287 if (VAR_OR_FUNCTION_DECL_P (expression
)
24288 && DECL_LANG_SPECIFIC (expression
)
24289 && DECL_TEMPLATE_INFO (expression
))
24291 /* Consider the innermost template arguments, since those are the ones
24292 that come from the template-id; the template arguments for the
24293 enclosing class do not make it type-dependent unless they are used in
24294 the type of the decl. */
24295 if (PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (expression
))
24296 && (any_dependent_template_arguments_p
24297 (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression
)))))
24301 /* Otherwise, if the function decl isn't from a dependent scope, it can't be
24302 type-dependent. Checking this is important for functions with auto return
24303 type, which looks like a dependent type. */
24304 if (TREE_CODE (expression
) == FUNCTION_DECL
24305 && !(DECL_CLASS_SCOPE_P (expression
)
24306 && dependent_type_p (DECL_CONTEXT (expression
)))
24307 && !(DECL_FRIEND_P (expression
)
24308 && (!DECL_FRIEND_CONTEXT (expression
)
24309 || dependent_type_p (DECL_FRIEND_CONTEXT (expression
))))
24310 && !DECL_LOCAL_FUNCTION_P (expression
))
24312 gcc_assert (!dependent_type_p (TREE_TYPE (expression
))
24313 || undeduced_auto_decl (expression
));
24317 /* Always dependent, on the number of arguments if nothing else. */
24318 if (TREE_CODE (expression
) == EXPR_PACK_EXPANSION
)
24321 if (TREE_TYPE (expression
) == unknown_type_node
)
24323 if (TREE_CODE (expression
) == ADDR_EXPR
)
24324 return type_dependent_expression_p (TREE_OPERAND (expression
, 0));
24325 if (TREE_CODE (expression
) == COMPONENT_REF
24326 || TREE_CODE (expression
) == OFFSET_REF
)
24328 if (type_dependent_expression_p (TREE_OPERAND (expression
, 0)))
24330 expression
= TREE_OPERAND (expression
, 1);
24331 if (identifier_p (expression
))
24334 /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
24335 if (TREE_CODE (expression
) == SCOPE_REF
)
24338 if (BASELINK_P (expression
))
24340 if (BASELINK_OPTYPE (expression
)
24341 && dependent_type_p (BASELINK_OPTYPE (expression
)))
24343 expression
= BASELINK_FUNCTIONS (expression
);
24346 if (TREE_CODE (expression
) == TEMPLATE_ID_EXPR
)
24348 if (any_dependent_template_arguments_p
24349 (TREE_OPERAND (expression
, 1)))
24351 expression
= TREE_OPERAND (expression
, 0);
24352 if (identifier_p (expression
))
24356 gcc_assert (TREE_CODE (expression
) == OVERLOAD
24357 || TREE_CODE (expression
) == FUNCTION_DECL
);
24359 for (lkp_iterator
iter (expression
); iter
; ++iter
)
24360 if (type_dependent_expression_p (*iter
))
24366 gcc_assert (TREE_CODE (expression
) != TYPE_DECL
);
24368 /* Dependent type attributes might not have made it from the decl to
24370 if (DECL_P (expression
)
24371 && any_dependent_type_attributes_p (DECL_ATTRIBUTES (expression
)))
24374 return (dependent_type_p (TREE_TYPE (expression
)));
24377 /* [temp.dep.expr]/5: A class member access expression (5.2.5) is
24378 type-dependent if the expression refers to a member of the current
24379 instantiation and the type of the referenced member is dependent, or the
24380 class member access expression refers to a member of an unknown
24383 This function returns true if the OBJECT in such a class member access
24384 expression is of an unknown specialization. */
24387 type_dependent_object_expression_p (tree object
)
24389 /* An IDENTIFIER_NODE can sometimes have a TREE_TYPE, but it's still
24391 if (TREE_CODE (object
) == IDENTIFIER_NODE
)
24393 tree scope
= TREE_TYPE (object
);
24394 return (!scope
|| dependent_scope_p (scope
));
24397 /* walk_tree callback function for instantiation_dependent_expression_p,
24398 below. Returns non-zero if a dependent subexpression is found. */
24401 instantiation_dependent_r (tree
*tp
, int *walk_subtrees
,
24406 /* We don't have to worry about decltype currently because decltype
24407 of an instantiation-dependent expr is a dependent type. This
24408 might change depending on the resolution of DR 1172. */
24409 *walk_subtrees
= false;
24412 enum tree_code code
= TREE_CODE (*tp
);
24415 /* Don't treat an argument list as dependent just because it has no
24421 case TEMPLATE_PARM_INDEX
:
24424 /* Handle expressions with type operands. */
24428 case AT_ENCODE_EXPR
:
24430 tree op
= TREE_OPERAND (*tp
, 0);
24431 if (code
== SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (*tp
))
24432 op
= TREE_TYPE (op
);
24435 if (dependent_type_p (op
))
24439 *walk_subtrees
= false;
24446 case COMPONENT_REF
:
24447 if (identifier_p (TREE_OPERAND (*tp
, 1)))
24448 /* In a template, finish_class_member_access_expr creates a
24449 COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
24450 type-dependent, so that we can check access control at
24451 instantiation time (PR 42277). See also Core issue 1273. */
24456 if (instantiation_dependent_scope_ref_p (*tp
))
24461 /* Treat statement-expressions as dependent. */
24465 /* Treat requires-expressions as dependent. */
24466 case REQUIRES_EXPR
:
24470 /* Treat calls to function concepts as dependent. */
24471 if (function_concept_check_p (*tp
))
24475 case TEMPLATE_ID_EXPR
:
24476 /* And variable concepts. */
24477 if (variable_concept_p (TREE_OPERAND (*tp
, 0)))
24485 if (type_dependent_expression_p (*tp
))
24491 /* Returns TRUE if the EXPRESSION is instantiation-dependent, in the
24492 sense defined by the ABI:
24494 "An expression is instantiation-dependent if it is type-dependent
24495 or value-dependent, or it has a subexpression that is type-dependent
24496 or value-dependent."
24498 Except don't actually check value-dependence for unevaluated expressions,
24499 because in sizeof(i) we don't care about the value of i. Checking
24500 type-dependence will in turn check value-dependence of array bounds/template
24501 arguments as needed. */
24504 instantiation_dependent_uneval_expression_p (tree expression
)
24508 if (!processing_template_decl
)
24511 if (expression
== error_mark_node
)
24514 result
= cp_walk_tree_without_duplicates (&expression
,
24515 instantiation_dependent_r
, NULL
);
24516 return result
!= NULL_TREE
;
24519 /* As above, but also check value-dependence of the expression as a whole. */
24522 instantiation_dependent_expression_p (tree expression
)
24524 return (instantiation_dependent_uneval_expression_p (expression
)
24525 || value_dependent_expression_p (expression
));
24528 /* Like type_dependent_expression_p, but it also works while not processing
24529 a template definition, i.e. during substitution or mangling. */
24532 type_dependent_expression_p_push (tree expr
)
24535 ++processing_template_decl
;
24536 b
= type_dependent_expression_p (expr
);
24537 --processing_template_decl
;
24541 /* Returns TRUE if ARGS contains a type-dependent expression. */
24544 any_type_dependent_arguments_p (const vec
<tree
, va_gc
> *args
)
24549 FOR_EACH_VEC_SAFE_ELT (args
, i
, arg
)
24551 if (type_dependent_expression_p (arg
))
24557 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
24558 expressions) contains any type-dependent expressions. */
24561 any_type_dependent_elements_p (const_tree list
)
24563 for (; list
; list
= TREE_CHAIN (list
))
24564 if (type_dependent_expression_p (TREE_VALUE (list
)))
24570 /* Returns TRUE if LIST (a TREE_LIST whose TREE_VALUEs are
24571 expressions) contains any value-dependent expressions. */
24574 any_value_dependent_elements_p (const_tree list
)
24576 for (; list
; list
= TREE_CHAIN (list
))
24577 if (value_dependent_expression_p (TREE_VALUE (list
)))
24583 /* Returns TRUE if the ARG (a template argument) is dependent. */
24586 dependent_template_arg_p (tree arg
)
24588 if (!processing_template_decl
)
24591 /* Assume a template argument that was wrongly written by the user
24592 is dependent. This is consistent with what
24593 any_dependent_template_arguments_p [that calls this function]
24595 if (!arg
|| arg
== error_mark_node
)
24598 if (TREE_CODE (arg
) == ARGUMENT_PACK_SELECT
)
24599 arg
= ARGUMENT_PACK_SELECT_ARG (arg
);
24601 if (TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
24603 if (TREE_CODE (arg
) == TEMPLATE_DECL
)
24605 if (DECL_TEMPLATE_PARM_P (arg
))
24607 /* A member template of a dependent class is not necessarily
24608 type-dependent, but it is a dependent template argument because it
24609 will be a member of an unknown specialization to that template. */
24610 tree scope
= CP_DECL_CONTEXT (arg
);
24611 return TYPE_P (scope
) && dependent_type_p (scope
);
24613 else if (ARGUMENT_PACK_P (arg
))
24615 tree args
= ARGUMENT_PACK_ARGS (arg
);
24616 int i
, len
= TREE_VEC_LENGTH (args
);
24617 for (i
= 0; i
< len
; ++i
)
24619 if (dependent_template_arg_p (TREE_VEC_ELT (args
, i
)))
24625 else if (TYPE_P (arg
))
24626 return dependent_type_p (arg
);
24628 return (type_dependent_expression_p (arg
)
24629 || value_dependent_expression_p (arg
));
24632 /* Returns true if ARGS (a collection of template arguments) contains
24633 any types that require structural equality testing. */
24636 any_template_arguments_need_structural_equality_p (tree args
)
24643 if (args
== error_mark_node
)
24646 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
24648 tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
24649 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
24651 tree arg
= TREE_VEC_ELT (level
, j
);
24652 tree packed_args
= NULL_TREE
;
24655 if (ARGUMENT_PACK_P (arg
))
24657 /* Look inside the argument pack. */
24658 packed_args
= ARGUMENT_PACK_ARGS (arg
);
24659 len
= TREE_VEC_LENGTH (packed_args
);
24662 for (k
= 0; k
< len
; ++k
)
24665 arg
= TREE_VEC_ELT (packed_args
, k
);
24667 if (error_operand_p (arg
))
24669 else if (TREE_CODE (arg
) == TEMPLATE_DECL
)
24671 else if (TYPE_P (arg
) && TYPE_STRUCTURAL_EQUALITY_P (arg
))
24673 else if (!TYPE_P (arg
) && TREE_TYPE (arg
)
24674 && TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (arg
)))
24683 /* Returns true if ARGS (a collection of template arguments) contains
24684 any dependent arguments. */
24687 any_dependent_template_arguments_p (const_tree args
)
24694 if (args
== error_mark_node
)
24697 for (i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
24699 const_tree level
= TMPL_ARGS_LEVEL (args
, i
+ 1);
24700 for (j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
24701 if (dependent_template_arg_p (TREE_VEC_ELT (level
, j
)))
24708 /* Returns TRUE if the template TMPL is type-dependent. */
24711 dependent_template_p (tree tmpl
)
24713 if (TREE_CODE (tmpl
) == OVERLOAD
)
24715 for (lkp_iterator
iter (tmpl
); iter
; ++iter
)
24716 if (dependent_template_p (*iter
))
24721 /* Template template parameters are dependent. */
24722 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
)
24723 || TREE_CODE (tmpl
) == TEMPLATE_TEMPLATE_PARM
)
24725 /* So are names that have not been looked up. */
24726 if (TREE_CODE (tmpl
) == SCOPE_REF
|| identifier_p (tmpl
))
24731 /* Returns TRUE if the specialization TMPL<ARGS> is dependent. */
24734 dependent_template_id_p (tree tmpl
, tree args
)
24736 return (dependent_template_p (tmpl
)
24737 || any_dependent_template_arguments_p (args
));
24740 /* Returns TRUE if OMP_FOR with DECLV, INITV, CONDV and INCRV vectors
24744 dependent_omp_for_p (tree declv
, tree initv
, tree condv
, tree incrv
)
24748 if (!processing_template_decl
)
24751 for (i
= 0; i
< TREE_VEC_LENGTH (declv
); i
++)
24753 tree decl
= TREE_VEC_ELT (declv
, i
);
24754 tree init
= TREE_VEC_ELT (initv
, i
);
24755 tree cond
= TREE_VEC_ELT (condv
, i
);
24756 tree incr
= TREE_VEC_ELT (incrv
, i
);
24758 if (type_dependent_expression_p (decl
)
24759 || TREE_CODE (decl
) == SCOPE_REF
)
24762 if (init
&& type_dependent_expression_p (init
))
24765 if (type_dependent_expression_p (cond
))
24768 if (COMPARISON_CLASS_P (cond
)
24769 && (type_dependent_expression_p (TREE_OPERAND (cond
, 0))
24770 || type_dependent_expression_p (TREE_OPERAND (cond
, 1))))
24773 if (TREE_CODE (incr
) == MODOP_EXPR
)
24775 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0))
24776 || type_dependent_expression_p (TREE_OPERAND (incr
, 2)))
24779 else if (type_dependent_expression_p (incr
))
24781 else if (TREE_CODE (incr
) == MODIFY_EXPR
)
24783 if (type_dependent_expression_p (TREE_OPERAND (incr
, 0)))
24785 else if (BINARY_CLASS_P (TREE_OPERAND (incr
, 1)))
24787 tree t
= TREE_OPERAND (incr
, 1);
24788 if (type_dependent_expression_p (TREE_OPERAND (t
, 0))
24789 || type_dependent_expression_p (TREE_OPERAND (t
, 1)))
24798 /* TYPE is a TYPENAME_TYPE. Returns the ordinary TYPE to which the
24799 TYPENAME_TYPE corresponds. Returns the original TYPENAME_TYPE if
24800 no such TYPE can be found. Note that this function peers inside
24801 uninstantiated templates and therefore should be used only in
24802 extremely limited situations. ONLY_CURRENT_P restricts this
24803 peering to the currently open classes hierarchy (which is required
24804 when comparing types). */
24807 resolve_typename_type (tree type
, bool only_current_p
)
24816 gcc_assert (TREE_CODE (type
) == TYPENAME_TYPE
);
24818 scope
= TYPE_CONTEXT (type
);
24819 /* Usually the non-qualified identifier of a TYPENAME_TYPE is
24820 TYPE_IDENTIFIER (type). But when 'type' is a typedef variant of
24821 a TYPENAME_TYPE node, then TYPE_NAME (type) is set to the TYPE_DECL representing
24822 the typedef. In that case TYPE_IDENTIFIER (type) is not the non-qualified
24823 identifier of the TYPENAME_TYPE anymore.
24824 So by getting the TYPE_IDENTIFIER of the _main declaration_ of the
24825 TYPENAME_TYPE instead, we avoid messing up with a possible
24826 typedef variant case. */
24827 name
= TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type
));
24829 /* If the SCOPE is itself a TYPENAME_TYPE, then we need to resolve
24830 it first before we can figure out what NAME refers to. */
24831 if (TREE_CODE (scope
) == TYPENAME_TYPE
)
24833 if (TYPENAME_IS_RESOLVING_P (scope
))
24834 /* Given a class template A with a dependent base with nested type C,
24835 typedef typename A::C::C C will land us here, as trying to resolve
24836 the initial A::C leads to the local C typedef, which leads back to
24837 A::C::C. So we break the recursion now. */
24840 scope
= resolve_typename_type (scope
, only_current_p
);
24842 /* If we don't know what SCOPE refers to, then we cannot resolve the
24844 if (!CLASS_TYPE_P (scope
))
24846 /* If this is a typedef, we don't want to look inside (c++/11987). */
24847 if (typedef_variant_p (type
))
24849 /* If SCOPE isn't the template itself, it will not have a valid
24850 TYPE_FIELDS list. */
24851 if (same_type_p (scope
, CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
)))
24852 /* scope is either the template itself or a compatible instantiation
24853 like X<T>, so look up the name in the original template. */
24854 scope
= CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope
);
24855 /* We shouldn't have built a TYPENAME_TYPE with a non-dependent scope. */
24856 gcc_checking_assert (uses_template_parms (scope
));
24857 /* If scope has no fields, it can't be a current instantiation. Check this
24858 before currently_open_class to avoid infinite recursion (71515). */
24859 if (!TYPE_FIELDS (scope
))
24861 /* If the SCOPE is not the current instantiation, there's no reason
24862 to look inside it. */
24863 if (only_current_p
&& !currently_open_class (scope
))
24865 /* Enter the SCOPE so that name lookup will be resolved as if we
24866 were in the class definition. In particular, SCOPE will no
24867 longer be considered a dependent type. */
24868 pushed_scope
= push_scope (scope
);
24869 /* Look up the declaration. */
24870 decl
= lookup_member (scope
, name
, /*protect=*/0, /*want_type=*/true,
24871 tf_warning_or_error
);
24873 result
= NULL_TREE
;
24875 /* For a TYPENAME_TYPE like "typename X::template Y<T>", we want to
24876 find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
24877 tree fullname
= TYPENAME_TYPE_FULLNAME (type
);
24880 else if (identifier_p (fullname
)
24881 && TREE_CODE (decl
) == TYPE_DECL
)
24883 result
= TREE_TYPE (decl
);
24884 if (result
== error_mark_node
)
24885 result
= NULL_TREE
;
24887 else if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
24888 && DECL_CLASS_TEMPLATE_P (decl
))
24890 /* Obtain the template and the arguments. */
24891 tree tmpl
= TREE_OPERAND (fullname
, 0);
24892 if (TREE_CODE (tmpl
) == IDENTIFIER_NODE
)
24894 /* We get here with a plain identifier because a previous tentative
24895 parse of the nested-name-specifier as part of a ptr-operator saw
24896 ::template X<A>. The use of ::template is necessary in a
24897 ptr-operator, but wrong in a declarator-id.
24899 [temp.names]: In a qualified-id of a declarator-id, the keyword
24900 template shall not appear at the top level. */
24901 pedwarn (EXPR_LOC_OR_LOC (fullname
, input_location
), OPT_Wpedantic
,
24902 "keyword %<template%> not allowed in declarator-id");
24905 tree args
= TREE_OPERAND (fullname
, 1);
24906 /* Instantiate the template. */
24907 result
= lookup_template_class (tmpl
, args
, NULL_TREE
, NULL_TREE
,
24908 /*entering_scope=*/true,
24909 tf_error
| tf_user
);
24910 if (result
== error_mark_node
)
24911 result
= NULL_TREE
;
24914 /* Leave the SCOPE. */
24916 pop_scope (pushed_scope
);
24918 /* If we failed to resolve it, return the original typename. */
24922 /* If lookup found a typename type, resolve that too. */
24923 if (TREE_CODE (result
) == TYPENAME_TYPE
&& !TYPENAME_IS_RESOLVING_P (result
))
24925 /* Ill-formed programs can cause infinite recursion here, so we
24926 must catch that. */
24927 TYPENAME_IS_RESOLVING_P (result
) = 1;
24928 result
= resolve_typename_type (result
, only_current_p
);
24929 TYPENAME_IS_RESOLVING_P (result
) = 0;
24932 /* Qualify the resulting type. */
24933 quals
= cp_type_quals (type
);
24935 result
= cp_build_qualified_type (result
, cp_type_quals (result
) | quals
);
24940 /* EXPR is an expression which is not type-dependent. Return a proxy
24941 for EXPR that can be used to compute the types of larger
24942 expressions containing EXPR. */
24945 build_non_dependent_expr (tree expr
)
24949 /* When checking, try to get a constant value for all non-dependent
24950 expressions in order to expose bugs in *_dependent_expression_p
24951 and constexpr. This can affect code generation, see PR70704, so
24952 only do this for -fchecking=2. */
24953 if (flag_checking
> 1
24954 && cxx_dialect
>= cxx11
24955 /* Don't do this during nsdmi parsing as it can lead to
24956 unexpected recursive instantiations. */
24957 && !parsing_nsdmi ()
24958 /* Don't do this during concept expansion either and for
24959 the same reason. */
24960 && !expanding_concept ())
24961 fold_non_dependent_expr (expr
);
24963 /* Preserve OVERLOADs; the functions must be available to resolve
24966 if (TREE_CODE (inner_expr
) == STMT_EXPR
)
24967 inner_expr
= stmt_expr_value_expr (inner_expr
);
24968 if (TREE_CODE (inner_expr
) == ADDR_EXPR
)
24969 inner_expr
= TREE_OPERAND (inner_expr
, 0);
24970 if (TREE_CODE (inner_expr
) == COMPONENT_REF
)
24971 inner_expr
= TREE_OPERAND (inner_expr
, 1);
24972 if (is_overloaded_fn (inner_expr
)
24973 || TREE_CODE (inner_expr
) == OFFSET_REF
)
24975 /* There is no need to return a proxy for a variable. */
24978 /* Preserve string constants; conversions from string constants to
24979 "char *" are allowed, even though normally a "const char *"
24980 cannot be used to initialize a "char *". */
24981 if (TREE_CODE (expr
) == STRING_CST
)
24983 /* Preserve void and arithmetic constants, as an optimization -- there is no
24984 reason to create a new node. */
24985 if (TREE_CODE (expr
) == VOID_CST
24986 || TREE_CODE (expr
) == INTEGER_CST
24987 || TREE_CODE (expr
) == REAL_CST
)
24989 /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
24990 There is at least one place where we want to know that a
24991 particular expression is a throw-expression: when checking a ?:
24992 expression, there are special rules if the second or third
24993 argument is a throw-expression. */
24994 if (TREE_CODE (expr
) == THROW_EXPR
)
24997 /* Don't wrap an initializer list, we need to be able to look inside. */
24998 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
25001 /* Don't wrap a dummy object, we need to be able to test for it. */
25002 if (is_dummy_object (expr
))
25005 if (TREE_CODE (expr
) == COND_EXPR
)
25006 return build3 (COND_EXPR
,
25008 TREE_OPERAND (expr
, 0),
25009 (TREE_OPERAND (expr
, 1)
25010 ? build_non_dependent_expr (TREE_OPERAND (expr
, 1))
25011 : build_non_dependent_expr (TREE_OPERAND (expr
, 0))),
25012 build_non_dependent_expr (TREE_OPERAND (expr
, 2)));
25013 if (TREE_CODE (expr
) == COMPOUND_EXPR
25014 && !COMPOUND_EXPR_OVERLOADED (expr
))
25015 return build2 (COMPOUND_EXPR
,
25017 TREE_OPERAND (expr
, 0),
25018 build_non_dependent_expr (TREE_OPERAND (expr
, 1)));
25020 /* If the type is unknown, it can't really be non-dependent */
25021 gcc_assert (TREE_TYPE (expr
) != unknown_type_node
);
25023 /* Otherwise, build a NON_DEPENDENT_EXPR. */
25024 return build1 (NON_DEPENDENT_EXPR
, TREE_TYPE (expr
), expr
);
25027 /* ARGS is a vector of expressions as arguments to a function call.
25028 Replace the arguments with equivalent non-dependent expressions.
25029 This modifies ARGS in place. */
25032 make_args_non_dependent (vec
<tree
, va_gc
> *args
)
25037 FOR_EACH_VEC_SAFE_ELT (args
, ix
, arg
)
25039 tree newarg
= build_non_dependent_expr (arg
);
25041 (*args
)[ix
] = newarg
;
25045 /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a
25046 TEMPLATE_TYPE_PARM with a level one deeper than the actual template
25047 parms. If set_canonical is true, we set TYPE_CANONICAL on it. */
25050 make_auto_1 (tree name
, bool set_canonical
)
25052 tree au
= cxx_make_type (TEMPLATE_TYPE_PARM
);
25053 TYPE_NAME (au
) = build_decl (input_location
,
25054 TYPE_DECL
, name
, au
);
25055 TYPE_STUB_DECL (au
) = TYPE_NAME (au
);
25056 TEMPLATE_TYPE_PARM_INDEX (au
) = build_template_parm_index
25057 (0, processing_template_decl
+ 1, processing_template_decl
+ 1,
25058 TYPE_NAME (au
), NULL_TREE
);
25060 TYPE_CANONICAL (au
) = canonical_type_parameter (au
);
25061 DECL_ARTIFICIAL (TYPE_NAME (au
)) = 1;
25062 SET_DECL_TEMPLATE_PARM_P (TYPE_NAME (au
));
25068 make_decltype_auto (void)
25070 return make_auto_1 (decltype_auto_identifier
, true);
25076 return make_auto_1 (auto_identifier
, true);
25079 /* Return a C++17 deduction placeholder for class template TMPL. */
25082 make_template_placeholder (tree tmpl
)
25084 tree t
= make_auto_1 (DECL_NAME (tmpl
), true);
25085 CLASS_PLACEHOLDER_TEMPLATE (t
) = tmpl
;
25089 /* True iff T is a C++17 class template deduction placeholder. */
25092 template_placeholder_p (tree t
)
25094 return is_auto (t
) && CLASS_PLACEHOLDER_TEMPLATE (t
);
25097 /* Make a "constrained auto" type-specifier. This is an
25098 auto type with constraints that must be associated after
25099 deduction. The constraint is formed from the given
25100 CONC and its optional sequence of arguments, which are
25101 non-null if written as partial-concept-id. */
25104 make_constrained_auto (tree con
, tree args
)
25106 tree type
= make_auto_1 (auto_identifier
, false);
25108 /* Build the constraint. */
25109 tree tmpl
= DECL_TI_TEMPLATE (con
);
25110 tree expr
= VAR_P (con
) ? tmpl
: ovl_make (tmpl
);
25111 expr
= build_concept_check (expr
, type
, args
);
25113 tree constr
= normalize_expression (expr
);
25114 PLACEHOLDER_TYPE_CONSTRAINTS (type
) = constr
;
25116 /* Our canonical type depends on the constraint. */
25117 TYPE_CANONICAL (type
) = canonical_type_parameter (type
);
25119 /* Attach the constraint to the type declaration. */
25120 tree decl
= TYPE_NAME (type
);
25124 /* Given type ARG, return std::initializer_list<ARG>. */
25129 tree std_init_list
= get_namespace_binding (std_node
, init_list_identifier
);
25131 if (!std_init_list
|| !DECL_CLASS_TEMPLATE_P (std_init_list
))
25133 gcc_rich_location
richloc (input_location
);
25134 maybe_add_include_fixit (&richloc
, "<initializer_list>");
25135 error_at (&richloc
,
25136 "deducing from brace-enclosed initializer list"
25137 " requires %<#include <initializer_list>%>");
25139 return error_mark_node
;
25141 tree argvec
= make_tree_vec (1);
25142 TREE_VEC_ELT (argvec
, 0) = arg
;
25144 return lookup_template_class (std_init_list
, argvec
, NULL_TREE
,
25145 NULL_TREE
, 0, tf_warning_or_error
);
25148 /* Replace auto in TYPE with std::initializer_list<auto>. */
25151 listify_autos (tree type
, tree auto_node
)
25153 tree init_auto
= listify (auto_node
);
25154 tree argvec
= make_tree_vec (1);
25155 TREE_VEC_ELT (argvec
, 0) = init_auto
;
25156 if (processing_template_decl
)
25157 argvec
= add_to_template_args (current_template_args (), argvec
);
25158 return tsubst (type
, argvec
, tf_warning_or_error
, NULL_TREE
);
25161 /* Hash traits for hashing possibly constrained 'auto'
25162 TEMPLATE_TYPE_PARMs for use by do_auto_deduction. */
25164 struct auto_hash
: default_hash_traits
<tree
>
25166 static inline hashval_t
hash (tree
);
25167 static inline bool equal (tree
, tree
);
25170 /* Hash the 'auto' T. */
25173 auto_hash::hash (tree t
)
25175 if (tree c
= PLACEHOLDER_TYPE_CONSTRAINTS (t
))
25176 /* Matching constrained-type-specifiers denote the same template
25177 parameter, so hash the constraint. */
25178 return hash_placeholder_constraint (c
);
25180 /* But unconstrained autos are all separate, so just hash the pointer. */
25181 return iterative_hash_object (t
, 0);
25184 /* Compare two 'auto's. */
25187 auto_hash::equal (tree t1
, tree t2
)
25192 tree c1
= PLACEHOLDER_TYPE_CONSTRAINTS (t1
);
25193 tree c2
= PLACEHOLDER_TYPE_CONSTRAINTS (t2
);
25195 /* Two unconstrained autos are distinct. */
25199 return equivalent_placeholder_constraints (c1
, c2
);
25202 /* for_each_template_parm callback for extract_autos: if t is a (possibly
25203 constrained) auto, add it to the vector. */
25206 extract_autos_r (tree t
, void *data
)
25208 hash_table
<auto_hash
> &hash
= *(hash_table
<auto_hash
>*)data
;
25211 /* All the autos were built with index 0; fix that up now. */
25212 tree
*p
= hash
.find_slot (t
, INSERT
);
25215 /* If this is a repeated constrained-type-specifier, use the index we
25217 idx
= TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (*p
));
25220 /* Otherwise this is new, so use the current count. */
25222 idx
= hash
.elements () - 1;
25224 TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (t
)) = idx
;
25227 /* Always keep walking. */
25231 /* Return a TREE_VEC of the 'auto's used in type under the Concepts TS, which
25232 says they can appear anywhere in the type. */
25235 extract_autos (tree type
)
25237 hash_set
<tree
> visited
;
25238 hash_table
<auto_hash
> hash (2);
25240 for_each_template_parm (type
, extract_autos_r
, &hash
, &visited
, true);
25242 tree tree_vec
= make_tree_vec (hash
.elements());
25243 for (hash_table
<auto_hash
>::iterator iter
= hash
.begin();
25244 iter
!= hash
.end(); ++iter
)
25247 unsigned i
= TEMPLATE_PARM_IDX (TEMPLATE_TYPE_PARM_INDEX (elt
));
25248 TREE_VEC_ELT (tree_vec
, i
)
25249 = build_tree_list (NULL_TREE
, TYPE_NAME (elt
));
25255 /* The stem for deduction guide names. */
25256 const char *const dguide_base
= "__dguide_";
25258 /* Return the name for a deduction guide for class template TMPL. */
25261 dguide_name (tree tmpl
)
25263 tree type
= (TYPE_P (tmpl
) ? tmpl
: TREE_TYPE (tmpl
));
25264 tree tname
= TYPE_IDENTIFIER (type
);
25265 char *buf
= (char *) alloca (1 + strlen (dguide_base
)
25266 + IDENTIFIER_LENGTH (tname
));
25267 memcpy (buf
, dguide_base
, strlen (dguide_base
));
25268 memcpy (buf
+ strlen (dguide_base
), IDENTIFIER_POINTER (tname
),
25269 IDENTIFIER_LENGTH (tname
) + 1);
25270 tree dname
= get_identifier (buf
);
25271 TREE_TYPE (dname
) = type
;
25275 /* True if NAME is the name of a deduction guide. */
25278 dguide_name_p (tree name
)
25280 return (TREE_TYPE (name
)
25281 && !strncmp (IDENTIFIER_POINTER (name
), dguide_base
,
25282 strlen (dguide_base
)));
25285 /* True if FN is a deduction guide. */
25288 deduction_guide_p (const_tree fn
)
25291 if (tree name
= DECL_NAME (fn
))
25292 return dguide_name_p (name
);
25296 /* True if FN is the copy deduction guide, i.e. A(A)->A. */
25299 copy_guide_p (const_tree fn
)
25301 gcc_assert (deduction_guide_p (fn
));
25302 if (!DECL_ARTIFICIAL (fn
))
25304 tree parms
= FUNCTION_FIRST_USER_PARMTYPE (DECL_TI_TEMPLATE (fn
));
25305 return (TREE_CHAIN (parms
) == void_list_node
25306 && same_type_p (TREE_VALUE (parms
), TREE_TYPE (DECL_NAME (fn
))));
25309 /* True if FN is a guide generated from a constructor template. */
25312 template_guide_p (const_tree fn
)
25314 gcc_assert (deduction_guide_p (fn
));
25315 if (!DECL_ARTIFICIAL (fn
))
25317 tree tmpl
= DECL_TI_TEMPLATE (fn
);
25318 if (tree org
= DECL_ABSTRACT_ORIGIN (tmpl
))
25319 return PRIMARY_TEMPLATE_P (org
);
25323 /* OLDDECL is a _DECL for a template parameter. Return a similar parameter at
25324 LEVEL:INDEX, using tsubst_args and complain for substitution into non-type
25325 template parameter types. Note that the handling of template template
25326 parameters relies on current_template_parms being set appropriately for the
25330 rewrite_template_parm (tree olddecl
, unsigned index
, unsigned level
,
25331 tree tsubst_args
, tsubst_flags_t complain
)
25333 tree oldidx
= get_template_parm_index (olddecl
);
25336 if (TREE_CODE (olddecl
) == TYPE_DECL
25337 || TREE_CODE (olddecl
) == TEMPLATE_DECL
)
25339 tree oldtype
= TREE_TYPE (olddecl
);
25340 newtype
= cxx_make_type (TREE_CODE (oldtype
));
25341 TYPE_MAIN_VARIANT (newtype
) = newtype
;
25342 if (TREE_CODE (oldtype
) == TEMPLATE_TYPE_PARM
)
25343 TEMPLATE_TYPE_PARM_FOR_CLASS (newtype
)
25344 = TEMPLATE_TYPE_PARM_FOR_CLASS (oldtype
);
25347 newtype
= tsubst (TREE_TYPE (olddecl
), tsubst_args
,
25348 complain
, NULL_TREE
);
25351 = build_decl (DECL_SOURCE_LOCATION (olddecl
), TREE_CODE (olddecl
),
25352 DECL_NAME (olddecl
), newtype
);
25353 SET_DECL_TEMPLATE_PARM_P (newdecl
);
25356 if (TREE_CODE (olddecl
) == TYPE_DECL
25357 || TREE_CODE (olddecl
) == TEMPLATE_DECL
)
25359 newidx
= TEMPLATE_TYPE_PARM_INDEX (newtype
)
25360 = build_template_parm_index (index
, level
, level
,
25362 TEMPLATE_PARM_PARAMETER_PACK (newidx
)
25363 = TEMPLATE_PARM_PARAMETER_PACK (oldidx
);
25364 TYPE_STUB_DECL (newtype
) = TYPE_NAME (newtype
) = newdecl
;
25365 TYPE_CANONICAL (newtype
) = canonical_type_parameter (newtype
);
25367 if (TREE_CODE (olddecl
) == TEMPLATE_DECL
)
25369 DECL_TEMPLATE_RESULT (newdecl
)
25370 = build_decl (DECL_SOURCE_LOCATION (olddecl
), TYPE_DECL
,
25371 DECL_NAME (olddecl
), newtype
);
25372 DECL_ARTIFICIAL (DECL_TEMPLATE_RESULT (newdecl
)) = true;
25373 // First create a copy (ttargs) of tsubst_args with an
25374 // additional level for the template template parameter's own
25375 // template parameters (ttparms).
25376 tree ttparms
= (INNERMOST_TEMPLATE_PARMS
25377 (DECL_TEMPLATE_PARMS (olddecl
)));
25378 const int depth
= TMPL_ARGS_DEPTH (tsubst_args
);
25379 tree ttargs
= make_tree_vec (depth
+ 1);
25380 for (int i
= 0; i
< depth
; ++i
)
25381 TREE_VEC_ELT (ttargs
, i
) = TREE_VEC_ELT (tsubst_args
, i
);
25382 TREE_VEC_ELT (ttargs
, depth
)
25383 = template_parms_level_to_args (ttparms
);
25384 // Substitute ttargs into ttparms to fix references to
25385 // other template parameters.
25386 ttparms
= tsubst_template_parms_level (ttparms
, ttargs
,
25388 // Now substitute again with args based on tparms, to reduce
25389 // the level of the ttparms.
25390 ttargs
= current_template_args ();
25391 ttparms
= tsubst_template_parms_level (ttparms
, ttargs
,
25393 // Finally, tack the adjusted parms onto tparms.
25394 ttparms
= tree_cons (size_int (depth
), ttparms
,
25395 current_template_parms
);
25396 DECL_TEMPLATE_PARMS (newdecl
) = ttparms
;
25401 tree oldconst
= TEMPLATE_PARM_DECL (oldidx
);
25403 = build_decl (DECL_SOURCE_LOCATION (oldconst
),
25404 TREE_CODE (oldconst
),
25405 DECL_NAME (oldconst
), newtype
);
25406 TREE_CONSTANT (newconst
) = TREE_CONSTANT (newdecl
)
25407 = TREE_READONLY (newconst
) = TREE_READONLY (newdecl
) = true;
25408 SET_DECL_TEMPLATE_PARM_P (newconst
);
25409 newidx
= build_template_parm_index (index
, level
, level
,
25410 newconst
, newtype
);
25411 TEMPLATE_PARM_PARAMETER_PACK (newidx
)
25412 = TEMPLATE_PARM_PARAMETER_PACK (oldidx
);
25413 DECL_INITIAL (newdecl
) = DECL_INITIAL (newconst
) = newidx
;
25419 /* Returns a C++17 class deduction guide template based on the constructor
25420 CTOR. As a special case, CTOR can be a RECORD_TYPE for an implicit default
25421 guide, or REFERENCE_TYPE for an implicit copy/move guide. */
25424 build_deduction_guide (tree ctor
, tree outer_args
, tsubst_flags_t complain
)
25426 tree type
, tparms
, targs
, fparms
, fargs
, ci
;
25427 bool memtmpl
= false;
25430 tree fn_tmpl
= NULL_TREE
;
25435 bool copy_p
= TREE_CODE (type
) == REFERENCE_TYPE
;
25438 type
= TREE_TYPE (type
);
25439 fparms
= tree_cons (NULL_TREE
, type
, void_list_node
);
25442 fparms
= void_list_node
;
25444 tree ctmpl
= CLASSTYPE_TI_TEMPLATE (type
);
25445 tparms
= DECL_TEMPLATE_PARMS (ctmpl
);
25446 targs
= CLASSTYPE_TI_ARGS (type
);
25449 loc
= DECL_SOURCE_LOCATION (ctmpl
);
25450 explicit_p
= false;
25454 ++processing_template_decl
;
25457 = (TREE_CODE (ctor
) == TEMPLATE_DECL
? ctor
25458 : DECL_TI_TEMPLATE (ctor
));
25460 fn_tmpl
= tsubst (fn_tmpl
, outer_args
, complain
, ctor
);
25461 ctor
= DECL_TEMPLATE_RESULT (fn_tmpl
);
25463 type
= DECL_CONTEXT (ctor
);
25465 tparms
= DECL_TEMPLATE_PARMS (fn_tmpl
);
25466 /* If type is a member class template, DECL_TI_ARGS (ctor) will have
25467 fully specialized args for the enclosing class. Strip those off, as
25468 the deduction guide won't have those template parameters. */
25469 targs
= get_innermost_template_args (DECL_TI_ARGS (ctor
),
25470 TMPL_PARMS_DEPTH (tparms
));
25471 /* Discard the 'this' parameter. */
25472 fparms
= FUNCTION_ARG_CHAIN (ctor
);
25473 fargs
= TREE_CHAIN (DECL_ARGUMENTS (ctor
));
25474 ci
= get_constraints (ctor
);
25475 loc
= DECL_SOURCE_LOCATION (ctor
);
25476 explicit_p
= DECL_NONCONVERTING_P (ctor
);
25478 if (PRIMARY_TEMPLATE_P (fn_tmpl
))
25482 /* For a member template constructor, we need to flatten the two
25483 template parameter lists into one, and then adjust the function
25484 signature accordingly. This gets...complicated. */
25485 tree save_parms
= current_template_parms
;
25487 /* For a member template we should have two levels of parms/args, one
25488 for the class and one for the constructor. We stripped
25489 specialized args for further enclosing classes above. */
25490 const int depth
= 2;
25491 gcc_assert (TMPL_ARGS_DEPTH (targs
) == depth
);
25493 /* Template args for translating references to the two-level template
25494 parameters into references to the one-level template parameters we
25496 tree tsubst_args
= copy_node (targs
);
25497 TMPL_ARGS_LEVEL (tsubst_args
, depth
)
25498 = copy_node (TMPL_ARGS_LEVEL (tsubst_args
, depth
));
25500 /* Template parms for the constructor template. */
25501 tree ftparms
= TREE_VALUE (tparms
);
25502 unsigned flen
= TREE_VEC_LENGTH (ftparms
);
25503 /* Template parms for the class template. */
25504 tparms
= TREE_CHAIN (tparms
);
25505 tree ctparms
= TREE_VALUE (tparms
);
25506 unsigned clen
= TREE_VEC_LENGTH (ctparms
);
25507 /* Template parms for the deduction guide start as a copy of the
25508 template parms for the class. We set current_template_parms for
25509 lookup_template_class_1. */
25510 current_template_parms
= tparms
= copy_node (tparms
);
25511 tree new_vec
= TREE_VALUE (tparms
) = make_tree_vec (flen
+ clen
);
25512 for (unsigned i
= 0; i
< clen
; ++i
)
25513 TREE_VEC_ELT (new_vec
, i
) = TREE_VEC_ELT (ctparms
, i
);
25515 /* Now we need to rewrite the constructor parms to append them to the
25517 for (unsigned i
= 0; i
< flen
; ++i
)
25519 unsigned index
= i
+ clen
;
25520 unsigned level
= 1;
25521 tree oldelt
= TREE_VEC_ELT (ftparms
, i
);
25522 tree olddecl
= TREE_VALUE (oldelt
);
25523 tree newdecl
= rewrite_template_parm (olddecl
, index
, level
,
25524 tsubst_args
, complain
);
25525 tree newdef
= tsubst_template_arg (TREE_PURPOSE (oldelt
),
25526 tsubst_args
, complain
, ctor
);
25527 tree list
= build_tree_list (newdef
, newdecl
);
25528 TEMPLATE_PARM_CONSTRAINTS (list
)
25529 = tsubst_constraint_info (TEMPLATE_PARM_CONSTRAINTS (oldelt
),
25530 tsubst_args
, complain
, ctor
);
25531 TREE_VEC_ELT (new_vec
, index
) = list
;
25532 TMPL_ARG (tsubst_args
, depth
, i
) = template_parm_to_arg (list
);
25535 /* Now we have a final set of template parms to substitute into the
25536 function signature. */
25537 targs
= template_parms_to_args (tparms
);
25538 fparms
= tsubst_arg_types (fparms
, tsubst_args
, NULL_TREE
,
25540 fargs
= tsubst (fargs
, tsubst_args
, complain
, ctor
);
25542 ci
= tsubst_constraint_info (ci
, tsubst_args
, complain
, ctor
);
25544 current_template_parms
= save_parms
;
25546 --processing_template_decl
;
25551 /* Copy the parms so we can set DECL_PRIMARY_TEMPLATE. */
25552 tparms
= copy_node (tparms
);
25553 INNERMOST_TEMPLATE_PARMS (tparms
)
25554 = copy_node (INNERMOST_TEMPLATE_PARMS (tparms
));
25557 tree fntype
= build_function_type (type
, fparms
);
25558 tree ded_fn
= build_lang_decl_loc (loc
,
25560 dguide_name (type
), fntype
);
25561 DECL_ARGUMENTS (ded_fn
) = fargs
;
25562 DECL_ARTIFICIAL (ded_fn
) = true;
25563 DECL_NONCONVERTING_P (ded_fn
) = explicit_p
;
25564 tree ded_tmpl
= build_template_decl (ded_fn
, tparms
, /*member*/false);
25565 DECL_ARTIFICIAL (ded_tmpl
) = true;
25566 DECL_TEMPLATE_RESULT (ded_tmpl
) = ded_fn
;
25567 TREE_TYPE (ded_tmpl
) = TREE_TYPE (ded_fn
);
25568 DECL_TEMPLATE_INFO (ded_fn
) = build_template_info (ded_tmpl
, targs
);
25569 DECL_PRIMARY_TEMPLATE (ded_tmpl
) = ded_tmpl
;
25571 DECL_ABSTRACT_ORIGIN (ded_tmpl
) = fn_tmpl
;
25573 set_constraints (ded_tmpl
, ci
);
25578 /* Deduce template arguments for the class template placeholder PTYPE for
25579 template TMPL based on the initializer INIT, and return the resulting
25583 do_class_deduction (tree ptype
, tree tmpl
, tree init
, int flags
,
25584 tsubst_flags_t complain
)
25586 if (!DECL_CLASS_TEMPLATE_P (tmpl
))
25588 /* We should have handled this in the caller. */
25589 if (DECL_TEMPLATE_TEMPLATE_PARM_P (tmpl
))
25591 if (complain
& tf_error
)
25592 error ("non-class template %qT used without template arguments", tmpl
);
25593 return error_mark_node
;
25596 tree type
= TREE_TYPE (tmpl
);
25598 bool try_list_ctor
= false;
25600 vec
<tree
,va_gc
> *args
;
25601 if (init
== NULL_TREE
25602 || TREE_CODE (init
) == TREE_LIST
)
25603 args
= make_tree_vector_from_list (init
);
25604 else if (BRACE_ENCLOSED_INITIALIZER_P (init
))
25606 try_list_ctor
= TYPE_HAS_LIST_CTOR (type
);
25607 if (try_list_ctor
&& CONSTRUCTOR_NELTS (init
) == 1)
25609 /* As an exception, the first phase in 16.3.1.7 (considering the
25610 initializer list as a single argument) is omitted if the
25611 initializer list consists of a single expression of type cv U,
25612 where U is a specialization of C or a class derived from a
25613 specialization of C. */
25614 tree elt
= CONSTRUCTOR_ELT (init
, 0)->value
;
25615 tree etype
= TREE_TYPE (elt
);
25617 tree tparms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
25618 tree targs
= make_tree_vec (TREE_VEC_LENGTH (tparms
));
25619 int err
= unify (tparms
, targs
, type
, etype
,
25620 UNIFY_ALLOW_DERIVED
, /*explain*/false);
25622 try_list_ctor
= false;
25625 if (try_list_ctor
|| is_std_init_list (type
))
25626 args
= make_tree_vector_single (init
);
25628 args
= make_tree_vector_from_ctor (init
);
25631 args
= make_tree_vector_single (init
);
25633 tree dname
= dguide_name (tmpl
);
25634 tree cands
= lookup_qualified_name (CP_DECL_CONTEXT (tmpl
), dname
,
25635 /*type*/false, /*complain*/false,
25637 bool elided
= false;
25638 if (cands
== error_mark_node
)
25641 /* Prune explicit deduction guides in copy-initialization context. */
25642 if (flags
& LOOKUP_ONLYCONVERTING
)
25644 for (lkp_iterator
iter (cands
); !elided
&& iter
; ++iter
)
25645 if (DECL_NONCONVERTING_P (STRIP_TEMPLATE (*iter
)))
25650 /* Found a nonconverting guide, prune the candidates. */
25651 tree pruned
= NULL_TREE
;
25652 for (lkp_iterator
iter (cands
); iter
; ++iter
)
25653 if (!DECL_NONCONVERTING_P (STRIP_TEMPLATE (*iter
)))
25654 pruned
= lookup_add (*iter
, pruned
);
25660 tree outer_args
= NULL_TREE
;
25661 if (DECL_CLASS_SCOPE_P (tmpl
)
25662 && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (tmpl
)))
25664 outer_args
= CLASSTYPE_TI_ARGS (DECL_CONTEXT (tmpl
));
25665 type
= TREE_TYPE (most_general_template (tmpl
));
25668 bool saw_ctor
= false;
25669 // FIXME cache artificial deduction guides
25670 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (type
)); iter
; ++iter
)
25672 tree guide
= build_deduction_guide (*iter
, outer_args
, complain
);
25673 if ((flags
& LOOKUP_ONLYCONVERTING
)
25674 && DECL_NONCONVERTING_P (STRIP_TEMPLATE (guide
)))
25677 cands
= lookup_add (guide
, cands
);
25682 tree call
= error_mark_node
;
25684 /* If this is list-initialization and the class has a list constructor, first
25685 try deducing from the list as a single argument, as [over.match.list]. */
25686 tree list_cands
= NULL_TREE
;
25687 if (try_list_ctor
&& cands
)
25688 for (lkp_iterator
iter (cands
); iter
; ++iter
)
25691 if (is_list_ctor (dg
))
25692 list_cands
= lookup_add (dg
, list_cands
);
25696 ++cp_unevaluated_operand
;
25697 call
= build_new_function_call (list_cands
, &args
, tf_decltype
);
25698 --cp_unevaluated_operand
;
25700 if (call
== error_mark_node
)
25702 /* That didn't work, now try treating the list as a sequence of
25704 release_tree_vector (args
);
25705 args
= make_tree_vector_from_ctor (init
);
25709 /* Maybe generate an implicit deduction guide. */
25710 if (call
== error_mark_node
&& args
->length () < 2)
25712 tree gtype
= NULL_TREE
;
25714 if (args
->length () == 1)
25715 /* Generate a copy guide. */
25716 gtype
= build_reference_type (type
);
25717 else if (!saw_ctor
)
25718 /* Generate a default guide. */
25723 tree guide
= build_deduction_guide (gtype
, outer_args
, complain
);
25724 cands
= lookup_add (guide
, cands
);
25728 if (elided
&& !cands
)
25730 error ("cannot deduce template arguments for copy-initialization"
25731 " of %qT, as it has no non-explicit deduction guides or "
25732 "user-declared constructors", type
);
25733 return error_mark_node
;
25735 else if (!cands
&& call
== error_mark_node
)
25737 error ("cannot deduce template arguments of %qT, as it has no viable "
25738 "deduction guides", type
);
25739 return error_mark_node
;
25742 if (call
== error_mark_node
)
25744 ++cp_unevaluated_operand
;
25745 call
= build_new_function_call (cands
, &args
, tf_decltype
);
25746 --cp_unevaluated_operand
;
25749 if (call
== error_mark_node
&& (complain
& tf_warning_or_error
))
25751 error ("class template argument deduction failed:");
25753 ++cp_unevaluated_operand
;
25754 call
= build_new_function_call (cands
, &args
, complain
| tf_decltype
);
25755 --cp_unevaluated_operand
;
25758 inform (input_location
, "explicit deduction guides not considered "
25759 "for copy-initialization");
25762 release_tree_vector (args
);
25764 return cp_build_qualified_type (TREE_TYPE (call
), cp_type_quals (ptype
));
25767 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
25768 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
25771 do_auto_deduction (tree type
, tree init
, tree auto_node
)
25773 return do_auto_deduction (type
, init
, auto_node
,
25774 tf_warning_or_error
,
25778 /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
25779 from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE.
25780 The CONTEXT determines the context in which auto deduction is performed
25781 and is used to control error diagnostics. FLAGS are the LOOKUP_* flags.
25782 OUTER_TARGS are used during template argument deduction
25783 (context == adc_unify) to properly substitute the result, and is ignored
25786 For partial-concept-ids, extra args may be appended to the list of deduced
25787 template arguments prior to determining constraint satisfaction. */
25790 do_auto_deduction (tree type
, tree init
, tree auto_node
,
25791 tsubst_flags_t complain
, auto_deduction_context context
,
25792 tree outer_targs
, int flags
)
25796 if (init
== error_mark_node
)
25797 return error_mark_node
;
25799 if (init
&& type_dependent_expression_p (init
)
25800 && context
!= adc_unify
)
25801 /* Defining a subset of type-dependent expressions that we can deduce
25802 from ahead of time isn't worth the trouble. */
25805 if (tree tmpl
= CLASS_PLACEHOLDER_TEMPLATE (auto_node
))
25806 /* C++17 class template argument deduction. */
25807 return do_class_deduction (type
, tmpl
, init
, flags
, complain
);
25809 if (TREE_TYPE (init
) == NULL_TREE
)
25810 /* Nothing we can do with this, even in deduction context. */
25813 /* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
25814 with either a new invented type template parameter U or, if the
25815 initializer is a braced-init-list (8.5.4), with
25816 std::initializer_list<U>. */
25817 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
25819 if (!DIRECT_LIST_INIT_P (init
))
25820 type
= listify_autos (type
, auto_node
);
25821 else if (CONSTRUCTOR_NELTS (init
) == 1)
25822 init
= CONSTRUCTOR_ELT (init
, 0)->value
;
25825 if (complain
& tf_warning_or_error
)
25827 if (permerror (input_location
, "direct-list-initialization of "
25828 "%<auto%> requires exactly one element"))
25829 inform (input_location
,
25830 "for deduction to %<std::initializer_list%>, use copy-"
25831 "list-initialization (i.e. add %<=%> before the %<{%>)");
25833 type
= listify_autos (type
, auto_node
);
25837 if (type
== error_mark_node
)
25838 return error_mark_node
;
25840 init
= resolve_nondeduced_context (init
, complain
);
25842 if (context
== adc_decomp_type
25843 && auto_node
== type
25844 && init
!= error_mark_node
25845 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
25846 /* [dcl.decomp]/1 - if decomposition declaration has no ref-qualifiers
25847 and initializer has array type, deduce cv-qualified array type. */
25848 return cp_build_qualified_type_real (TREE_TYPE (init
), TYPE_QUALS (type
),
25850 else if (AUTO_IS_DECLTYPE (auto_node
))
25852 bool id
= (DECL_P (init
)
25853 || ((TREE_CODE (init
) == COMPONENT_REF
25854 || TREE_CODE (init
) == SCOPE_REF
)
25855 && !REF_PARENTHESIZED_P (init
)));
25856 targs
= make_tree_vec (1);
25857 TREE_VEC_ELT (targs
, 0)
25858 = finish_decltype_type (init
, id
, tf_warning_or_error
);
25859 if (type
!= auto_node
)
25861 if (complain
& tf_error
)
25862 error ("%qT as type rather than plain %<decltype(auto)%>", type
);
25863 return error_mark_node
;
25868 tree parms
= build_tree_list (NULL_TREE
, type
);
25872 tparms
= extract_autos (type
);
25875 tparms
= make_tree_vec (1);
25876 TREE_VEC_ELT (tparms
, 0)
25877 = build_tree_list (NULL_TREE
, TYPE_NAME (auto_node
));
25880 targs
= make_tree_vec (TREE_VEC_LENGTH (tparms
));
25881 int val
= type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
25882 DEDUCE_CALL
, LOOKUP_NORMAL
,
25883 NULL
, /*explain_p=*/false);
25886 if (processing_template_decl
)
25887 /* Try again at instantiation time. */
25889 if (type
&& type
!= error_mark_node
25890 && (complain
& tf_error
))
25891 /* If type is error_mark_node a diagnostic must have been
25892 emitted by now. Also, having a mention to '<type error>'
25893 in the diagnostic is not really useful to the user. */
25895 if (cfun
&& auto_node
== current_function_auto_return_pattern
25896 && LAMBDA_FUNCTION_P (current_function_decl
))
25897 error ("unable to deduce lambda return type from %qE", init
);
25899 error ("unable to deduce %qT from %qE", type
, init
);
25900 type_unification_real (tparms
, targs
, parms
, &init
, 1, 0,
25901 DEDUCE_CALL
, LOOKUP_NORMAL
,
25902 NULL
, /*explain_p=*/true);
25904 return error_mark_node
;
25908 /* Check any placeholder constraints against the deduced type. */
25909 if (flag_concepts
&& !processing_template_decl
)
25910 if (tree constr
= PLACEHOLDER_TYPE_CONSTRAINTS (auto_node
))
25912 /* Use the deduced type to check the associated constraints. If we
25913 have a partial-concept-id, rebuild the argument list so that
25914 we check using the extra arguments. */
25915 gcc_assert (TREE_CODE (constr
) == CHECK_CONSTR
);
25916 tree cargs
= CHECK_CONSTR_ARGS (constr
);
25917 if (TREE_VEC_LENGTH (cargs
) > 1)
25919 cargs
= copy_node (cargs
);
25920 TREE_VEC_ELT (cargs
, 0) = TREE_VEC_ELT (targs
, 0);
25924 if (!constraints_satisfied_p (constr
, cargs
))
25926 if (complain
& tf_warning_or_error
)
25930 case adc_unspecified
:
25932 error("placeholder constraints not satisfied");
25934 case adc_variable_type
:
25935 case adc_decomp_type
:
25936 error ("deduced initializer does not satisfy "
25937 "placeholder constraints");
25939 case adc_return_type
:
25940 error ("deduced return type does not satisfy "
25941 "placeholder constraints");
25943 case adc_requirement
:
25944 error ("deduced expression type does not satisfy "
25945 "placeholder constraints");
25948 diagnose_constraints (input_location
, constr
, targs
);
25950 return error_mark_node
;
25954 if (processing_template_decl
&& context
!= adc_unify
)
25955 outer_targs
= current_template_args ();
25956 targs
= add_to_template_args (outer_targs
, targs
);
25957 return tsubst (type
, targs
, complain
, NULL_TREE
);
25960 /* Substitutes LATE_RETURN_TYPE for 'auto' in TYPE and returns the
25964 splice_late_return_type (tree type
, tree late_return_type
)
25966 if (is_auto (type
))
25968 if (late_return_type
)
25969 return late_return_type
;
25971 tree idx
= get_template_parm_index (type
);
25972 if (TEMPLATE_PARM_LEVEL (idx
) <= processing_template_decl
)
25973 /* In an abbreviated function template we didn't know we were dealing
25974 with a function template when we saw the auto return type, so update
25975 it to have the correct level. */
25976 return make_auto_1 (TYPE_IDENTIFIER (type
), true);
25981 /* Returns true iff TYPE is a TEMPLATE_TYPE_PARM representing 'auto' or
25982 'decltype(auto)' or a deduced class template. */
25985 is_auto (const_tree type
)
25987 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
25988 && (TYPE_IDENTIFIER (type
) == auto_identifier
25989 || TYPE_IDENTIFIER (type
) == decltype_auto_identifier
25990 || CLASS_PLACEHOLDER_TEMPLATE (type
)))
25996 /* for_each_template_parm callback for type_uses_auto. */
25999 is_auto_r (tree tp
, void */
*data*/
)
26001 return is_auto (tp
);
26004 /* Returns the TEMPLATE_TYPE_PARM in TYPE representing `auto' iff TYPE contains
26005 a use of `auto'. Returns NULL_TREE otherwise. */
26008 type_uses_auto (tree type
)
26010 if (type
== NULL_TREE
)
26012 else if (flag_concepts
)
26014 /* The Concepts TS allows multiple autos in one type-specifier; just
26015 return the first one we find, do_auto_deduction will collect all of
26017 if (uses_template_parms (type
))
26018 return for_each_template_parm (type
, is_auto_r
, /*data*/NULL
,
26019 /*visited*/NULL
, /*nondeduced*/true);
26024 return find_type_usage (type
, is_auto
);
26027 /* For a given template T, return the vector of typedefs referenced
26028 in T for which access check is needed at T instantiation time.
26029 T is either a FUNCTION_DECL or a RECORD_TYPE.
26030 Those typedefs were added to T by the function
26031 append_type_to_template_for_access_check. */
26033 vec
<qualified_typedef_usage_t
, va_gc
> *
26034 get_types_needing_access_check (tree t
)
26037 vec
<qualified_typedef_usage_t
, va_gc
> *result
= NULL
;
26039 if (!t
|| t
== error_mark_node
)
26042 if (!(ti
= get_template_info (t
)))
26045 if (CLASS_TYPE_P (t
)
26046 || TREE_CODE (t
) == FUNCTION_DECL
)
26048 if (!TI_TEMPLATE (ti
))
26051 result
= TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
);
26057 /* Append the typedef TYPE_DECL used in template T to a list of typedefs
26058 tied to T. That list of typedefs will be access checked at
26059 T instantiation time.
26060 T is either a FUNCTION_DECL or a RECORD_TYPE.
26061 TYPE_DECL is a TYPE_DECL node representing a typedef.
26062 SCOPE is the scope through which TYPE_DECL is accessed.
26063 LOCATION is the location of the usage point of TYPE_DECL.
26065 This function is a subroutine of
26066 append_type_to_template_for_access_check. */
26069 append_type_to_template_for_access_check_1 (tree t
,
26072 location_t location
)
26074 qualified_typedef_usage_t typedef_usage
;
26077 if (!t
|| t
== error_mark_node
)
26080 gcc_assert ((TREE_CODE (t
) == FUNCTION_DECL
26081 || CLASS_TYPE_P (t
))
26083 && TREE_CODE (type_decl
) == TYPE_DECL
26086 if (!(ti
= get_template_info (t
)))
26089 gcc_assert (TI_TEMPLATE (ti
));
26091 typedef_usage
.typedef_decl
= type_decl
;
26092 typedef_usage
.context
= scope
;
26093 typedef_usage
.locus
= location
;
26095 vec_safe_push (TI_TYPEDEFS_NEEDING_ACCESS_CHECKING (ti
), typedef_usage
);
26098 /* Append TYPE_DECL to the template TEMPL.
26099 TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
26100 At TEMPL instanciation time, TYPE_DECL will be checked to see
26101 if it can be accessed through SCOPE.
26102 LOCATION is the location of the usage point of TYPE_DECL.
26104 e.g. consider the following code snippet:
26111 template<class U> struct S
26113 C::myint mi; // <-- usage point of the typedef C::myint
26118 At S<char> instantiation time, we need to check the access of C::myint
26119 In other words, we need to check the access of the myint typedef through
26120 the C scope. For that purpose, this function will add the myint typedef
26121 and the scope C through which its being accessed to a list of typedefs
26122 tied to the template S. That list will be walked at template instantiation
26123 time and access check performed on each typedefs it contains.
26124 Note that this particular code snippet should yield an error because
26125 myint is private to C. */
26128 append_type_to_template_for_access_check (tree templ
,
26131 location_t location
)
26133 qualified_typedef_usage_t
*iter
;
26136 gcc_assert (type_decl
&& (TREE_CODE (type_decl
) == TYPE_DECL
));
26138 /* Make sure we don't append the type to the template twice. */
26139 FOR_EACH_VEC_SAFE_ELT (get_types_needing_access_check (templ
), i
, iter
)
26140 if (iter
->typedef_decl
== type_decl
&& scope
== iter
->context
)
26143 append_type_to_template_for_access_check_1 (templ
, type_decl
,
26147 /* Convert the generic type parameters in PARM that match the types given in the
26148 range [START_IDX, END_IDX) from the current_template_parms into generic type
26152 convert_generic_types_to_packs (tree parm
, int start_idx
, int end_idx
)
26154 tree current
= current_template_parms
;
26155 int depth
= TMPL_PARMS_DEPTH (current
);
26156 current
= INNERMOST_TEMPLATE_PARMS (current
);
26157 tree replacement
= make_tree_vec (TREE_VEC_LENGTH (current
));
26159 for (int i
= 0; i
< start_idx
; ++i
)
26160 TREE_VEC_ELT (replacement
, i
)
26161 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
26163 for (int i
= start_idx
; i
< end_idx
; ++i
)
26165 /* Create a distinct parameter pack type from the current parm and add it
26166 to the replacement args to tsubst below into the generic function
26169 tree o
= TREE_TYPE (TREE_VALUE
26170 (TREE_VEC_ELT (current
, i
)));
26171 tree t
= copy_type (o
);
26172 TEMPLATE_TYPE_PARM_INDEX (t
)
26173 = reduce_template_parm_level (TEMPLATE_TYPE_PARM_INDEX (o
),
26175 TREE_TYPE (TEMPLATE_TYPE_DECL (t
)) = t
;
26176 TYPE_STUB_DECL (t
) = TYPE_NAME (t
) = TEMPLATE_TYPE_DECL (t
);
26177 TYPE_MAIN_VARIANT (t
) = t
;
26178 TEMPLATE_TYPE_PARAMETER_PACK (t
) = true;
26179 TYPE_CANONICAL (t
) = canonical_type_parameter (t
);
26180 TREE_VEC_ELT (replacement
, i
) = t
;
26181 TREE_VALUE (TREE_VEC_ELT (current
, i
)) = TREE_CHAIN (t
);
26184 for (int i
= end_idx
, e
= TREE_VEC_LENGTH (current
); i
< e
; ++i
)
26185 TREE_VEC_ELT (replacement
, i
)
26186 = TREE_TYPE (TREE_VALUE (TREE_VEC_ELT (current
, i
)));
26188 /* If there are more levels then build up the replacement with the outer
26191 replacement
= add_to_template_args (template_parms_to_args
26192 (TREE_CHAIN (current_template_parms
)),
26195 return tsubst (parm
, replacement
, tf_none
, NULL_TREE
);
26198 /* Entries in the decl_constraint hash table. */
26199 struct GTY((for_user
)) constr_entry
26205 /* Hashing function and equality for constraint entries. */
26206 struct constr_hasher
: ggc_ptr_hash
<constr_entry
>
26208 static hashval_t
hash (constr_entry
*e
)
26210 return (hashval_t
)DECL_UID (e
->decl
);
26213 static bool equal (constr_entry
*e1
, constr_entry
*e2
)
26215 return e1
->decl
== e2
->decl
;
26219 /* A mapping from declarations to constraint information. Note that
26220 both templates and their underlying declarations are mapped to the
26221 same constraint information.
26223 FIXME: This is defined in pt.c because garbage collection
26224 code is not being generated for constraint.cc. */
26226 static GTY (()) hash_table
<constr_hasher
> *decl_constraints
;
26228 /* Returns the template constraints of declaration T. If T is not
26229 constrained, return NULL_TREE. Note that T must be non-null. */
26232 get_constraints (tree t
)
26234 if (!flag_concepts
)
26237 gcc_assert (DECL_P (t
));
26238 if (TREE_CODE (t
) == TEMPLATE_DECL
)
26239 t
= DECL_TEMPLATE_RESULT (t
);
26240 constr_entry elt
= { t
, NULL_TREE
};
26241 constr_entry
* found
= decl_constraints
->find (&elt
);
26248 /* Associate the given constraint information CI with the declaration
26249 T. If T is a template, then the constraints are associated with
26250 its underlying declaration. Don't build associations if CI is
26254 set_constraints (tree t
, tree ci
)
26258 gcc_assert (t
&& flag_concepts
);
26259 if (TREE_CODE (t
) == TEMPLATE_DECL
)
26260 t
= DECL_TEMPLATE_RESULT (t
);
26261 gcc_assert (!get_constraints (t
));
26262 constr_entry elt
= {t
, ci
};
26263 constr_entry
** slot
= decl_constraints
->find_slot (&elt
, INSERT
);
26264 constr_entry
* entry
= ggc_alloc
<constr_entry
> ();
26269 /* Remove the associated constraints of the declaration T. */
26272 remove_constraints (tree t
)
26274 gcc_assert (DECL_P (t
));
26275 if (TREE_CODE (t
) == TEMPLATE_DECL
)
26276 t
= DECL_TEMPLATE_RESULT (t
);
26278 constr_entry elt
= {t
, NULL_TREE
};
26279 constr_entry
** slot
= decl_constraints
->find_slot (&elt
, NO_INSERT
);
26281 decl_constraints
->clear_slot (slot
);
26284 /* Memoized satisfaction results for declarations. This
26285 maps the pair (constraint_info, arguments) to the result computed
26286 by constraints_satisfied_p. */
26288 struct GTY((for_user
)) constraint_sat_entry
26295 /* Hashing function and equality for constraint entries. */
26297 struct constraint_sat_hasher
: ggc_ptr_hash
<constraint_sat_entry
>
26299 static hashval_t
hash (constraint_sat_entry
*e
)
26301 hashval_t val
= iterative_hash_object(e
->ci
, 0);
26302 return iterative_hash_template_arg (e
->args
, val
);
26305 static bool equal (constraint_sat_entry
*e1
, constraint_sat_entry
*e2
)
26307 return e1
->ci
== e2
->ci
&& comp_template_args (e1
->args
, e2
->args
);
26311 /* Memoized satisfaction results for concept checks. */
26313 struct GTY((for_user
)) concept_spec_entry
26320 /* Hashing function and equality for constraint entries. */
26322 struct concept_spec_hasher
: ggc_ptr_hash
<concept_spec_entry
>
26324 static hashval_t
hash (concept_spec_entry
*e
)
26326 return hash_tmpl_and_args (e
->tmpl
, e
->args
);
26329 static bool equal (concept_spec_entry
*e1
, concept_spec_entry
*e2
)
26331 ++comparing_specializations
;
26332 bool eq
= e1
->tmpl
== e2
->tmpl
&& comp_template_args (e1
->args
, e2
->args
);
26333 --comparing_specializations
;
26338 static GTY (()) hash_table
<constraint_sat_hasher
> *constraint_memos
;
26339 static GTY (()) hash_table
<concept_spec_hasher
> *concept_memos
;
26341 /* Search for a memoized satisfaction result. Returns one of the
26342 truth value nodes if previously memoized, or NULL_TREE otherwise. */
26345 lookup_constraint_satisfaction (tree ci
, tree args
)
26347 constraint_sat_entry elt
= { ci
, args
, NULL_TREE
};
26348 constraint_sat_entry
* found
= constraint_memos
->find (&elt
);
26350 return found
->result
;
26355 /* Memoize the result of a satisfication test. Returns the saved result. */
26358 memoize_constraint_satisfaction (tree ci
, tree args
, tree result
)
26360 constraint_sat_entry elt
= {ci
, args
, result
};
26361 constraint_sat_entry
** slot
= constraint_memos
->find_slot (&elt
, INSERT
);
26362 constraint_sat_entry
* entry
= ggc_alloc
<constraint_sat_entry
> ();
26368 /* Search for a memoized satisfaction result for a concept. */
26371 lookup_concept_satisfaction (tree tmpl
, tree args
)
26373 concept_spec_entry elt
= { tmpl
, args
, NULL_TREE
};
26374 concept_spec_entry
* found
= concept_memos
->find (&elt
);
26376 return found
->result
;
26381 /* Memoize the result of a concept check. Returns the saved result. */
26384 memoize_concept_satisfaction (tree tmpl
, tree args
, tree result
)
26386 concept_spec_entry elt
= {tmpl
, args
, result
};
26387 concept_spec_entry
** slot
= concept_memos
->find_slot (&elt
, INSERT
);
26388 concept_spec_entry
* entry
= ggc_alloc
<concept_spec_entry
> ();
26394 static GTY (()) hash_table
<concept_spec_hasher
> *concept_expansions
;
26396 /* Returns a prior concept specialization. This returns the substituted
26397 and normalized constraints defined by the concept. */
26400 get_concept_expansion (tree tmpl
, tree args
)
26402 concept_spec_entry elt
= { tmpl
, args
, NULL_TREE
};
26403 concept_spec_entry
* found
= concept_expansions
->find (&elt
);
26405 return found
->result
;
26410 /* Save a concept expansion for later. */
26413 save_concept_expansion (tree tmpl
, tree args
, tree def
)
26415 concept_spec_entry elt
= {tmpl
, args
, def
};
26416 concept_spec_entry
** slot
= concept_expansions
->find_slot (&elt
, INSERT
);
26417 concept_spec_entry
* entry
= ggc_alloc
<concept_spec_entry
> ();
26424 hash_subsumption_args (tree t1
, tree t2
)
26426 gcc_assert (TREE_CODE (t1
) == CHECK_CONSTR
);
26427 gcc_assert (TREE_CODE (t2
) == CHECK_CONSTR
);
26429 val
= iterative_hash_object (CHECK_CONSTR_CONCEPT (t1
), val
);
26430 val
= iterative_hash_template_arg (CHECK_CONSTR_ARGS (t1
), val
);
26431 val
= iterative_hash_object (CHECK_CONSTR_CONCEPT (t2
), val
);
26432 val
= iterative_hash_template_arg (CHECK_CONSTR_ARGS (t2
), val
);
26436 /* Compare the constraints of two subsumption entries. The LEFT1 and
26437 LEFT2 arguments comprise the first subsumption pair and the RIGHT1
26438 and RIGHT2 arguments comprise the second. These are all CHECK_CONSTRs. */
26441 comp_subsumption_args (tree left1
, tree left2
, tree right1
, tree right2
)
26443 if (CHECK_CONSTR_CONCEPT (left1
) == CHECK_CONSTR_CONCEPT (right1
))
26444 if (CHECK_CONSTR_CONCEPT (left2
) == CHECK_CONSTR_CONCEPT (right2
))
26445 if (comp_template_args (CHECK_CONSTR_ARGS (left1
),
26446 CHECK_CONSTR_ARGS (right1
)))
26447 return comp_template_args (CHECK_CONSTR_ARGS (left2
),
26448 CHECK_CONSTR_ARGS (right2
));
26452 /* Key/value pair for learning and memoizing subsumption results. This
26453 associates a pair of check constraints (including arguments) with
26454 a boolean value indicating the result. */
26456 struct GTY((for_user
)) subsumption_entry
26463 /* Hashing function and equality for constraint entries. */
26465 struct subsumption_hasher
: ggc_ptr_hash
<subsumption_entry
>
26467 static hashval_t
hash (subsumption_entry
*e
)
26469 return hash_subsumption_args (e
->t1
, e
->t2
);
26472 static bool equal (subsumption_entry
*e1
, subsumption_entry
*e2
)
26474 ++comparing_specializations
;
26475 bool eq
= comp_subsumption_args(e1
->t1
, e1
->t2
, e2
->t1
, e2
->t2
);
26476 --comparing_specializations
;
26481 static GTY (()) hash_table
<subsumption_hasher
> *subsumption_table
;
26483 /* Search for a previously cached subsumption result. */
26486 lookup_subsumption_result (tree t1
, tree t2
)
26488 subsumption_entry elt
= { t1
, t2
, false };
26489 subsumption_entry
* found
= subsumption_table
->find (&elt
);
26491 return &found
->result
;
26496 /* Save a subsumption result. */
26499 save_subsumption_result (tree t1
, tree t2
, bool result
)
26501 subsumption_entry elt
= {t1
, t2
, result
};
26502 subsumption_entry
** slot
= subsumption_table
->find_slot (&elt
, INSERT
);
26503 subsumption_entry
* entry
= ggc_alloc
<subsumption_entry
> ();
26509 /* Set up the hash table for constraint association. */
26512 init_constraint_processing (void)
26514 if (!flag_concepts
)
26517 decl_constraints
= hash_table
<constr_hasher
>::create_ggc(37);
26518 constraint_memos
= hash_table
<constraint_sat_hasher
>::create_ggc(37);
26519 concept_memos
= hash_table
<concept_spec_hasher
>::create_ggc(37);
26520 concept_expansions
= hash_table
<concept_spec_hasher
>::create_ggc(37);
26521 subsumption_table
= hash_table
<subsumption_hasher
>::create_ggc(37);
26524 /* __integer_pack(N) in a pack expansion expands to a sequence of numbers from
26528 declare_integer_pack (void)
26530 tree ipfn
= push_library_fn (get_identifier ("__integer_pack"),
26531 build_function_type_list (integer_type_node
,
26534 NULL_TREE
, ECF_CONST
);
26535 DECL_DECLARED_CONSTEXPR_P (ipfn
) = true;
26536 DECL_BUILT_IN_CLASS (ipfn
) = BUILT_IN_FRONTEND
;
26539 /* Set up the hash tables for template instantiations. */
26542 init_template_processing (void)
26544 decl_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
26545 type_specializations
= hash_table
<spec_hasher
>::create_ggc (37);
26547 if (cxx_dialect
>= cxx11
)
26548 declare_integer_pack ();
26551 /* Print stats about the template hash tables for -fstats. */
26554 print_template_statistics (void)
26556 fprintf (stderr
, "decl_specializations: size %ld, %ld elements, "
26557 "%f collisions\n", (long) decl_specializations
->size (),
26558 (long) decl_specializations
->elements (),
26559 decl_specializations
->collisions ());
26560 fprintf (stderr
, "type_specializations: size %ld, %ld elements, "
26561 "%f collisions\n", (long) type_specializations
->size (),
26562 (long) type_specializations
->elements (),
26563 type_specializations
->collisions ());
26566 #include "gt-cp-pt.h"